00001
00002
00003
00004 #include "BCP_math.hpp"
00005 #include "BCP_buffer.hpp"
00006 #include "BCP_message.hpp"
00007 #include "BCP_problem_core.hpp"
00008 #include "BCP_lp_node.hpp"
00009 #include "BCP_lp.hpp"
00010 #include "OsiSolverInterface.hpp"
00011 #include "BCP_lp_result.hpp"
00012 #include "BCP_lp_pool.hpp"
00013
00014 #include "BCP_lp_user.hpp"
00015
00016 #include "BCP_warmstart.hpp"
00017
00018
00019
00020 void
00021 BCP_lp_statistics::pack(BCP_buffer& buf)
00022 {
00023 buf.pack(time_cut_generation)
00024 .pack(time_var_generation)
00025 .pack(time_heuristics)
00026 .pack(time_lp_solving)
00027 .pack(time_branching);
00028 }
00029 void
00030 BCP_lp_statistics::unpack(BCP_buffer& buf)
00031 {
00032 buf.unpack(time_cut_generation)
00033 .unpack(time_var_generation)
00034 .unpack(time_heuristics)
00035 .unpack(time_lp_solving)
00036 .unpack(time_branching);
00037 }
00038 void
00039 BCP_lp_statistics::display() const
00040 {
00041 printf("LP statistics:\n");
00042 printf(" time in cut generation : %12.3f sec\n", time_cut_generation);
00043 printf(" time in var generation : %12.3f sec\n", time_var_generation);
00044 printf(" time in heuristics : %12.3f sec\n", time_heuristics);
00045 printf(" time in solving LPs : %12.3f sec\n", time_lp_solving);
00046 printf(" time in strong branching: %12.3f sec\n", time_branching);
00047 printf("\n");
00048 }
00049 void
00050 BCP_lp_statistics::add(const BCP_lp_statistics& stat)
00051 {
00052 time_cut_generation += stat.time_cut_generation;
00053 time_var_generation += stat.time_var_generation;
00054 time_heuristics += stat.time_heuristics ;
00055 time_lp_solving += stat.time_lp_solving ;
00056 time_branching += stat.time_branching ;
00057 }
00058
00059
00060
00061 BCP_lp_prob::BCP_lp_prob(int my_id, int parent) :
00062 BCP_process(my_id, parent),
00063 user(0),
00064 master_lp(0),
00065 lp_solver(0),
00066 msg_env(0),
00067 core(new BCP_problem_core),
00068 core_as_change(new BCP_problem_core_change),
00069 node(new BCP_lp_node),
00070 parent(new BCP_lp_parent),
00071 warmstartRoot(NULL),
00072 lp_result(new BCP_lp_result),
00073 var_bound_changes_since_logical_fixing(0),
00074 local_var_pool(new BCP_lp_var_pool),
00075 local_cut_pool(new BCP_lp_cut_pool),
00076 next_var_index(0),
00077 last_var_index(0),
00078 next_cut_index(0),
00079 last_cut_index(0),
00080 upper_bound(BCP_DBL_MAX),
00081 phase(0)
00082 {}
00083
00084 BCP_lp_prob::~BCP_lp_prob() {
00085
00086 delete user;
00087 delete packer;
00088 delete master_lp;
00089 delete lp_solver;
00090
00091 delete core;
00092 delete core_as_change;
00093
00094 delete node;
00095 delete parent;
00096 delete warmstartRoot;
00097
00098 delete lp_result;
00099 purge_ptr_vector(slack_pool);
00100
00101 delete local_var_pool;
00102 delete local_cut_pool;
00103
00104
00105
00106
00107
00108
00109
00110 }
00111
00112
00113
00114 void
00115 BCP_lp_prob::pack_var(const BCP_var& var)
00116 {
00117 const int bcpind = var.bcpind();
00118 msg_buf.pack(bcpind);
00119 const BCP_object_t obj_t = var.obj_type();
00120 const BCP_obj_status varstat = var.status();
00121 const BCP_var_t var_t = var.var_type();
00122 const double obj = var.obj();
00123 const double lb = var.lb();
00124 const double ub = var.ub();
00125 msg_buf.pack(obj_t).pack(varstat).pack(var_t).pack(obj).pack(lb).pack(ub);
00126 switch (obj_t) {
00127 case BCP_CoreObj:
00128 break;
00129 case BCP_AlgoObj:
00130 packer->pack_var_algo(&dynamic_cast<const BCP_var_algo&>(var), msg_buf);
00131 break;
00132 default:
00133 throw BCP_fatal_error("BCP_lp_prob::_pack_var(): unexpected obj_t.\n");
00134 }
00135 }
00136
00137
00138
00139 BCP_var*
00140 BCP_lp_prob::unpack_var()
00141 {
00142 BCP_object_t obj_t;
00143 int bcpind;
00144 BCP_var_t var_t;
00145 double obj, lb, ub;
00146 BCP_obj_status varstat;
00147 msg_buf.unpack(bcpind)
00148 .unpack(obj_t).unpack(varstat)
00149 .unpack(var_t).unpack(obj).unpack(lb).unpack(ub);
00150
00151 BCP_var* var = 0;
00152 switch (obj_t) {
00153 case BCP_CoreObj:
00154 var = new BCP_var_core(var_t, obj, lb, ub);
00155 break;
00156 case BCP_AlgoObj:
00157 var = packer->unpack_var_algo(msg_buf);
00158 var->set_var_type(var_t);
00159 var->change_bounds(lb, ub);
00160 var->set_obj(obj);
00161 break;
00162 default:
00163 throw BCP_fatal_error("BCP_lp_prob::_unpack_var(): unexpected obj_t.\n");
00164 }
00165 var->set_bcpind(bcpind);
00166 var->set_status(varstat);
00167
00168 return var;
00169 }
00170
00171
00172
00173 void
00174 BCP_lp_prob::pack_cut(const BCP_cut& cut)
00175 {
00176 const int bcpind = cut.bcpind();
00177 msg_buf.pack(bcpind);
00178 const BCP_object_t obj_t = cut.obj_type();
00179 const BCP_obj_status cutstat = cut.status();
00180 const double lb = cut.lb();
00181 const double ub = cut.ub();
00182 msg_buf.pack(obj_t).pack(cutstat).pack(lb).pack(ub);
00183 switch (obj_t) {
00184 case BCP_CoreObj:
00185 break;
00186 case BCP_AlgoObj:
00187 packer->pack_cut_algo(&dynamic_cast<const BCP_cut_algo&>(cut), msg_buf);
00188 break;
00189 default:
00190 throw BCP_fatal_error("BCP_lp_prob::_pack_cut(): unexpected obj_t.\n");
00191 }
00192 }
00193
00194
00195
00196 BCP_cut*
00197 BCP_lp_prob::unpack_cut()
00198 {
00199 BCP_object_t obj_t;
00200 int bcpind;
00201 double lb, ub;
00202 BCP_obj_status cutstat;
00203 msg_buf.unpack(bcpind).unpack(obj_t).unpack(cutstat).unpack(lb).unpack(ub);
00204
00205 BCP_cut* cut = 0;
00206 switch (obj_t) {
00207 case BCP_CoreObj:
00208 cut = new BCP_cut_core(lb, ub);
00209 break;
00210 case BCP_AlgoObj:
00211 cut = packer->unpack_cut_algo(msg_buf);
00212 cut->change_bounds(lb, ub);
00213 break;
00214 default:
00215 throw BCP_fatal_error("BCP_lp_prob::_unpack_cut(): unexpected obj_t.\n");
00216 }
00217 cut->set_bcpind(bcpind);
00218 cut->set_status(cutstat);
00219
00220 return cut;
00221 }