coin-Bcp
BCP_lp_user.hpp
Go to the documentation of this file.
1 // Copyright (C) 2000, International Business Machines
2 // Corporation and others. All Rights Reserved.
3 #ifndef _BCP_LP_USER_H
4 #define _BCP_LP_USER_H
5 
6 // This file is fully prepared for doxygen.
7 
8 #include <vector>
9 
10 #include "OsiSolverInterface.hpp"
11 #include "OsiAuxInfo.hpp"
12 #include "OsiBranchingObject.hpp"
13 #include "OsiChooseVariable.hpp"
14 
15 #include "BCP_USER.hpp"
16 
17 #include "BCP_buffer.hpp"
18 #include "BCP_vector.hpp"
19 #include "BCP_string.hpp"
20 #include "BCP_warmstart.hpp"
21 #include "BCP_solution.hpp"
22 #include "BCP_var.hpp"
23 #include "BCP_cut.hpp"
24 #include "BCP_matrix.hpp"
25 
26 #include "BCP_enum.hpp"
27 #include "BCP_enum_branch.hpp"
28 #include "BCP_enum_process_t.hpp"
29 #include "BCP_lp_param.hpp"
30 #include "BCP_lp_result.hpp"
31 #include "BCP_lp_pool.hpp"
32 #include "BCP_lp_branch.hpp"
33 
34 //#############################################################################
35 
36 class BCP_lp_prob;
37 class BCP_problem_core;
38 
39 //#############################################################################
40 
41 // All these functions are defined in BCP_lp_user.cpp, except for those that
42 // have no counterparts in p.defaults, i.e., for those that have no builtin
43 // pairs.
44 
45 //#############################################################################
46 
75 class BCP_lp_user : public BCP_user_class {
76 private:
77  BCP_lp_user(const BCP_lp_user&);
78  BCP_lp_user& operator=(const BCP_lp_user&);
79 
80 private:
81  bool using_deprecated_set_user_data_for_children;
82  BCP_lp_prob * p;
83  OsiBabSolver* babSolver_;
84 
85 public:
92  void setLpProblemPointer(BCP_lp_prob * ptr) { p = ptr; }
95  BCP_lp_prob * getLpProblemPointer() { return p; }
98  void setOsiBabSolver(OsiBabSolver* ptr) { babSolver_ = ptr; }
99  OsiBabSolver* getOsiBabSolver() { return babSolver_; }
100 
103  double upper_bound() const;
107  bool over_ub(double lb) const;
109  int current_phase() const;
111  int current_level() const;
113  int current_index() const;
115  int current_iteration() const;
117  double start_time() const;
120  BCP_user_data* get_user_data();
123  void print(const bool ifprint, const char * format, ...) const;
124 
127  char get_param(const BCP_lp_par::chr_params key) const;
130  int get_param(const BCP_lp_par::int_params key) const;
132  double get_param(const BCP_lp_par::dbl_params key) const;
134  const BCP_string& get_param(const BCP_lp_par::str_params key) const;
135 
137  void set_param(const BCP_lp_par::chr_params key, const bool val);
139  void set_param(const BCP_lp_par::chr_params key, const char val);
141  void set_param(const BCP_lp_par::int_params key, const int val);
143  void set_param(const BCP_lp_par::dbl_params key, const double val);
145  void set_param(const BCP_lp_par::str_params key, const char * val);
150  void send_feasible_solution(const BCP_solution* sol);
151  //=========================================================================
154  BCP_lp_user() : p(0), babSolver_(0) {}
157  virtual ~BCP_lp_user() {}
160  //=========================================================================
168  void
169  select_nonzeros(const double * first, const double * last,
170  const double etol, BCP_vec<int>& nonzeros) const;
173  void
174  select_zeros(const double * first, const double * last,
175  const double etol, BCP_vec<int>& zeros) const;
178  void
179  select_positives(const double * first, const double * last,
180  const double etol, BCP_vec<int>& positives) const;
183  void
184  select_fractions(const double * first, const double * last,
185  const double etol, BCP_vec<int>& fractions) const;
188  //=========================================================================
197  virtual void
198  unpack_module_data(BCP_buffer & buf);
199 
202  //=========================================================================
204  int process_id() const;
206  int parent() const;
208  void
209  send_message(const int target, const BCP_buffer& buf,
210  BCP_message_tag tag = BCP_Msg_User);
212  void
213  receive_message(const int sender, BCP_buffer& buf,
214  BCP_message_tag tag = BCP_Msg_User);
216  void
217  broadcast_message(const BCP_process_t proc_type, const BCP_buffer& buf);
220  virtual void
221  process_message(BCP_buffer& buf);
222  //=========================================================================
233  virtual OsiSolverInterface *
234  initialize_solver_interface();
235 
236  //=========================================================================
241  virtual void
242  initialize_int_and_sos_list(std::vector<OsiObject *>& intAndSosObjects);
243 
244  //=========================================================================
262  virtual void
263  initialize_new_search_tree_node(const BCP_vec<BCP_var*>& vars,
264  const BCP_vec<BCP_cut*>& cuts,
265  const BCP_vec<BCP_obj_status>& var_status,
266  const BCP_vec<BCP_obj_status>& cut_status,
267  BCP_vec<int>& var_changed_pos,
268  BCP_vec<double>& var_new_bd,
269  BCP_vec<int>& cut_changed_pos,
270  BCP_vec<double>& cut_new_bd);
271 
272  //=========================================================================
277  virtual void
278  load_problem(OsiSolverInterface& osi, BCP_problem_core* core,
279  BCP_var_set& vars, BCP_cut_set& cuts);
280 
281  //=========================================================================
295  virtual void
296  modify_lp_parameters(OsiSolverInterface* lp, const int changeType,
297  bool in_strong_branching);
298 
299  //===========================================================================
326  virtual void
327  process_lp_result(const BCP_lp_result& lpres,
328  const BCP_vec<BCP_var*>& vars,
329  const BCP_vec<BCP_cut*>& cuts,
330  const double old_lower_bound,
331  double& true_lower_bound,
332  BCP_solution*& sol,
333  BCP_vec<BCP_cut*>& new_cuts,
334  BCP_vec<BCP_row*>& new_rows,
335  BCP_vec<BCP_var*>& new_vars,
336  BCP_vec<BCP_col*>& new_cols);
337 
338  //=========================================================================
350  virtual double
351  compute_lower_bound(const double old_lower_bound,
352  const BCP_lp_result& lpres,
353  const BCP_vec<BCP_var*>& vars,
354  const BCP_vec<BCP_cut*>& cuts);
355 
356  //=========================================================================
377  virtual BCP_solution*
378  test_feasibility(const BCP_lp_result& lp_result,
379  const BCP_vec<BCP_var*>& vars,
380  const BCP_vec<BCP_cut*>& cuts);
396  BCP_solution_generic*
397  test_binary(const BCP_lp_result& lpres, const BCP_vec<BCP_var*>& vars,
398  const double etol) const;
401  BCP_solution_generic*
402  test_integral(const BCP_lp_result& lpres, const BCP_vec<BCP_var*>& vars,
403  const double etol) const;
405  BCP_solution_generic*
406  test_full(const BCP_lp_result& lpres, const BCP_vec<BCP_var*>& vars,
407  const double etol) const;
416  virtual BCP_solution*
417  generate_heuristic_solution(const BCP_lp_result& lpres,
418  const BCP_vec<BCP_var*>& vars,
419  const BCP_vec<BCP_cut*>& cuts);
422  //=========================================================================
437  virtual void
438  pack_feasible_solution(BCP_buffer& buf, const BCP_solution* sol);
439 
440  //-------------------------------------------------------------------------
462  virtual void
463  pack_primal_solution(BCP_buffer& buf,
464  const BCP_lp_result& lp_result,
465  const BCP_vec<BCP_var*>& vars,
466  const BCP_vec<BCP_cut*>& cuts);
467  //-------------------------------------------------------------------------
489  virtual void
490  pack_dual_solution(BCP_buffer& buf,
491  const BCP_lp_result& lp_result,
492  const BCP_vec<BCP_var*>& vars,
493  const BCP_vec<BCP_cut*>& cuts);
496  //=========================================================================
517  virtual void
518  display_lp_solution(const BCP_lp_result& lp_result,
519  const BCP_vec<BCP_var*>& vars,
520  const BCP_vec<BCP_cut*>& cuts,
521  const bool final_lp_solution);
524  //=========================================================================
531  virtual void
532  restore_feasibility(const BCP_lp_result& lpres,
533  const std::vector<double*> dual_rays,
534  const BCP_vec<BCP_var*>& vars,
535  const BCP_vec<BCP_cut*>& cuts,
536  BCP_vec<BCP_var*>& vars_to_add,
537  BCP_vec<BCP_col*>& cols_to_add);
538 
539  //=========================================================================
575  virtual void
576  cuts_to_rows(const BCP_vec<BCP_var*>& vars, // on what to expand
577  BCP_vec<BCP_cut*>& cuts, // what to expand
578  BCP_vec<BCP_row*>& rows, // the expanded rows
579  // things that the user can use for lifting cuts if allowed
580  const BCP_lp_result& lpres,
581  BCP_object_origin origin, bool allow_multiple);
582  //-------------------------------------------------------------------------
603  virtual void
604  vars_to_cols(const BCP_vec<BCP_cut*>& cuts, // on what to expand
605  BCP_vec<BCP_var*>& vars, // what to expand
606  BCP_vec<BCP_col*>& cols, // the expanded cols
607  // things that the user can use for lifting vars if allowed
608  const BCP_lp_result& lpres,
609  BCP_object_origin origin, bool allow_multiple);
612  //=========================================================================
628  virtual void
629  generate_cuts_in_lp(const BCP_lp_result& lpres,
630  const BCP_vec<BCP_var*>& vars,
631  const BCP_vec<BCP_cut*>& cuts,
632  BCP_vec<BCP_cut*>& new_cuts,
633  BCP_vec<BCP_row*>& new_rows);
634  //-------------------------------------------------------------------------
651  virtual void
652  generate_vars_in_lp(const BCP_lp_result& lpres,
653  const BCP_vec<BCP_var*>& vars,
654  const BCP_vec<BCP_cut*>& cuts,
655  const bool before_fathom,
656  BCP_vec<BCP_var*>& new_vars,
657  BCP_vec<BCP_col*>& new_cols);
658  //-------------------------------------------------------------------------
666  virtual BCP_object_compare_result
667  compare_cuts(const BCP_cut* c0, const BCP_cut* c1);
668  //-------------------------------------------------------------------------
677  virtual BCP_object_compare_result
678  compare_vars(const BCP_var* v0, const BCP_var* v1);
681  //=========================================================================
682  virtual void
683  select_vars_to_delete(const BCP_lp_result& lpres,
684  const BCP_vec<BCP_var*>& vars,
685  const BCP_vec<BCP_cut*>& cuts,
686  const bool before_fathom,
687  BCP_vec<int>& deletable);
688  virtual void
689  select_cuts_to_delete(const BCP_lp_result& lpres,
690  const BCP_vec<BCP_var*>& vars,
691  const BCP_vec<BCP_cut*>& cuts,
692  const bool before_fathom,
693  BCP_vec<int>& deletable);
694  //=========================================================================
712  virtual void
713  logical_fixing(const BCP_lp_result& lpres,
714  const BCP_vec<BCP_var*>& vars,
715  const BCP_vec<BCP_cut*>& cuts,
716  const BCP_vec<BCP_obj_status>& var_status,
717  const BCP_vec<BCP_obj_status>& cut_status,
718  const int var_bound_changes_since_logical_fixing,
719  BCP_vec<int>& changed_pos, BCP_vec<double>& new_bd);
724  void
725  reduced_cost_fixing(const double* dj, const double* x, const double gap,
726  BCP_vec<BCP_var*>& vars, int& newly_changed);
727 
728  //=========================================================================
768  virtual BCP_branching_decision
769  select_branching_candidates(const BCP_lp_result& lpres,
770  const BCP_vec<BCP_var*>& vars,
771  const BCP_vec<BCP_cut*>& cuts,
772  const BCP_lp_var_pool& local_var_pool,
773  const BCP_lp_cut_pool& local_cut_pool,
774  BCP_vec<BCP_lp_branching_object*>& cands,
775  bool force_branch = false);
778  virtual int
779  try_to_branch(OsiBranchingInformation& branchInfo,
780  OsiSolverInterface* solver,
781  OsiChooseVariable* choose,
782  OsiBranchingObject*& branchObject,
783  bool allowVarFix);
788  void
789  branch_close_to_half(const BCP_lp_result& lpres,
790  const BCP_vec<BCP_var*>& vars,
791  const int to_be_selected,
792  const double etol,
793  BCP_vec<BCP_lp_branching_object*>& candidates);
798  void
799  branch_close_to_one(const BCP_lp_result& lpres,
800  const BCP_vec<BCP_var*>& vars,
801  const int to_be_selected,
802  const double etol,
803  BCP_vec<BCP_lp_branching_object*>& candidates);
808  void
809  append_branching_vars(const double* x,
810  const BCP_vec<BCP_var*>& vars,
811  const BCP_vec<int>& select_pos,
812  BCP_vec<BCP_lp_branching_object*>& candidates);
829  virtual BCP_branching_object_relation
830  compare_branching_candidates(BCP_presolved_lp_brobj* new_solved,
831  BCP_presolved_lp_brobj* old_solved);
851  virtual void
852  set_actions_for_children(BCP_presolved_lp_brobj* best);
853 
862  virtual void
863  set_user_data_for_children(BCP_presolved_lp_brobj* best,
864  const int selected);
868  virtual void
869  set_user_data_for_children(BCP_presolved_lp_brobj* best);
872  //=========================================================================
873  // purging the slack cut pool (candidates for branching on cut)
895  virtual void
896  purge_slack_pool(const BCP_vec<BCP_cut*>& slack_pool,
897  BCP_vec<int>& to_be_purged);
899 };
900 
901 //#############################################################################
902 
903 #endif
OsiBabSolver
This class allows for the use of more exotic solvers e.g.
Definition: OsiAuxInfo.hpp:52
BCP_vector.hpp
BCP_object_origin
BCP_object_origin
This enumerative constant describes the origin (originating process) of an object (variable or cut)...
Definition: BCP_enum.hpp:249
BCP_lp_user::get_param
char get_param(const BCP_lp_par::chr_params key) const
BCP_lp_par::int_params
int_params
Integer parameters.
Definition: BCP_lp_param.hpp:163
BCP_lp_user::set_actions_for_children
virtual void set_actions_for_children(BCP_presolved_lp_brobj *best)
Decide what to do with the children of the selected branching object.
BCP_message_tag
BCP_message_tag
This enumerative constant describes the message tags different processes of BCP understand.
Definition: BCP_message_tag.hpp:11
BCP_problem_core
This class describes the core of the MIP problem, the variables/cuts in it as well as the matrix corr...
Definition: BCP_problem_core.hpp:31
BCP_lp_user::initialize_solver_interface
virtual OsiSolverInterface * initialize_solver_interface()
Create LP solver environment.
BCP_solution.hpp
OsiBranchingObject.hpp
BCP_lp_par::str_params
str_params
String parameters.
Definition: BCP_lp_param.hpp:424
BCP_lp_user::setOsiBabSolver
void setOsiBabSolver(OsiBabSolver *ptr)
Definition: BCP_lp_user.hpp:98
BCP_lp_user::branch_close_to_one
void branch_close_to_one(const BCP_lp_result &lpres, const BCP_vec< BCP_var * > &vars, const int to_be_selected, const double etol, BCP_vec< BCP_lp_branching_object * > &candidates)
Select the &quot;close-to-one&quot; variables for strong branching.
BCP_lp_user::print
void print(const bool ifprint, const char *format,...) const
A method to print a message with the process id.
BCP_lp_user::parent
int parent() const
the process id of the parent
BCP_lp_user::pack_dual_solution
virtual void pack_dual_solution(BCP_buffer &buf, const BCP_lp_result &lp_result, const BCP_vec< BCP_var * > &vars, const BCP_vec< BCP_cut * > &cuts)
Pack the information necessary for variable generation into the buffer.
BCP_cut.hpp
BCP_lp_user::select_fractions
void select_fractions(const double *first, const double *last, const double etol, BCP_vec< int > &fractions) const
Select all fractional entries.
BCP_lp_user::select_vars_to_delete
virtual void select_vars_to_delete(const BCP_lp_result &lpres, const BCP_vec< BCP_var * > &vars, const BCP_vec< BCP_cut * > &cuts, const bool before_fathom, BCP_vec< int > &deletable)
BCP_lp_user::reduced_cost_fixing
void reduced_cost_fixing(const double *dj, const double *x, const double gap, BCP_vec< BCP_var * > &vars, int &newly_changed)
Reduced cost fixing.
BCP_USER.hpp
BCP_lp_user::select_branching_candidates
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)
Decide whether to branch or not and select a set of branching candidates if branching is decided upon...
BCP_lp_user::try_to_branch
virtual int try_to_branch(OsiBranchingInformation &branchInfo, OsiSolverInterface *solver, OsiChooseVariable *choose, OsiBranchingObject *&branchObject, bool allowVarFix)
Select the &quot;close-to-half&quot; variables for strong branching.
BCP_cut
Abstract base class that defines members common to all types of cuts.
Definition: BCP_cut.hpp:29
BCP_lp_user::getOsiBabSolver
OsiBabSolver * getOsiBabSolver()
Definition: BCP_lp_user.hpp:99
BCP_lp_branch.hpp
BCP_lp_user::set_user_data_for_children
virtual void set_user_data_for_children(BCP_presolved_lp_brobj *best, const int selected)
For each child create a user data object and put it into the appropriate entry in best-&gt;user_data()...
BCP_lp_user::process_lp_result
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)
Process the result of an iteration.
BCP_lp_user::test_integral
BCP_solution_generic * test_integral(const BCP_lp_result &lpres, const BCP_vec< BCP_var * > &vars, const double etol) const
Test whether all variables are integer.
BCP_process_t
BCP_process_t
This enumerative constant describes the various process types.
Definition: BCP_enum_process_t.hpp:10
BCP_lp_user::test_feasibility
virtual BCP_solution * test_feasibility(const BCP_lp_result &lp_result, const BCP_vec< BCP_var * > &vars, const BCP_vec< BCP_cut * > &cuts)
Evaluate and return MIP feasibility of the current solution.
BCP_lp_user::set_param
void set_param(const BCP_lp_par::chr_params key, const bool val)
BCP_lp_user::current_level
int current_level() const
Return the level of the search tree node being processed.
BCP_lp_user::operator=
BCP_lp_user & operator=(const BCP_lp_user &)
BCP_lp_user::current_index
int current_index() const
Return the internal index of the search tree node being processed.
BCP_lp_user::start_time
double start_time() const
Return when the LP process started.
BCP_lp_prob
NO OLD DOC.
Definition: BCP_lp.hpp:102
BCP_cut_set
This class is just a collection of pointers to cuts with a number of methods to manipulate these cuts...
Definition: BCP_cut.hpp:279
BCP_var.hpp
BCP_lp_user::current_iteration
int current_iteration() const
Return the iteration count within the search tree node being processed.
BCP_string
This class is a very simple impelementation of a constant length string.
Definition: BCP_string.hpp:13
BCP_lp_user::current_phase
int current_phase() const
Return the phase the algorithm is in.
BCP_lp_user::purge_slack_pool
virtual void purge_slack_pool(const BCP_vec< BCP_cut * > &slack_pool, BCP_vec< int > &to_be_purged)
Selectively purge the list of slack cuts.
BCP_lp_user::unpack_module_data
virtual void unpack_module_data(BCP_buffer &buf)
Unpack the initial information sent to the LP process by the Tree Manager.
BCP_lp_user
The BCP_lp_user class is the base class from which the user can derive a problem specific class to be...
Definition: BCP_lp_user.hpp:75
BCP_lp_user::compare_branching_candidates
virtual BCP_branching_object_relation compare_branching_candidates(BCP_presolved_lp_brobj *new_solved, BCP_presolved_lp_brobj *old_solved)
Decide which branching object is preferred for branching.
BCP_lp_user::broadcast_message
void broadcast_message(const BCP_process_t proc_type, const BCP_buffer &buf)
Broadcast the message to all processes of the given type.
BCP_lp_user::send_message
void send_message(const int target, const BCP_buffer &buf, BCP_message_tag tag=BCP_Msg_User)
Send a message to a particular process.
BCP_lp_user::branch_close_to_half
void branch_close_to_half(const BCP_lp_result &lpres, const BCP_vec< BCP_var * > &vars, const int to_be_selected, const double etol, BCP_vec< BCP_lp_branching_object * > &candidates)
Select the &quot;close-to-half&quot; variables for strong branching.
BCP_lp_user::load_problem
virtual void load_problem(OsiSolverInterface &osi, BCP_problem_core *core, BCP_var_set &vars, BCP_cut_set &cuts)
Load the problem specified by core, vars, and cuts into the solver interface.
BCP_lp_user::logical_fixing
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)
This method provides an opportunity for the user to tighten the bounds of variables.
BCP_lp_user::cuts_to_rows
virtual void cuts_to_rows(const BCP_vec< BCP_var * > &vars, BCP_vec< BCP_cut * > &cuts, BCP_vec< BCP_row * > &rows, const BCP_lp_result &lpres, BCP_object_origin origin, bool allow_multiple)
Convert (and possibly lift) a set of cuts into corresponding rows for the current LP relaxation...
BCP_lp_user::pack_feasible_solution
virtual void pack_feasible_solution(BCP_buffer &buf, const BCP_solution *sol)
Pack a MIP feasible solution into a buffer.
BCP_lp_user::display_lp_solution
virtual void display_lp_solution(const BCP_lp_result &lp_result, const BCP_vec< BCP_var * > &vars, const BCP_vec< BCP_cut * > &cuts, const bool final_lp_solution)
Display the result of most recent LP optimization.
BCP_string.hpp
BCP_lp_user::getLpProblemPointer
BCP_lp_prob * getLpProblemPointer()
Get the pointer.
Definition: BCP_lp_user.hpp:95
BCP_lp_user::get_user_data
BCP_user_data * get_user_data()
Return a pointer to the BCP_user_data structure the user (may have) stored in this node...
BCP_lp_user::generate_cuts_in_lp
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)
Generate cuts within the LP process.
BCP_lp_user::compare_cuts
virtual BCP_object_compare_result compare_cuts(const BCP_cut *c0, const BCP_cut *c1)
Compare two generated cuts.
BCP_lp_user::compare_vars
virtual BCP_object_compare_result compare_vars(const BCP_var *v0, const BCP_var *v1)
Compare two generated variables.
BCP_lp_user::initialize_new_search_tree_node
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)
Initializing a new search tree node.
BCP_lp_user::append_branching_vars
void append_branching_vars(const double *x, const BCP_vec< BCP_var * > &vars, const BCP_vec< int > &select_pos, BCP_vec< BCP_lp_branching_object * > &candidates)
This helper method creates branching variable candidates and appends them to cans.
BCP_lp_user::select_cuts_to_delete
virtual void select_cuts_to_delete(const BCP_lp_result &lpres, const BCP_vec< BCP_var * > &vars, const BCP_vec< BCP_cut * > &cuts, const bool before_fathom, BCP_vec< int > &deletable)
BCP_lp_user::select_positives
void select_positives(const double *first, const double *last, const double etol, BCP_vec< int > &positives) const
Select all positive entries.
BCP_enum_process_t.hpp
BCP_lp_user::initialize_int_and_sos_list
virtual void initialize_int_and_sos_list(std::vector< OsiObject * > &intAndSosObjects)
Create the list of objects that can be used for branching (simple integer vars and SOS sets)...
BCP_warmstart.hpp
BCP_lp_user::BCP_lp_user
BCP_lp_user()
Being virtual, the destructor invokes the destructor for the real type of the object being deleted...
Definition: BCP_lp_user.hpp:154
BCP_lp_user::generate_heuristic_solution
virtual BCP_solution * generate_heuristic_solution(const BCP_lp_result &lpres, const BCP_vec< BCP_var * > &vars, const BCP_vec< BCP_cut * > &cuts)
Try to generate a heuristic solution (or return one generated during cut/variable generation...
BCP_branching_decision
BCP_branching_decision
This enumerative constant is the return value of the select_branching_candidates() method in [BCP_lp_...
Definition: BCP_enum_branch.hpp:58
BCP_lp_par::chr_params
chr_params
Character parameters.
Definition: BCP_lp_param.hpp:17
BCP_lp_user::setLpProblemPointer
void setLpProblemPointer(BCP_lp_prob *ptr)
Set the pointer.
Definition: BCP_lp_user.hpp:93
BCP_user_class
Definition: BCP_USER.hpp:26
OsiSolverInterface.hpp
BCP_lp_user::pack_primal_solution
virtual void pack_primal_solution(BCP_buffer &buf, const BCP_lp_result &lp_result, const BCP_vec< BCP_var * > &vars, const BCP_vec< BCP_cut * > &cuts)
Pack the information necessary for cut generation into the buffer.
BCP_lp_user::modify_lp_parameters
virtual void modify_lp_parameters(OsiSolverInterface *lp, const int changeType, bool in_strong_branching)
Modify parameters of the LP solver before optimization.
OsiSolverInterface
Abstract Base Class for describing an interface to a solver.
Definition: OsiSolverInterface.hpp:61
BCP_lp_user::restore_feasibility
virtual void restore_feasibility(const BCP_lp_result &lpres, const std::vector< double * > dual_rays, const BCP_vec< BCP_var * > &vars, const BCP_vec< BCP_cut * > &cuts, BCP_vec< BCP_var * > &vars_to_add, BCP_vec< BCP_col * > &cols_to_add)
Restoring feasibility.
OsiChooseVariable.hpp
BCP_lp_user::babSolver_
OsiBabSolver * babSolver_
Definition: BCP_lp_user.hpp:83
BCP_lp_user::upper_bound
double upper_bound() const
Return what is the best known upper bound (might be BCP_DBL_MAX)
BCP_var
Abstract base class that defines members common to all types of variables.
Definition: BCP_var.hpp:28
BCP_lp_result.hpp
BCP_presolved_lp_brobj
A presolved branching object candidate.
Definition: BCP_lp_branch.hpp:321
BCP_lp_user::~BCP_lp_user
virtual ~BCP_lp_user()
Being virtual, the destructor invokes the destructor for the real type of the object being deleted...
Definition: BCP_lp_user.hpp:157
BCP_lp_param.hpp
BCP_lp_user::receive_message
void receive_message(const int sender, BCP_buffer &buf, BCP_message_tag tag=BCP_Msg_User)
Wait for a message and receive it.
BCP_lp_user::select_zeros
void select_zeros(const double *first, const double *last, const double etol, BCP_vec< int > &zeros) const
Select all zero entries.
BCP_var_set
This class is just a collection of pointers to variables with a number of methods to manipulate these...
Definition: BCP_var.hpp:316
BCP_vec< int >
BCP_buffer
This class describes the message buffer used for all processes of BCP.
Definition: BCP_buffer.hpp:39
BCP_lp_var_pool
Definition: BCP_lp_pool.hpp:109
BCP_lp_user::generate_vars_in_lp
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)
Generate variables within the LP process.
BCP_enum_branch.hpp
BCP_lp_user::vars_to_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)
Convert a set of variables into corresponding columns for the current LP relaxation.
BCP_lp_user::process_message
virtual void process_message(BCP_buffer &buf)
Process a message that has been sent by another process&#39; user part to this process&#39; user part...
BCP_branching_object_relation
BCP_branching_object_relation
This enumerative constant is the return value of the compare_presolved_branching_objects() method in ...
Definition: BCP_enum_branch.hpp:80
BCP_Msg_User
Used by the user to send a message to the user portion of the other process.
Definition: BCP_message_tag.hpp:47
BCP_lp_cut_pool
Definition: BCP_lp_pool.hpp:47
BCP_lp_user::p
BCP_lp_prob * p
Definition: BCP_lp_user.hpp:82
OsiChooseVariable
This class chooses a variable to branch on.
Definition: OsiChooseVariable.hpp:33
BCP_lp_result
This class holds the results after solving an LP relaxation.
Definition: BCP_lp_result.hpp:39
BCP_lp_user::over_ub
bool over_ub(double lb) const
Return true / false depending on whether the lb argument is over the current upper bound or not...
BCP_lp_user::test_binary
BCP_solution_generic * test_binary(const BCP_lp_result &lpres, const BCP_vec< BCP_var * > &vars, const double etol) const
Test whether all variables are 0/1.
BCP_lp_pool.hpp
BCP_solution_generic
This class holds a MIP feasible primal solution.
Definition: BCP_solution.hpp:33
BCP_buffer.hpp
BCP_lp_user::send_feasible_solution
void send_feasible_solution(const BCP_solution *sol)
OsiAuxInfo.hpp
BCP_enum.hpp
BCP_lp_par::dbl_params
dbl_params
Double parameters.
Definition: BCP_lp_param.hpp:313
BCP_object_compare_result
BCP_object_compare_result
This enumerative constant describes the possible outcomes when comparing two objects (variables or cu...
Definition: BCP_enum.hpp:276
BCP_matrix.hpp
BCP_lp_user::select_nonzeros
void select_nonzeros(const double *first, const double *last, const double etol, BCP_vec< int > &nonzeros) const
Select all nonzero entries.
BCP_lp_user::test_full
BCP_solution_generic * test_full(const BCP_lp_result &lpres, const BCP_vec< BCP_var * > &vars, const double etol) const
Test whether the variables specified as integers are really integer.
BCP_user_data
Definition: BCP_USER.hpp:19
OsiBranchingObject
Abstract branching object base class.
Definition: OsiBranchingObject.hpp:282
BCP_solution
This is the abstract base class for a solution to a Mixed Integer Programming problem.
Definition: BCP_solution.hpp:14
BCP_lp_user::process_id
int process_id() const
What is the process id of the current process.
BCP_lp_user::using_deprecated_set_user_data_for_children
bool using_deprecated_set_user_data_for_children
Definition: BCP_lp_user.hpp:81
BCP_lp_user::compute_lower_bound
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)
Compute a true lower bound for the subproblem.
Generated by   doxygen 1.8.5