AFTModel.hxx

Go to the documentation of this file.

#ifndef CONICBUNDLE_AFTMODEL_HXX
#define CONICBUNDLE_AFTMODEL_HXX

#include "SumBlockModel.hxx"
#include "AFTData.hxx"
#include "AffineFunctionTransformation.hxx"

namespace ConicBundle {


class AFTModel: public SumBlockModel
{
private:
  //==================  dummy oracle  =====================
  SumBlockModel* model;
  bool model_is_owner;
  ModifiableOracleObject dummy_oracle;

  //=================== data of the AFT  ==================
  AffineFunctionTransformation* aft;
  AFTData data;

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

  //--- lazy evaluation of the the candidate subgradient
  MinorantPointer cand_minorant;

  MinorantPointer  center_minorant;

   
  //===================  quadratic subproblems ==================
  QPConeModelDataObject* block;

  std::map<MinorantPointer,MinorantPointer> precomputed;
  CH_Matrix_Classes::Indexmatrix qp_indices;
  CH_Matrix_Classes::Indexmatrix old_indices;


  //=================== private functions ======================

  SumBlockModel* cond_model_trafo()
  { return model_is_owner? model: model->sbm_transform();}
  const SumBlockModel* cond_model_trafo() const
  { return model_is_owner? model: model->sbm_transform();}


  const CH_Matrix_Classes::Matrix& 
  generate_aft_cand(
                    CH_Matrix_Classes::Integer cand_id,
                    const CH_Matrix_Classes::Matrix& cand_y
                    );

  int check_function_id_change(CH_Matrix_Classes::Integer function_id);

  
  int compute_qp_data(const CH_Matrix_Classes::Indexmatrix* indices=0) const;


public:
  void clear(AffineFunctionTransformation* inaft,
             CH_Matrix_Classes::Integer start_modification_id=0);

  virtual void clear(){clear(0);}

  AFTModel(SumBlockModel* in_model,
           AffineFunctionTransformation* inaft=0,
           CH_Matrix_Classes::Integer start_modification_id=0,
           bool in_model_is_owner=false,
           CBout* cb=0);
  ~AFTModel();

  const AffineFunctionTransformation* get_aft() const {return aft;}

  //----------------------------------------------------------------------
  
  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& center_ub_fid,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 center_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_augmodel
   
  int make_model_aggregate(bool& penalty_parameter_increased,
                           bool keep_penalty_fixed);  

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

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

  
  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 */) {return 1;}

  BundleParameters* get_bundle_parameters() const {return 0;}

  void clear_model(bool discard_minorants_only=false);

  void clear_aggregates();  

  //get_ret_code()      // as in SumBlockModel


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

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

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

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

  virtual CH_Tools::Microseconds get_preeval_time() const 
  { 
    CH_Tools::Microseconds ms(preeval_time);
    if (model) ms+= model->get_preeval_time();
    return ms;
  }
  virtual CH_Tools::Microseconds get_eval_time() const 
  { 
    CH_Tools::Microseconds ms(eval_time);
    if (model) ms= model->get_eval_time();
    return ms;
  }

  virtual CH_Tools::Microseconds get_posteval_time() const
  { 
    CH_Tools::Microseconds ms(posteval_time);
    if (model) ms+= model->get_posteval_time();
    return ms;
  }

  void set_out(std::ostream* o=0,int pril=1)
  {
    SumBlockModel::set_out(o,pril);
    if (model)
      model->set_cbout(this,0);
    aft->set_cbout(this,0);
    if (block)
      block->set_cbout(this,-1);
  }

  //set_cbout()  // calls set_out in SumBlockModel



};


}

#endif