BB_lp.hpp

Go to the documentation of this file.

// Last edit: 1/21/09
//
// Name:     BB_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 _BB_LP_H
#define _BB_LP_H

#include "BB.hpp"
#include "BCP_lp_user.hpp"

#include "BB_user_data.hpp"

class BB_lp : public BCP_lp_user {

  BB_prob *p_desc;     

  MY_user_data *p_ud;  
  
  int in_strong;       

  double EPS;          

  BCP_vec<BCP_cut*> algo_cuts;    

  std::vector<int> violated_cuts; 

public:

  BB_lp(){}
  
  virtual ~BB_lp() {}

  virtual void unpack_module_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,
                                    const int changeType,
                                    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 logical_fixing(const BCP_lp_result& lpres,
                              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,
                              const int var_bound_changes_since_logical_fixing,
                              BCP_vec<int>& changed_pos, 
                              BCP_vec<double>& new_bd);
  
  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 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);
};

#endif