/home/coin/SVN-release/OS-2.1.0/Bcp/src/LP/BCP_lp.cpp

Go to the documentation of this file.
00001 // Copyright (C) 2000, International Business Machines
00002 // Corporation and others.  All Rights Reserved.
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    // these are vectors of ptrs, but they need not be purged. they just point
00105    // into the appropriate fields of p.node->vars/cuts
00106    //    purge_ptr_vector(all_vars);
00107    //    purge_ptr_vector(all_cuts);
00108 
00109    // delete tree_manager; this pointer must NOT be deleted!!!
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 }

Generated on Tue Mar 30 03:04:32 2010 by  doxygen 1.4.7