SumBundleHandler.hxx

Go to the documentation of this file.

#ifndef CONICBUNDLE_SUMBUNDLEHANDLER_HXX
#define CONICBUNDLE_SUMBUNDLEHANDLER_HXX


#include "SumBundle.hxx"
//#include "BundleModel.hxx"
#include "SumBundleParametersObject.hxx"

namespace ConicBundle {


class SumBundleHandler: public CBout
{ 
private:
  SumBundle* sumbundle;

  SumBundleHandler* parent_handler;
  const AffineFunctionTransformation* aft;

  class BundleInformation
  {
  public:
    SumBundleParametersObject* sbp; 
    CH_Matrix_Classes::Integer bundle_size;      
    CH_Matrix_Classes::Integer aggr_index;       
    CH_Matrix_Classes::Integer new_index;        
    CH_Matrix_Classes::Indexmatrix map_to_old;   
    CH_Matrix_Classes::Indexmatrix model_indices; 
    CH_Matrix_Classes::Matrix old_lowrank;  
    CH_Matrix_Classes::Matrix old_diagonal; 
    CH_Matrix_Classes::Symmatrix old_sym; 

    QPConeModelDataObject* block;                           
    CH_Matrix_Classes::Real increase_factor;     

    //the following avoid introducing further function argumetns in start_augmodel
    CH_Matrix_Classes::Real tmodel_maxviol; 
    CH_Matrix_Classes::Real tweightu; 
    BundleModel::ModelUpdate tmodel_update; 

    BundleInformation();

    ~BundleInformation();

    BundleInformation& operator=(const BundleInformation& bi);
  };

  
  typedef std::vector<BundleInformation*> BundleInformationVector;
  BundleInformationVector bundleinfo;

  int init(FunctionTask ft,CH_Matrix_Classes::Real funfactor,const BundleParameters* bp);

  int set_bundle_parameters(FunctionTask ft,const BundleParameters& bp);

  int store_aggregate(FunctionTask ft); 

  int reassign_minorants(const CH_Matrix_Classes::Indexmatrix& map_to_old,FunctionTask ft);


  int make_model_aggregate(FunctionTask ft);

  int provide_model_aggregate(FunctionTask ft);

  int update_model(BundleModel::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,
                   FunctionTask ft);

  int eval_model(CH_Matrix_Classes::Real& lb,CH_Matrix_Classes::Integer yid,const CH_Matrix_Classes::Matrix& y,FunctionTask ft) const;

  CH_Matrix_Classes::Real lb_model(CH_Matrix_Classes::Integer yid,const CH_Matrix_Classes::Matrix& y,FunctionTask ft) const;
  
  int contribute_new_minorants(FunctionTask ft);

  int remove_contributions(FunctionTask ft);

  int add_contributions(FunctionTask ft);

  int align_bundle(bool use_parent_update,FunctionTask ft);

  int align_bundle(bool use_parent_update);

  void clear_model(FunctionTask ft);

  void clear_aggregates(FunctionTask ft);


public:

  SumBundleHandler(SumBundle& sb,const std::map<FunctionTask,CH_Matrix_Classes::Real>& factor_map,const BundleParameters* bp=0);
  ~SumBundleHandler();

  const SumBundle* get_sumbundle() const {return sumbundle;}

  bool handles(FunctionTask ft)
  {return (sumbundle->has_bundle_for(ft));}

  CH_Matrix_Classes::Integer get_new_index(FunctionTask ft) const
  {const BundleInformation* bi=bundleinfo[ft]; return (bi==0)?-1:bi->new_index;}

  bool initialization_needed(FunctionTask ft) const;

  bool initialization_needed() const;

  int set_parent_information(SumBundleHandler *parent_sbh,const AffineFunctionTransformation* aft,SumBundle::Mode in_mode); 

  int reset_function_factor(FunctionTask ft,CH_Matrix_Classes::Real factor);

  int set_bundle_parameters(const BundleParameters& bp);


  CH_Matrix_Classes::Real get_increase_factor() const;

  int update_model(BundleModel::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 eval_model(CH_Matrix_Classes::Real& lb,CH_Matrix_Classes::Integer yid,const CH_Matrix_Classes::Matrix& y) const;

  CH_Matrix_Classes::Real lb_model(CH_Matrix_Classes::Integer yid,const CH_Matrix_Classes::Matrix& y) const;
  

  int normalize_sumbundle();

  int contribute_new_minorants();

  int remove_contributions();

  int add_contributions();

  int start_augmodel(QPModelDataPointer& bp,
                     CH_Matrix_Classes::Integer cand_id,
                     const CH_Matrix_Classes::Matrix& cand_y,
                     const CH_Matrix_Classes::Indexmatrix* indices,
                     FunctionTask ft);

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


  int make_model_aggregate(bool& increased, bool fixed);
  
  int provide_model_aggregate();
  
  int adjust_multiplier(bool& values_may_have_changed);
  
  int contribute_initial_bundle(FunctionTask ft,
                                const MinorantBundle& bundle_minorants,
                                const CH_Matrix_Classes::Matrix& coeff);
   
  int install_external_aggregate(FunctionTask ft,
                                 const MinorantPointer& aggr,
                                 CH_Matrix_Classes::Real aggr_coeff);
   

  int set_cand_minorant(FunctionTask ft,
                       const MinorantPointer& minorant);

  void clear_model();

  void clear_aggregates();

  void clear_cand_minorants();

  int append_vars(FunctionTask ft,const CH_Matrix_Classes::Matrix& append_mat);

  int reassign_vars(FunctionTask ft,const CH_Matrix_Classes::Indexmatrix& map_to_old);

  int add_variable_metric(FunctionTask ft,
                          VariableMetric& H,
                          CH_Matrix_Classes::Integer yid,
                          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 add_variable_metric(VariableMetric& H,
                          CH_Matrix_Classes::Integer yid,
                          const CH_Matrix_Classes::Matrix& center_y,
                          bool descent_step,
                          CH_Matrix_Classes::Real weightu,
                          CH_Matrix_Classes::Real model_maxviol,
                          const CH_Matrix_Classes::Indexmatrix* indices=0);


  CH_Matrix_Classes::Real guess_curvature(const MinorantBundle& mnrts,
                                          const CH_Matrix_Classes::Indexmatrix& selected_indices,
                                          CH_Matrix_Classes::Integer cand_id,
                                          const CH_Matrix_Classes::Matrix& cand_y,
                                          CH_Matrix_Classes::Real model_maxviol) const;

};





}

#endif