/usr/include/coin/MP_constraint.hpp is in coinor-libflopc++-dev 1.0.6-3.1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 | // ******************** FlopCpp **********************************************
// File: MP_constraint.hpp
// $Id$
// Author: Tim Helge Hultberg (thh@mat.ua.pt)
// Copyright (C) 2003 Tim Helge Hultberg
// All Rights Reserved.
// ****************************************************************************
#ifndef _MP_constraint_hpp_
#define _MP_constraint_hpp_
#include <set>
using std::set;
#include <map>
using std::map;
#include "MP_set.hpp"
#include "MP_domain.hpp"
#include "MP_utilities.hpp"
#include "MP_expression.hpp"
#include "MP_boolean.hpp"
#include "MP_data.hpp"
namespace flopc {
class MP_constraint;
class Constant;
class MP_model;
class MP_variable;
/** @brief Enumeration for indicating direction of a constraint.
@ingroup INTERNAL_USE
*/
enum Sense_enum {LE,GE,EQ};
/** Semantic representation of a constraint in a Math Program
@ingroup INTERNAL_USE
@see MP_constraint for a public interface.
@note of interest is the operator overloads which are 'friends'
*/
class Constraint_base {
public:
Constraint_base(const MP_expression& l, const MP_expression& r, Sense_enum s) :
left(l), right(r), sense(s), count(0) {}
MP_expression left,right;
Sense_enum sense;
// protected:
int count;
};
class Constraint : public Handle<Constraint_base*> {
friend class MP_constraint;
friend class MP_model;
friend class Constraint_base;
friend Constraint operator<=(const MP_expression& l, const MP_expression& r);
friend Constraint operator<=(const Constant& l, const MP_expression& r);
friend Constraint operator<=(const MP_expression& l, const Constant& r);
friend Constraint operator<=(const VariableRef& l, const VariableRef& r);
friend Constraint operator>=(const MP_expression& l, const MP_expression& r);
friend Constraint operator>=(const Constant& l, const MP_expression& r);
friend Constraint operator>=(const MP_expression& l, const Constant& r);
friend Constraint operator>=(const VariableRef& l, const VariableRef& r);
friend Constraint operator==(const MP_expression& l, const MP_expression& r);
friend Constraint operator==(const Constant& l, const MP_expression& r);
friend Constraint operator==(const MP_expression& l, const Constant& r);
friend Constraint operator==(const VariableRef& l, const VariableRef& r);
public:
Constraint() : Handle<Constraint_base*>(0) {}
Constraint(Constraint_base* r) : Handle<Constraint_base*>(r) {}
// MP_expression getLeft() {return root->left;}
};
/** @brief Uses operator overloading to construct an Constraint
@ingroup PublicInterface
Constucts a Constraint using operator overloading.
@see MP_constraint
*/
inline Constraint operator<=(const MP_expression& l, const MP_expression& r) {
return new Constraint_base(l, r, LE);
}
/** @brief Uses operator overloading to construct an Constraint
@ingroup PublicInterface
Constucts a Constraint using operator overloading.
@see MP_constraint
*/
inline Constraint operator<=(const Constant& l, const MP_expression& r) {
return operator<=(MP_expression(l), r);
}
/** @brief Uses operator overloading to construct an Constraint
@ingroup PublicInterface
Constucts a Constraint using operator overloading.
@see MP_constraint
*/
inline Constraint operator<=(const MP_expression& l, const Constant& r){
return operator<=(l, MP_expression(r));
}
/** @brief Uses operator overloading to construct an Constraint
@ingroup PublicInterface
Constucts a Constraint using operator overloading.
@see MP_constraint
*/
inline Constraint operator<=(const VariableRef& l, const VariableRef& r) {
return new Constraint_base(l, r, LE);
}
/** @brief Uses operator overloading to construct an Constraint
@ingroup PublicInterface
Constucts a Constraint using operator overloading.
@see MP_constraint
*/
inline Constraint operator>=(const MP_expression& l, const MP_expression& r) {
return new Constraint_base(l, r, GE);
}
/** @brief Uses operator overloading to construct an Constraint
@ingroup PublicInterface
Constucts a Constraint using operator overloading.
@see MP_constraint
*/
inline Constraint operator>=(const Constant& l, const MP_expression& r){
return operator>=(MP_expression(l), r);
}
/** @brief Uses operator overloading to construct an Constraint
@ingroup PublicInterface
Constucts a Constraint using operator overloading.
@see MP_constraint
*/
inline Constraint operator>=(const MP_expression& l, const Constant& r){
return operator>=(l, MP_expression(r));
}
/** @brief Uses operator overloading to construct an Constraint
@ingroup PublicInterface
Constucts a Constraint using operator overloading.
@see MP_constraint
*/
inline Constraint operator>=(const VariableRef& l, const VariableRef& r) {
return new Constraint_base(l, r, GE);
}
/** @brief Uses operator overloading to construct an Constraint
@ingroup PublicInterface
Constucts a Constraint using operator overloading.
@see MP_constraint
*/
inline Constraint operator==(const MP_expression& l, const MP_expression& r) {
return new Constraint_base(l, r, EQ);
}
/** @brief Uses operator overloading to construct an Constraint
@ingroup PublicInterface
Constucts a Constraint using operator overloading.
@see MP_constraint
*/
inline Constraint operator==(const Constant& l, const MP_expression& r){
return operator==(MP_expression(l), r);
}
/** @brief Uses operator overloading to construct an Constraint
@ingroup PublicInterface
Constucts a Constraint using operator overloading.
@see MP_constraint
*/
inline Constraint operator==(const MP_expression& l, const Constant& r) {
return operator==(l, MP_expression(r));
}
/** @brief Uses operator overloading to construct an Constraint
@ingroup PublicInterface
Constucts a Constraint using operator overloading.
@see MP_constraint
*/
inline Constraint operator==(const VariableRef& l, const VariableRef& r) {
return new Constraint_base(l, r, EQ);
}
class GenerateFunctor;
/** @brief Semantic representation of a linear constraint.
@ingroup PublicInterface
This is one of the main public interface classes. It is always constructed
through operator overloading between expressions, constants, and
variables.
There are many 'friend' overloaded operators to do the constuction.
The basic idea is to make the constraint look like a paper-model
constraint in C++ code. Once constructed, it should be added to the model.
The snippet below is an overly simplistic example, but is ok for
illustration.
<code> <br>
MP_model aModel; // your model<br>
MP_set I; // the set the constraint is defined over. <br>
MP_variable x(I); // your variable<br>
...<br>
MP_constraint cons(I); // construct the right number of constraints.<br>
cons = x <= 3;<br> // Assign in the semantic rep to it.
aModel.add(cons); // add it to the model <br>
</code>
<br>
There is quite a bit of C++ machinery going on there.
@li MP_expression(const VariableRef& v); converts the VariableRef x into an MP_expression.
@li MP_constraint cons(I); construct the right dimensioned sized bundle of constraints.<br>
@li friend Constraint operator<=(const MP_expression& l, const Constant& r); converts the x <= 3 into an Constraint.
@todo more work on MP_constraint.
*/
class MP_constraint : public RowMajor, public Named {
public:
/// construct the MP_constraint with appropriate sets for indexing.
MP_constraint(
const MP_set_base &s1 = MP_set::getEmpty(),
const MP_set_base &s2 = MP_set::getEmpty(),
const MP_set_base &s3 = MP_set::getEmpty(),
const MP_set_base &s4 = MP_set::getEmpty(),
const MP_set_base &s5 = MP_set::getEmpty()
);
MP_constraint& operator()(
const MP_index_exp& i1 = MP_index_exp::getEmpty(),
const MP_index_exp& i2 = MP_index_exp::getEmpty(),
const MP_index_exp& i3 = MP_index_exp::getEmpty(),
const MP_index_exp& i4 = MP_index_exp::getEmpty(),
const MP_index_exp& i5 = MP_index_exp::getEmpty()
) {
I1 = i1; I2 = i2; I3 = i3; I4 = i4; I5 = i5;
return *this;
}
operator int() {
return offset + f(I1->evaluate(),I2->evaluate(),I3->evaluate(),
I4->evaluate(),I5->evaluate());
}
virtual ~MP_constraint() {}
double price(int i1=0, int i2=0, int i3=0, int i4=0, int i5=0) const;
void coefficients(vector<MP::Coef>& cfs);
int row_number() const;
MP_constraint& such_that(const MP_boolean& b) {
B = b;
return *this;
}
void insertVariables(set<MP_variable*>& v);
void operator=(const Constraint& v);
void display(string s="") const;
MP_model* M;
int offset;
MP_expression left,right;
Sense_enum sense;
private:
MP_boolean B;
const MP_set_base &S1, &S2, &S3, &S4, &S5;
MP_index_exp I1, I2, I3, I4, I5;
};
} // End of namespace flopc
#endif
|