Bcp  1.4.4
BCP_lp_functions.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_FUNCTIONS_H
4 #define _BCP_LP_FUNCTIONS_H
5 
6 // This file is fully docified.
7 // Actually, there's nothing to docify here...
8 
9 #include <vector>
10 
11 #include "BCP_enum.hpp"
12 #include "BCP_enum_branch.hpp"
13 #include "BCP_message_tag.hpp"
14 #include "BCP_vector.hpp"
15 
16 class OsiSolverInterface;
17 class CoinWarmStart;
18 
19 class BCP_buffer;
20 class BCP_lp_prob;
21 class BCP_lp_result;
24 class BCP_solution;
25 class BCP_col;
26 class BCP_row;
27 class BCP_warmstart;
28 class BCP_var;
29 
30 //-----------------------------------------------------------------------------
31 // BCP_lp_main.cpp
32 void
34 
35 //-----------------------------------------------------------------------------
36 // BCP_lp_repricing.cpp
38 
39 //-----------------------------------------------------------------------------
40 // BCP_lp_main_loop.cpp
42 
43 //-----------------------------------------------------------------------------
44 // BCP_lp_fathom.cpp
45 void BCP_price_vars(BCP_lp_prob& p, const bool from_fathom,
46  BCP_vec<BCP_var*>& vars_to_add,
47  BCP_vec<BCP_col*>& cols_to_add);
49  const std::vector<double*> dual_rays,
50  BCP_vec<BCP_var*>& vars_to_add,
51  BCP_vec<BCP_col*>& cols_to_add);
52 void BCP_lp_perform_fathom(BCP_lp_prob& p, const char* msg,
53  BCP_message_tag msgtag);
54 bool BCP_lp_fathom(BCP_lp_prob& p, const bool from_repricing);
55 
56 //-----------------------------------------------------------------------------
57 // BCP_lp_generate_cuts.cpp
59  bool first_in_loop, const bool from_repricing);
60 
61 //-----------------------------------------------------------------------------
62 // BCP_lp_generate_vars.cpp
64  bool first_in_loop, const bool from_repricing);
65 
66 //-----------------------------------------------------------------------------
67 // BCP_lp_misc.cpp
68 void BCP_lp_process_result(BCP_lp_prob& p, const BCP_lp_result& lpres);
77  OsiSolverInterface* lp);
79  OsiSolverInterface* lp);
80 //-----------------------------------------------------------------------------
81 // BCP_lp_msgproc.cpp
86 void BCP_lp_send_cuts_to_cp(BCP_lp_prob& p, const int eff_cnt_limit);
88 
89 //-----------------------------------------------------------------------------
90 // BCP_lp_branch.cpp
93 
94 //-----------------------------------------------------------------------------
95 // BCP_lp_colrow.cpp
100  const int added_colnum,
101  const int added_rownum,
102  const bool from_fathom,
103  const bool force_delete);
106 
107 //-----------------------------------------------------------------------------
108 // BCP_lp_msg_node_send.cpp
109 // brobj is 0, msgtag is 'real' when invoked from fathom().
110 // brobj is 'real', msgtag is BCP_Msg_NoMessage when invoked from branch()
112  BCP_presolved_lp_brobj* brobj,
113  BCP_message_tag msgtag);
114 
115 //-----------------------------------------------------------------------------
116 // BCP_lp_msg_node_rec.cpp
118 
119 //-----------------------------------------------------------------------------
120 // BCP_lp_create_lp.cpp
122 
123 //-----------------------------------------------------------------------------
124 // BCP_lp_create_warmstart.cpp
125 // The calling functions will consider ws to be lost! This function should
126 // either build it into the created BCP_warmstart or delete it.
128 
129 #endif
BCP_col
This class holds a column in a compressed form.
Definition: BCP_matrix.hpp:26
BCP_lp_main_loop
void BCP_lp_main_loop(BCP_lp_prob &p)
BCP_lp_add_from_local_var_pool
int BCP_lp_add_from_local_var_pool(BCP_lp_prob &p)
BCP_lp_process_core
void BCP_lp_process_core(BCP_lp_prob &p, BCP_buffer &buf)
BCP_vector.hpp
BCP_lp_generate_cuts
int BCP_lp_generate_cuts(BCP_lp_prob &p, bool first_in_loop, const bool from_repricing)
BCP_lp_check_ub
void BCP_lp_check_ub(BCP_lp_prob &p)
BCP_lp_create_lp
void BCP_lp_create_lp(BCP_lp_prob &p)
BCP_restore_feasibility
void BCP_restore_feasibility(BCP_lp_prob &p, const std::vector< double * > dual_rays, BCP_vec< BCP_var * > &vars_to_add, BCP_vec< BCP_col * > &cols_to_add)
BCP_lp_convert_CoinWarmStart
BCP_warmstart * BCP_lp_convert_CoinWarmStart(BCP_lp_prob &p, CoinWarmStart *&ws)
BCP_branching_result
BCP_branching_result
This enumerative constant describes the possible outcomes of a branching attempt.
Definition: BCP_enum_branch.hpp:38
BCP_lp_delete_cols_and_rows
void BCP_lp_delete_cols_and_rows(BCP_lp_prob &p, BCP_lp_branching_object *can, const int added_colnum, const int added_rownum, const bool from_fathom, const bool force_delete)
BCP_price_vars
void BCP_price_vars(BCP_lp_prob &p, const bool from_fathom, BCP_vec< BCP_var * > &vars_to_add, BCP_vec< BCP_col * > &cols_to_add)
BCP_lp_perform_fathom
void BCP_lp_perform_fathom(BCP_lp_prob &p, const char *msg, BCP_message_tag msgtag)
BCP_lp_send_node_description
int BCP_lp_send_node_description(BCP_lp_prob &p, BCP_presolved_lp_brobj *brobj, BCP_message_tag msgtag)
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_lp_process_result
void BCP_lp_process_result(BCP_lp_prob &p, const BCP_lp_result &lpres)
BCP_enum.hpp
BCP_vec< BCP_var * >
BCP_lp_adjust_row_effectiveness
void BCP_lp_adjust_row_effectiveness(BCP_lp_prob &p)
BCP_lp_prepare_for_new_node
void BCP_lp_prepare_for_new_node(BCP_lp_prob &p)
BCP_lp_fathom
bool BCP_lp_fathom(BCP_lp_prob &p, const bool from_repricing)
BCP_lp_unpack_active_node
void BCP_lp_unpack_active_node(BCP_lp_prob &p, BCP_buffer &buf)
BCP_lp_pack_for_vg
BCP_message_tag BCP_lp_pack_for_vg(BCP_lp_prob &p)
BCP_lp_clean_up_node
void BCP_lp_clean_up_node(BCP_lp_prob &p)
BCP_lp_purge_slack_pool
void BCP_lp_purge_slack_pool(BCP_lp_prob &p)
BCP_lp_branching_object
This class describes a generic branching object.
Definition: BCP_lp_branch.hpp:70
BCP_lp_result
This class holds the results after solving an LP relaxation.
Definition: BCP_lp_result.hpp:39
BCP_lp_next_var_index
int BCP_lp_next_var_index(BCP_lp_prob &p)
BCP_lp_process_ub_message
void BCP_lp_process_ub_message(BCP_lp_prob &p, BCP_buffer &buf)
BCP_lp_fix_vars
bool BCP_lp_fix_vars(BCP_lp_prob &p)
BCP_lp_add_cols_to_lp
void BCP_lp_add_cols_to_lp(const BCP_vec< BCP_col * > &cols, OsiSolverInterface *lp)
BCP_lp_add_rows_to_lp
void BCP_lp_add_rows_to_lp(const BCP_vec< BCP_row * > &rows, OsiSolverInterface *lp)
BCP_lp_generate_vars
int BCP_lp_generate_vars(BCP_lp_prob &p, bool first_in_loop, const bool from_repricing)
BCP_lp_pack_for_cg
BCP_message_tag BCP_lp_pack_for_cg(BCP_lp_prob &p)
BCP_lp_branch
BCP_branching_result BCP_lp_branch(BCP_lp_prob &p)
OsiSolverInterface
BCP_presolved_lp_brobj
A presolved branching object candidate.
Definition: BCP_lp_branch.hpp:321
BCP_solution
This is the abstract base class for a solution to a Mixed Integer Programming problem.
Definition: BCP_solution.hpp:14
BCP_row
This class holds a row in a compressed form.
Definition: BCP_matrix.hpp:152
CoinWarmStart
BCP_var
Abstract base class that defines members common to all types of variables.
Definition: BCP_var.hpp:28
BCP_lp_repricing
void BCP_lp_repricing(BCP_lp_prob &p)
BCP_lp_add_from_local_cut_pool
int BCP_lp_add_from_local_cut_pool(BCP_lp_prob &p)
BCP_lp_prob
NO OLD DOC.
Definition: BCP_lp.hpp:102
BCP_message_tag.hpp
BCP_lp_test_feasibility
void BCP_lp_test_feasibility(BCP_lp_prob &p, const BCP_lp_result &lpres)
BCP_lp_next_cut_index
int BCP_lp_next_cut_index(BCP_lp_prob &p)
BCP_lp_send_cuts_to_cp
void BCP_lp_send_cuts_to_cp(BCP_lp_prob &p, const int eff_cnt_limit)
BCP_lp_unpack_diving_info
void BCP_lp_unpack_diving_info(BCP_lp_prob &p, BCP_buffer &buf)
BCP_warmstart
Warmstarting information for the LP solver.
Definition: BCP_warmstart.hpp:24
BCP_enum_branch.hpp
BCP_buffer
This class describes the message buffer used for all processes of BCP.
Definition: BCP_buffer.hpp:39
BCP_lp_compute_lower_bound
double BCP_lp_compute_lower_bound(BCP_lp_prob &p, const BCP_lp_result &lpres)