ConeModel.hxx

Go to the documentation of this file.

#ifndef CONICBUNDLE_CONEMODEL_HXX
#define CONICBUNDLE_CONEMODEL_HXX

#include "SumBlockModel.hxx"

namespace ConicBundle {


class ConeModel: public SumBlockModel
{
protected:


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


  virtual int evaluate_oracle(CH_Matrix_Classes::Integer y_id,
                              const CH_Matrix_Classes::Matrix& y,
                              CH_Matrix_Classes::Real nullstep_bound,
                              CH_Matrix_Classes::Real relprec)=0;

  virtual int evaluate_local_model(CH_Matrix_Classes::Real& lb,
                                   CH_Matrix_Classes::Integer y_id,
                                   const CH_Matrix_Classes::Matrix& y,
                                   CH_Matrix_Classes::Real relprec)=0;

  virtual int update_local_model(ModelUpdate model_update,
                                 CH_Matrix_Classes::Integer center_id,
                                 const CH_Matrix_Classes::Matrix& center_y,
                                 CH_Matrix_Classes::Integer y_id,
                                 const CH_Matrix_Classes::Matrix& y,
                                 CH_Matrix_Classes::Real model_maxviol,
                                 BundleProxObject& H)=0;


  virtual int switch_to_local( const MinorantBundle& sumbundle_model,
                             const CH_Matrix_Classes::Matrix& sumbundle_coeff)=0;

  virtual int get_aggregate_and_coefficient(MinorantPointer& sumbundle_aggr,
                                            CH_Matrix_Classes::Real& aggr_coeff)=0;
  
 virtual int start_local_augmodel(QPModelDataPointer& qpblockp,
                                  CH_Matrix_Classes::Integer cand_id,
                                  const CH_Matrix_Classes::Matrix& cand_y,
                                  const CH_Matrix_Classes::Indexmatrix* needed_indexsubset)=0;

  virtual int provide_local_aggregate(CH_Matrix_Classes::Integer y_id,
                                      const CH_Matrix_Classes::Matrix& iny)=0;

  virtual int make_local_aggregate(CH_Matrix_Classes::Real& new_function_factor,
                                   bool keep_penalty_fixed)=0;

  virtual int local_adjust_multiplier(CH_Matrix_Classes::Real& new_function_factor)=0;

  virtual bool candidate_available()=0;
  //e.g. { return (data.cand_ub_mid==data.modification_id)&&(data.cand_Ritzvec.coldim()>0); }
  
  virtual MinorantPointer& provide_cand_minorant()=0;

  virtual MinorantPointer& provide_center_minorant()=0;





  
public:    

  virtual void clear(); 

  // set_variable_metric_selection     //as in SumBlockData

  ConeModel(CBout* cb=0,int incr=-1);
    
  virtual ~ConeModel();


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

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

  //synchronize_ids       //as in SumBlockModel

  //center_modified        //as in SumBlockModel

  int recompute_center(CH_Matrix_Classes::Integer& new_center_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)
  {return get_data()->model_aggregate_modified(old_model_aggregate_id);}

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

  // apply_modification     // as in SumBlockModel

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

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

  // get_oracle_object() still abstract
  
  // start_augmodel see SumBlockModel::start_augmodel
   
  int make_model_aggregate(bool& penalty_parameter_increased,
                           bool keep_penalty_fixed);  

  //get_model_aggregate(... aft=0)   //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);


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

  
 // SumBlockModel::get_data is still abstract


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


  // SumBlockModel::get_approximate_primal is still abstract

  // SumBlockModel::get_center_primal is still abstract

  // SumBlockModel::get_candidate_primal is still abstract

  // SumBlockModel::call_primal_extender is still asbtract
   
  // SumBlockModel::set_bundle_parameters is still abstract

  // SumBlockModel::get_bundle_parameters is still abstract

  // see SumBlockModel::clear_model 
  void clear_model(bool discard_minorants_only);

  void clear_aggregates();




  //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

  //set_out()               // as in SumBlockModel

  //set_cbout()  // calls set_out in SumBlockModel

  
  
};


}

#endif