00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #ifndef PPL_MIP_Problem_inlines_hh
00024 #define PPL_MIP_Problem_inlines_hh 1
00025
00026 #include "Constraint.defs.hh"
00027 #include <stdexcept>
00028
00029 namespace Parma_Polyhedra_Library {
00030
00031 inline dimension_type
00032 MIP_Problem::max_space_dimension() {
00033 return Constraint::max_space_dimension();
00034 }
00035
00036 inline dimension_type
00037 MIP_Problem::space_dimension() const {
00038 return external_space_dim;
00039 }
00040
00041
00042 inline
00043 MIP_Problem::MIP_Problem(const MIP_Problem& y)
00044 : external_space_dim(y.external_space_dim),
00045 internal_space_dim(y.internal_space_dim),
00046 tableau(y.tableau),
00047 working_cost(y.working_cost),
00048 mapping(y.mapping),
00049 base(y.base),
00050 status(y.status),
00051 pricing(y.pricing),
00052 initialized(y.initialized),
00053 input_cs(y.input_cs),
00054 first_pending_constraint(y.first_pending_constraint),
00055 input_obj_function(y.input_obj_function),
00056 opt_mode(y.opt_mode),
00057 last_generator(y.last_generator),
00058 i_variables(y.i_variables) {
00059 assert(OK());
00060 }
00061
00062 inline
00063 MIP_Problem::~MIP_Problem() {
00064 }
00065
00066
00067 inline void
00068 MIP_Problem::set_optimization_mode(const Optimization_Mode mode) {
00069 if (opt_mode != mode) {
00070 opt_mode = mode;
00071 if (status == UNBOUNDED || status == OPTIMIZED)
00072 status = SATISFIABLE;
00073 assert(OK());
00074 }
00075 }
00076
00077 inline const Linear_Expression&
00078 MIP_Problem::objective_function() const {
00079 return input_obj_function;
00080 }
00081
00082 inline Optimization_Mode
00083 MIP_Problem::optimization_mode() const {
00084 return opt_mode;
00085 }
00086
00087 inline void
00088 MIP_Problem::optimal_value(Coefficient& num, Coefficient& den) const {
00089 const Generator& g = optimizing_point();
00090 evaluate_objective_function(g, num, den);
00091 }
00092
00093 inline MIP_Problem::const_iterator
00094 MIP_Problem::constraints_begin() const {
00095 return input_cs.begin();
00096 }
00097
00098 inline MIP_Problem::const_iterator
00099 MIP_Problem::constraints_end() const {
00100 return input_cs.end();
00101 }
00102
00103 inline const Variables_Set&
00104 MIP_Problem::integer_space_dimensions() const {
00105 return i_variables;
00106 }
00107
00108 inline MIP_Problem::Control_Parameter_Value
00109 MIP_Problem::get_control_parameter(Control_Parameter_Name name) const {
00110 used(name);
00111 assert(name == PRICING);
00112 return pricing;
00113 }
00114
00115 inline void
00116 MIP_Problem::set_control_parameter(Control_Parameter_Value value) {
00117 pricing = value;
00118 }
00119
00120 inline void
00121 MIP_Problem::swap(MIP_Problem& y) {
00122 std::swap(external_space_dim, y.external_space_dim);
00123 std::swap(internal_space_dim, y.internal_space_dim);
00124 std::swap(tableau, y.tableau);
00125 std::swap(working_cost, y.working_cost);
00126 std::swap(mapping, y.mapping);
00127 std::swap(initialized, y.initialized);
00128 std::swap(base, y.base);
00129 std::swap(status, y.status);
00130 std::swap(pricing, y.pricing);
00131 std::swap(input_cs, y.input_cs);
00132 std::swap(first_pending_constraint, y.first_pending_constraint);
00133 std::swap(input_obj_function, y.input_obj_function);
00134 std::swap(opt_mode, y.opt_mode);
00135 std::swap(last_generator, y.last_generator);
00136 std::swap(i_variables, y.i_variables);
00137 }
00138
00139 inline MIP_Problem&
00140 MIP_Problem::operator=(const MIP_Problem& y) {
00141 MIP_Problem tmp(y);
00142 swap(tmp);
00143 return *this;
00144 }
00145
00146 inline void
00147 MIP_Problem::clear() {
00148 MIP_Problem tmp;
00149 swap(tmp);
00150 }
00151
00152 inline memory_size_type
00153 MIP_Problem::external_memory_in_bytes() const {
00154 memory_size_type n
00155 = tableau.external_memory_in_bytes()
00156 + working_cost.external_memory_in_bytes()
00157 + input_obj_function.external_memory_in_bytes()
00158 + last_generator.external_memory_in_bytes();
00159
00160 n += input_cs.capacity() * sizeof(Constraint);
00161 for (const_iterator i = input_cs.begin(),
00162 i_end = input_cs.end(); i != i_end; ++i)
00163 n += (i->external_memory_in_bytes());
00164
00165 n += base.capacity() * sizeof(dimension_type);
00166
00167 n += mapping.capacity() * sizeof(std::pair<dimension_type, dimension_type>);
00168 return n;
00169 }
00170
00171 inline memory_size_type
00172 MIP_Problem::total_memory_in_bytes() const {
00173 return sizeof(*this) + external_memory_in_bytes();
00174 }
00175
00176 }
00177
00178 namespace std {
00179
00181 inline void
00182 swap(Parma_Polyhedra_Library::MIP_Problem& x,
00183 Parma_Polyhedra_Library::MIP_Problem& y) {
00184 x.swap(y);
00185 }
00186
00187 }
00188
00189 #endif // !defined(PPL_MIP_Problem_inlines_hh)