OS_lp.hpp

Go to the documentation of this file.

/* $Id: OS_lp.hpp 2904 2009-09-06 06:47:42Z kmartin $ */
// Last edit: 2/10/05
//
// Name:     OS_lp.hpp
// Author:   Francois Margot
//           Tepper School of Business
//           Carnegie Mellon University, Pittsburgh, PA 15213
//           email: fmargot@andrew.cmu.edu
// Date:     12/28/03
//-----------------------------------------------------------------------------
// Copyright (C) 2003, Francois Margot, International Business Machines
// Corporation and others.  All Rights Reserved.

#ifndef _OS_LP_H
#define _OS_LP_H


#include "OS.hpp"
#include "BCP_lp_user.hpp"
#include "BCP_buffer.hpp"
#include "BCP_parameters.hpp"
#include "OS_var.hpp"
#include "OS_user_data.hpp"
#include "OS_packer.hpp"

class OS_lp : public BCP_lp_user {

    OsiSolverInterface* cg_lp;
    //BCP_parameter_set<MCF1_par> par;
   // OS_user_data data;

  OS_prob *os_prob;     

  MY_user_data *p_ud;  
  
  int in_strong;       

  double EPS;          

  BCP_vec<BCP_cut*> algo_cuts;    
  
  BCP_vec<BCP_var*> algo_vars;   
  

 bool generated_vars; 
 

 bool generated_cuts; 

  std::vector<int> violated_cuts; 

public:





  OS_lp(){}
  
  virtual ~OS_lp() {}

  virtual void unpack_module_data(BCP_buffer & buf);

 // virtual void pack_cut_algo(const BCP_cut_algo* cut, BCP_buffer& buf);

//  virtual BCP_cut_algo* unpack_cut_algo(BCP_buffer& buf);
  
  
//      virtual void pack_var_algo(const BCP_var_algo* var, BCP_buffer& buf) {
                
//              OS_pack_var(var, buf);
//    }
        
 //   virtual BCP_var_algo* unpack_var_algo(BCP_buffer& buf) {
//                      return OS_unpack_var(buf);
 //   } 

  //virtual void pack_user_data(const BCP_user_data* ud, BCP_buffer& buf);

  //virtual MY_user_data* unpack_user_data(BCP_buffer& buf);

  // Tell Bcp which solver to use and set parameters of solver.
  virtual OsiSolverInterface *initialize_solver_interface();
  
  virtual void initialize_new_search_tree_node(
                                 const BCP_vec<BCP_var*>& vars,
                                 const BCP_vec<BCP_cut*>& cuts,
                                 const BCP_vec<BCP_obj_status>& var_status,
                                 const BCP_vec<BCP_obj_status>& cut_status,
                                 BCP_vec<int>& var_changed_pos,
                                 BCP_vec<double>& var_new_bd,
                                 BCP_vec<int>& cut_changed_pos,
                                 BCP_vec<double>& cut_new_bd);
  
  virtual void modify_lp_parameters(OsiSolverInterface* lp, 
                                    bool in_strong_branching);
  
 // virtual BCP_solution* test_feasibility(const BCP_lp_result& lp_result,
//                                       const BCP_vec<BCP_var*>& vars,
//                                       const BCP_vec<BCP_cut*>& cuts);
  

  


  //virtual void generate_cuts_in_lp(const BCP_lp_result& lpres,
//                    const BCP_vec<BCP_var*>& vars,
//                    const BCP_vec<BCP_cut*>& cuts,
//                    BCP_vec<BCP_cut*>& new_cuts,
//                    BCP_vec<BCP_row*>& new_rows);

  
 virtual  void display_lp_solution(const BCP_lp_result& lpres,
                                 const BCP_vec<BCP_var*>& vars,
                                 const BCP_vec<BCP_cut*>& cuts,
                                 const bool final_lp_solution);

  virtual BCP_solution* generate_heuristic_solution(
                               const BCP_lp_result& lpres,
                               const BCP_vec<BCP_var*>& vars,
                               const BCP_vec<BCP_cut*>& cuts);

  virtual void
  cuts_to_rows(const BCP_vec<BCP_var*>& vars, // on what to expand
               BCP_vec<BCP_cut*>& cuts,       // what to expand
               BCP_vec<BCP_row*>& rows,       // the expanded rows
               const BCP_lp_result& lpres,
               BCP_object_origin origin, bool allow_multiple);



  virtual BCP_branching_decision
  select_branching_candidates(const BCP_lp_result& lpres,
                              const BCP_vec<BCP_var*>& vars,
                              const BCP_vec<BCP_cut*>& cuts,
                              const BCP_lp_var_pool& local_var_pool,
                              const BCP_lp_cut_pool& local_cut_pool,
                              BCP_vec<BCP_lp_branching_object*>& cands,
                              bool force_branch = false);

  virtual void set_user_data_for_children(BCP_presolved_lp_brobj* best, 
                                          const int selected);
                                          



//      virtual double  compute_lower_bound(const double old_lower_bound,
//              const BCP_lp_result& lpres, const BCP_vec<BCP_var*>& vars,
//              const BCP_vec<BCP_cut*>& cuts);
                        
                        
//      virtual void generate_vars_in_lp(const BCP_lp_result& lpres,
//              const BCP_vec<BCP_var*>& vars, const BCP_vec<BCP_cut*>& cuts,
//              const bool before_fathom, BCP_vec<BCP_var*>& new_vars,
//              BCP_vec<BCP_col*>& new_cols);
                        
                        
 virtual void vars_to_cols(const BCP_vec<BCP_cut*>& cuts,
                 BCP_vec<BCP_var*>& vars, BCP_vec<BCP_col*>& cols,
                const BCP_lp_result& lpres,
                BCP_object_origin origin, bool allow_multiple);
    
    
    //===========================================================================
    virtual void process_lp_result(const BCP_lp_result& lpres,
                      const BCP_vec<BCP_var*>& vars,
                      const BCP_vec<BCP_cut*>& cuts,
                      const double old_lower_bound,
                      double& true_lower_bound,
                      BCP_solution*& sol,
                      BCP_vec<BCP_cut*>& new_cuts,
                      BCP_vec<BCP_row*>& new_rows,
                      BCP_vec<BCP_var*>& new_vars,
                      BCP_vec<BCP_col*>& new_cols);



};

#endif