SumBlockModel.hxx

Go to the documentation of this file.

#ifndef CONICBUNDLE_SUMBLOCKMODEL_HXX
#define CONICBUNDLE_SUMBLOCKMODEL_HXX


#include "clock.hxx"
#include "MatrixCBSolver.hxx"
#include "BundleModel.hxx"
#include "AffineFunctionTransformation.hxx"
#include "BundleData.hxx"
#include "SumBundleHandler.hxx"

namespace ConicBundle {



  class AFTModel; 

class SumBlockModel: public BundleModel
{
 protected:
  CH_Tools::Clock clock;      
  CH_Tools::Microseconds evalmodel_time; 
  CH_Tools::Microseconds updatemodel_time; 
  CH_Tools::Microseconds eval_time; 
  CH_Tools::Microseconds preeval_time; 
  CH_Tools::Microseconds posteval_time; 
  CH_Tools::Microseconds metric_time; 

  //--- every SumBlockModel can be equipped with its own affine function transformation
  AFTModel* aftmodel; 

  //--- every SumBlockModel can be equipped with its own VariableMetricSelection
  VariableMetricSelection* vm_selection; 

  //--- the bundle handler for contributing to a parent sumbundle
  SumBundleHandler* bundlehandler;
  SumBundleParametersObject* sumbundle_parameters;

  //--- for testing purposes
  mutable MinorantPointer old_model_aggregate;
   
  
 public:
  virtual ~SumBlockModel();
   
  virtual void clear(); 

  int initialize_aft(AffineFunctionTransformation* aft=0);

  virtual int set_variable_metric_selection(VariableMetricSelection* vms=0)
  { delete vm_selection; vm_selection=vms; return 0;}

  virtual VariableMetricSelection* get_variable_metric_selection() const
  { return vm_selection;}

  bool call_aftmodel_first(const FunObjModMap& funmdfmap);

  SumBlockModel(CBout* cb=0,int cbinc=-1);

  virtual ModifiableOracleObject* get_oracle_object() =0;

  virtual const SumBlockModel* model(const FunctionObject* /* fo */) const
  {return 0;}

  virtual CH_Matrix_Classes::Integer nsubmodels() const 
  {return 0;}

  virtual int add_model(SumBlockModel* /* model */)
  {return 1;}

  virtual SumBlockModel* remove_model(const FunctionObject* /* fo */)
  {return 0;}  
  
  virtual SumBlockModel* remove_model(SumBlockModel* model)
  {
    if (model!=0)
      return remove_model(dynamic_cast<FunctionObject*>(model->get_oracle_object()));
    return 0;
  }


  
  //----------------------------------------------------------------------

  //virtual int eval_function(...)=0; is still abstract 

  //virtual int eval_model(...) =0;  is still abstract

  virtual int start_augmodel(QPModelDataPointer& blockp,
                             CH_Matrix_Classes::Integer cand_id,
                             const CH_Matrix_Classes::Matrix& cand_y,
                             const CH_Matrix_Classes::Indexmatrix* indices=0);


  // virtual int start_augmodel(......) =0; is still abstract

  // virtual int make_model_aggregate(..)=0; is still abstract 

  virtual int get_model_aggregate(CH_Matrix_Classes::Integer& model_aggregate_id,
                                  MinorantPointer& model_aggregate);

  //see BundleModel::update_model() it is still abstract
  virtual int update_model(ModelUpdate model_update,
                           CH_Matrix_Classes::Integer center_id,
                           const CH_Matrix_Classes::Matrix& center_y,
                           CH_Matrix_Classes::Integer cand_id,
                           const CH_Matrix_Classes::Matrix& cand_y,
                           CH_Matrix_Classes::Real model_maxviol,
                           BundleProxObject& H) =0;

  virtual int synchronize_ids(CH_Matrix_Classes::Integer& new_center_ub_fid, 
                              CH_Matrix_Classes::Integer new_center_id,
                              CH_Matrix_Classes::Integer old_center_id,
                              CH_Matrix_Classes::Integer& new_cand_ub_fid, 
                              CH_Matrix_Classes::Integer new_cand_id,
                              CH_Matrix_Classes::Integer old_cand_id,
                              CH_Matrix_Classes::Integer& new_aggregate_id);

  virtual bool center_modified(CH_Matrix_Classes::Integer& center_fid, 
                               CH_Matrix_Classes::Integer center_id);

  //virtual bool recompute_center(...) =0;  is still abstract

  virtual bool model_aggregate_modified(CH_Matrix_Classes::Integer old_model_aggregate_id);

  //virtual int provide_model_aggregate(...) =0; is still abstract

  virtual int apply_modification(bool& no_changes,
                                 const GroundsetModification& gsmdf,
                                 const FunObjModMap& funmdfmap,
                                 CH_Matrix_Classes::Integer new_center_id,
                                 const CH_Matrix_Classes::Matrix& new_center,
                                 CH_Matrix_Classes::Integer old_center_id,
                                 const CH_Matrix_Classes::Matrix& old_center);

  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 int check_center_validity_by_candidate(...)=0; is still abstract

  int get_function_minorant(CH_Matrix_Classes::Integer& function_modification_id,MinorantPointer& minorant);

  int get_center_minorant(CH_Matrix_Classes::Integer& function_modification_id,MinorantPointer& minorant);

  BundleModel* transform();


  //----------------------------------------------------------------------

  SumBlockModel* sbm_transform();



   virtual int get_model_aggregate(CH_Matrix_Classes::Integer& model_aggregate_id,
                                   MinorantPointer& model_aggregate,
                                   bool all_parts,
                                   const AffineFunctionTransformation* aft=0);

  virtual CH_Matrix_Classes::Real lb_function(CH_Matrix_Classes::Integer y_id,
                                              const CH_Matrix_Classes::Matrix& y);

  virtual int get_function_minorant(MinorantPointer& function_minorant,
                                    const AffineFunctionTransformation* aft=0)=0;

  virtual int get_center_minorant(MinorantPointer& center_minorant,
                                  const AffineFunctionTransformation* aft=0)=0;

  
  //-------- messages needed, if online problem modifications are desired
  //         these messages are passed on recursively by SumModel and AFTModel


  virtual int adjust_multiplier(bool& values_may_have_changed)=0;


  virtual int sumbundle_mode(SumBundle::Mode& mode,
                     SumBundleHandler* bh=0,
                     AffineFunctionTransformation* aft=0)=0;

  virtual int start_sumaugmodel(QPModelDataPointer& blockp,
                                CH_Matrix_Classes::Integer cand_id,
                                const CH_Matrix_Classes::Matrix& cand_y,
                                const CH_Matrix_Classes::Indexmatrix* indices=0,
                                SumBundleHandler* bh=0,
                                SumBundle::Mode mode=SumBundle::inactive,
                                AffineFunctionTransformation* aft=0)=0;


  virtual int update_model(ModelUpdate model_update,
                           CH_Matrix_Classes::Integer center_id,
                           const CH_Matrix_Classes::Matrix& center_y,
                           CH_Matrix_Classes::Integer cand_id,
                           const CH_Matrix_Classes::Matrix& cand_y,
                           CH_Matrix_Classes::Real model_maxviol,
                           BundleProxObject& H,
                           CH_Matrix_Classes::Real& model_deviation,
                           CH_Matrix_Classes::Real& model_curvature)=0;



  //----------------------------------------------------------------------

  AFTModel* get_aftmodel() {return aftmodel;}

  const AFTModel* get_aftmodel() const {return aftmodel;}

  virtual BundleData* get_data() =0;

  virtual const BundleData* get_data() const =0;

  virtual int set_data(BundleData*) {return 1;}

  virtual const PrimalData* get_approximate_primal() const
  {return get_data()->get_approximate_primal();}

   virtual const PrimalData* get_center_primal() const
  {return get_data()->get_center_primal();}

  virtual const PrimalData* get_candidate_primal() const
  {return get_data()->get_candidate_primal();}

  virtual int call_primal_extender(PrimalExtender& pext)
  {return get_data()->call_primal_extender(pext);}

  virtual int set_bundle_parameters(const BundleParameters& )
  {return 1;}

  virtual const BundleParameters* get_bundle_parameters() const
  {return 0;}

  virtual int set_sumbundle_parameters(const BundleParameters& );

  virtual const SumBundleParametersObject* get_sumbundle_parameters() const
  {return sumbundle_parameters;}

  virtual void clear_model(bool discard_minorants_only=false)
  {get_data()->clear_model(discard_minorants_only);}

  virtual void clear_aggregates()
  {get_data()->clear_aggregates();}

  virtual int get_ret_code() const 
  {return 0;}



  //---------------------------------------------------------------------- 
  
  CH_Tools::Microseconds get_evalmodel_time() const {return evalmodel_time;}
  CH_Tools::Microseconds get_updatemodel_time() const {return updatemodel_time;}  
  virtual CH_Tools::Microseconds get_preeval_time() const {return preeval_time;}
  virtual CH_Tools::Microseconds get_eval_time() const {return eval_time;}
  virtual CH_Tools::Microseconds get_posteval_time() const {return posteval_time;}
  CH_Tools::Microseconds get_metric_time() const {return metric_time;}

  std::ostream& print_statistics(std::ostream& out) const;

  void set_out(std::ostream* o=0,int pril=1)
  {
    CBout::set_out(o,pril);
    get_data()->set_cbout(this);
    if (vm_selection)
      vm_selection->set_cbout(this,0);
  }

  void set_cbout(const CBout* cb,int incr)
  {
    set_out(cb->get_out_ptr(),cb->get_print_level()+incr);
  }

};


}

#endif