SumModel.hxx

Go to the documentation of this file.

#ifndef CONICBUNDLE_SUMMODEL_HXX
#define CONICBUNDLE_SUMMODEL_HXX

#include <list>
#include "SumBlockModel.hxx"
#include "AFTModel.hxx"

namespace ConicBundle {

class SumModelParametersObject;  

class SumModel: public SumBlockModel
{
public:
  //==================  models description ====================
  class ModelData
  {
    friend SumModel;   
  private:
    SumBlockModel* oracle_model; 
    CH_Matrix_Classes::Integer function_id;
    CH_Matrix_Classes::Integer center_ub_fid;
    CH_Matrix_Classes::Integer cand_ub_fid;
    CH_Matrix_Classes::Integer aggregate_id;

    CH_Matrix_Classes::Real model_deviation;

    CH_Matrix_Classes::Real deviation_contribution;

    CH_Matrix_Classes::Real model_curvature;

    CH_Matrix_Classes::Real weighted_curvature;

    SumBundle::Mode suggested_mode;

  public:
    SumBlockModel* model() const
    {return oracle_model->sbm_transform();}
    ~ModelData();
    ModelData(SumBlockModel* oracle_model);

    CH_Matrix_Classes::Real get_model_deviation() const
    {return model_deviation;}

    CH_Matrix_Classes::Real get_model_curvature() const
    {return model_curvature;}

    CH_Matrix_Classes::Real& set_deviation_contribution() 
    {return deviation_contribution;}

    CH_Matrix_Classes::Real& set_weighted_curvature() 
    {return weighted_curvature;}

    SumBundle::Mode& set_suggested_mode() 
    {return suggested_mode;}
  };

  typedef std::map<const FunctionObject*,ModelData*> ModelMap; 
  
private:
  //==================  dummy oracle  =====================
  ModifiableOracleObject dummy_oracle;

  //--- data describing the model
  BundleData data;

  ModelMap modelmap; 

  std::list<const ModelData*> local_augmodel;

  //=================== data of function evaluations ==================
  CH_Matrix_Classes::Integer ncalls;

  MinorantPointer cand_minorant;

  MinorantPointer center_minorant;

   
  //===================  quadratic subproblems ==================
  QPSumModelDataObject* block;

  SumModelParametersObject* model_selection;


public:
  void clear();

  SumModel(CBout* cb=0);

  ~SumModel();

  const SumBlockModel* model(const FunctionObject* fo) const;

  CH_Matrix_Classes::Integer nsubmodels() const 
  {return CH_Matrix_Classes::Integer(modelmap.size());}

  int add_model(SumBlockModel* model);

  SumBlockModel* remove_model(const FunctionObject* fo);
  

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

  int eval_function(CH_Matrix_Classes::Integer& ub_fid,
                    CH_Matrix_Classes::Real& ub,
                    CH_Matrix_Classes::Integer y_id,
                    const CH_Matrix_Classes::Matrix& y,
                    CH_Matrix_Classes::Real nullstep_bound,
                    CH_Matrix_Classes::Real relprec);


  int eval_model(CH_Matrix_Classes::Real& lb, 
                 CH_Matrix_Classes::Integer y_id,
                 const CH_Matrix_Classes::Matrix& y,
                 CH_Matrix_Classes::Real relprec);

  //eval_augmodel           //as in SumBlockModel
 
  //reeval_augmodel         //as in SumBlockModel

  //get_model_aggregate(three parameters) //as in SumBlockModel

  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);

  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);

  bool center_modified(CH_Matrix_Classes::Integer& function_modification_id,
                       CH_Matrix_Classes::Integer center_id);

  int recompute_center(CH_Matrix_Classes::Integer& new_center_ub_fid,
                       CH_Matrix_Classes::Real& new_center_ub,
                       CH_Matrix_Classes::Integer center_id,
                       const CH_Matrix_Classes::Matrix& y,
                       bool accept_only_higher_values=false,
                       CH_Matrix_Classes::Real relprec=-1.);

  bool model_aggregate_modified(CH_Matrix_Classes::Integer old_model_aggregate_id);

  int provide_model_aggregate(CH_Matrix_Classes::Integer y_id,
                              const CH_Matrix_Classes::Matrix& y);

  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);

  int check_center_validity_by_candidate(bool& cand_minorant_is_below,
                                         CH_Matrix_Classes::Integer center_id,
                                         const CH_Matrix_Classes::Matrix& center_y);


  //----------------------------------------------------------------------
  
  ModifiableOracleObject* get_oracle_object() {return &dummy_oracle;}

  // start_augmodel as in SumBlockModel::start_augmode()l

  int make_model_aggregate(bool& penalty_parameter_increased,
                           bool keep_penalty_fixed);  

  // get_model_aggregate(six parameters)     //as in SumBlockModel 

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

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

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

  int adjust_multiplier(bool& values_may_have_changed);

  int sumbundle_mode(SumBundle::Mode& mode,
                     SumBundleHandler* bh=0,
                     AffineFunctionTransformation* aft=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);


  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 null_step_factor,
                   BundleProxObject& H,
                   CH_Matrix_Classes::Real& model_deviation,
                   CH_Matrix_Classes::Real& model_curvature);

  BundleData* get_data() {return &data;}

  const BundleData* get_data() const {return &data;}

  int set_data(BundleData* bd){return data.init(bd);}



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

  const PrimalData* get_approximate_primal() const {return 0;}

  const PrimalData* get_center_primal() const {return 0;}
  
  const PrimalData* get_candidate_primal() const {return 0;}

  virtual int call_primal_extender(PrimalExtender& /* pext */) {return 1;}

  int set_bundle_parameters(const BundleParameters& bp); 

  const BundleParameters* get_bundle_parameters() const;

  void clear_model(bool discard_minorants_only=false);

  void clear_aggregates(); 

  //get_ret_code()      // as in SumBlockModel


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

  //get_QPcoeff_time()      // as in SumBlockModel

  //get_QPsolve_time()      // as in SumBlockModel

  //get_evalaugmodel_time() // as in SumBlockModel

  //get_evalmodel_time()    // as in SumBlockModel

  //get_updatemodel_time()  // as in SumBlockModel

  //get_eval_time()         // as in SumBlockModel

  void set_out(std::ostream* o=0,int pril=1);

  //set_cbout()  // calls set_out in SumBlockModel

  virtual CH_Tools::Microseconds get_preeval_time() const 
  { 
    CH_Tools::Microseconds ms(preeval_time);
    for (ModelMap::const_iterator it=modelmap.begin();it!=modelmap.end();it++){
      ms+=it->second->model()->get_preeval_time();
    }
    return ms;
  }
  virtual CH_Tools::Microseconds get_eval_time() const 
  { 
    CH_Tools::Microseconds ms(0);
    for (ModelMap::const_iterator it=modelmap.begin();it!=modelmap.end();it++){
      ms+=it->second->model()->get_eval_time();
    }
    return ms;
  }

  virtual CH_Tools::Microseconds get_posteval_time() const
  { 
    CH_Tools::Microseconds ms(posteval_time);
    for (ModelMap::const_iterator it=modelmap.begin();it!=modelmap.end();it++){
      ms+=it->second->model()->get_posteval_time();
    }
    return ms;
  }




};



}

#endif