PSCModel.hxx

Go to the documentation of this file.

#ifndef CONICBUNDLE_PSCMODEL_HXX
#define CONICBUNDLE_PSCMODEL_HXX

#include "ConeModel.hxx"
#include "PSCData.hxx"
#include "PSCModelParametersObject.hxx"
#include "PSCAffineFunction.hxx"
#include "PSCIPBundleBlock.hxx"

namespace ConicBundle {


class PSCModel: public ConeModel
{
private:

  //--- problem description
  PSCOracle* oracle;   
  //--- data describing the model
  PSCData data;
  PSCModelParametersObject* model_selection;

  //--- data of last oracle evaluation
  int ret_code;
  CH_Matrix_Classes::Integer nr_eval;

  //--- augmented modle solver
  QPConeModelDataObject* block;


  //--- for debugging
  //CH_Matrix_Classes::Matrix debug_cand_y;
  //CH_Matrix_Classes::Matrix debug_center_y;

  //--- for passing oracle information to the QP Solver
  class QPPSCOracleData : public QPPSCOracleDataObject
  {
  private:
    PSCAffineFunction* oracle; 
    PSCData* data; 
    
  public:
    QPPSCOracleData():oracle(0),data(0){}
    ~QPPSCOracleData(){}

    int init(PSCOracle* op,PSCData *dp)
    {
      oracle=dynamic_cast<PSCAffineFunction*>(op);
      data=dp;
      return ((oracle==0)||(data==0));
    }

    virtual const SparseCoeffmatMatrix& get_opAt()
    { assert(oracle); return oracle->get_opAt(); }
    
    virtual const SparseCoeffmatMatrix& get_C()
    { assert(oracle); return oracle->get_C(); }

    virtual const CH_Matrix_Classes::Matrix& get_bundlevecs()
    { assert(data); return data->bundlevecs; }
   
  };

  QPPSCOracleData qp_oracle_data;
  
   //----------------------------------------------------------------------


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

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

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

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


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

  virtual int get_aggregate_and_coefficient(MinorantPointer& sumbundle_aggr,
                                            CH_Matrix_Classes::Real& aggr_coeff);
  
  
 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);

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

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

  virtual bool candidate_available()
  {return (data.cand_ub_mid==data.get_modification_id())&&(data.cand_Ritzval.rowdim()>0); }
  
  virtual MinorantPointer& provide_cand_minorant();

  virtual MinorantPointer& provide_center_minorant();




public:    
  virtual void clear(); 

  virtual int set_variable_metric_selection(VariableMetricSelection* vms=0);

  PSCModel(PSCOracle* fo,CH_Matrix_Classes::Real fun_factor=1.,FunctionTask fun_task=ObjectiveFunction,CBout* cb=0,int cbinc=-1);
    
  ~PSCModel();


  //----------------------------------------------------------------------
  
  
   //eval_function     //as in ConeModel

  //eval_model        //as in ConeModel

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

  //update_model           //as in ConeModel

  //synchronize_ids        //as in SumBlockModel

  //center_modified        //as in SumBlockModel

  //recompute center       //as in ConeModel

  //model_aggregate_modified      //as in ConeModel

  //provide_model_aggregate  //as in ConeModel

  // apply_modfication    // as in SumBlockModel

  // add_variable_metric  //as in SumBlockModel

  //check_center_validity_by_candidate  //as in ConeModel
 
 

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

  ModifiableOracleObject* get_oracle_object() {return oracle;}
  
  //start_augmodel   //as in ConeModel
   
  // make_model_aggregate         //as in ConeModel

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

  // get_function_minorant      //as in ConeModel

  // get_center_minorant        //as in ConeModel

  // adjust_multiplier          //as in ConeModel

  // sumbundle_contribution     //as in ConeModel

  // as in ConeModel::update_model(ModelUpdate,CH_Matrix_Classes::Integer,const CH_Matrix_Classes::Matrix&,CH_Matrix_Classes::Real,CH_Matrix_Classes::Real,CH_Matrix_Classes::Real&,CH_Matrix_Classes::Real&)
  
  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 data.get_approximate_primal(); }

  const PrimalData* get_center_primal() const 
  { if (!(const_cast<PSCModel*>(this))->provide_center_minorant().valid()) return 0; return data.get_center_primal();}

  const PrimalData* get_candidate_primal() const 
  { if (!(const_cast<PSCModel*>(this))->provide_cand_minorant().valid()) return 0; return data.get_candidate_primal();}

  int call_primal_extender(PrimalExtender& prex)
  { return data.call_primal_extender(prex); }
   
  int set_bundle_parameters(const BundleParameters& bp);

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

  // clear_model()        //as in ConeModel

  // clear_aggregates()   //as in ConeModel

  int get_ret_code() const {return ret_code;}



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

  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

  //get_eval_time()         // as in SumBlockModel

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

  //set_cbout()  // calls set_out in SumBlockModel

  

  
};


}

#endif