Scippy

SoPlex

Sequential object-oriented simPlex

lprowbase.h
Go to the documentation of this file.
1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2 /* */
3 /* This file is part of the class library */
4 /* SoPlex --- the Sequential object-oriented simPlex. */
5 /* */
6 /* Copyright (C) 1996-2022 Konrad-Zuse-Zentrum */
7 /* fuer Informationstechnik Berlin */
8 /* */
9 /* SoPlex is distributed under the terms of the ZIB Academic Licence. */
10 /* */
11 /* You should have received a copy of the ZIB Academic License */
12 /* along with SoPlex; see the file COPYING. If not email to soplex@zib.de. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file lprowbase.h
17  * @brief (In)equality for LPs.
18  */
19 #ifndef _LPROWBASE_H_
20 #define _LPROWBASE_H_
21 
22 #include <assert.h>
23 
24 #include "soplex/spxdefines.h"
25 #include "soplex/basevectors.h"
26 
27 namespace soplex
28 {
29 /**@brief (In)equality for LPs.
30  * @ingroup Algo
31  *
32  * Class LPRowBase provides constraints for linear programs in the form \f[ l \le a^Tx \le r, \f] where \em a is a
33  * DSVector. \em l is referred to as %left hand side, \em r as %right hand side and \em a as \em row \em vector or the
34  * constraint vector. \em l and \em r may also take values \f$\pm\f$ #R(infinity). This static member is predefined, but
35  * may be overridden to meet the needs of the LP solver to be used.
36  *
37  * LPRowBases allow to specify regular inequalities of the form \f[ a^Tx \sim \alpha, \f] where \f$\sim\f$ can take any
38  * value of \f$\le, =, \ge\f$, by setting rhs and lhs to the same value or setting one of them to \f$\infty\f$.
39  *
40  * Since constraints in the regular form occur often, LPRowBases offers methods type() and value() for retreiving
41  * \f$\sim\f$ and \f$\alpha\f$ of an LPRowBase in this form, respectively. Also, a constructor for LPRowBases given in
42  * regular form is provided.
43  */
44 template < class R >
45 class LPRowBase
46 {
47  template < class S > friend class LPRowBase;
48 
49 private:
50 
51  // ------------------------------------------------------------------------------------------------------------------
52  /**@name Data */
53  ///@{
54 
55  R left; ///< left-hand side of the constraint
56  R right; ///< right-hand side of the constraint
57  R object; ///< objective coefficient of corresponding slack variable s = vec times primal
58  DSVectorBase<R> vec; ///< the row vector
59 
60  ///@}
61 
62 public:
63 
64  // ------------------------------------------------------------------------------------------------------------------
65  /**@name Types */
66  ///@{
67 
68  /// (In)Equality type of an LP row.
69  /** #LPRowBase%s may be of one of the following Types. This datatype may be used for constructing new #LPRowBase%s in the
70  * regular form.
71  */
72  enum Type
73  {
74  LESS_EQUAL, ///< \f$a^Tx \le \alpha\f$.
75  EQUAL, ///< \f$a^Tx = \alpha\f$.
76  GREATER_EQUAL, ///< \f$a^Tx \ge \alpha\f$.
77  RANGE ///< \f$\lambda \le a^Tx \le \rho\f$.
78  };
79 
80  ///@}
81 
82  // ------------------------------------------------------------------------------------------------------------------
83  /**@name Construction / destruction */
84  ///@{
85 
86  /// Constructs LPRowBase with a vector ready to hold \p defDim nonzeros.
87  explicit LPRowBase<R>(int defDim = 0)
88  : left(0), right(R(infinity)), object(0), vec(defDim)
89  {
90  assert(isConsistent());
91  }
92 
93  /// Copy constructor.
95  : left(row.left), right(row.right), object(row.object), vec(row.vec)
96  {
97  assert(isConsistent());
98  }
99 
100  /// Copy constructor.
101  template < class S >
103  : left(row.left), right(row.right), object(row.object), vec(row.vec)
104  {
105  assert(isConsistent());
106  }
107 
108  /// Constructs LPRowBase with the given left-hand side, right-hand side and rowVector.
109  LPRowBase<R>(const R& p_lhs, const SVectorBase<R>& p_rowVector, const R& p_rhs, const R& p_obj = 0)
110  : left(p_lhs), right(p_rhs), object(p_obj), vec(p_rowVector)
111  {
112  assert(isConsistent());
113  }
114 
115  /// Constructs LPRowBase from passed \p rowVector, \p type and \p value.
116  LPRowBase<R>(const SVectorBase<R>& p_rowVector, Type p_type, const R& p_value, const R& p_obj = 0)
117  : object(p_obj), vec(p_rowVector)
118  {
119  switch(p_type)
120  {
121  case LESS_EQUAL:
122  left = R(-infinity);
123  right = p_value;
124  break;
125 
126  case EQUAL:
127  left = p_value;
128  right = p_value;
129  break;
130 
131  case GREATER_EQUAL:
132  left = p_value;
133  right = R(infinity);
134  break;
135 
136  default:
137  throw SPxInternalCodeException("XLPROW03 This should never happen.");
138  }
139 
140  assert(isConsistent());
141  }
142 
143  /// Destructor.
145  {}
146 
147  ///@}
148 
149  // ------------------------------------------------------------------------------------------------------------------
150  /**@name Access / modification */
151  ///@{
152 
153  /// Gets type of row.
154  Type type() const
155  {
156  if(rhs() >= R(infinity))
157  return GREATER_EQUAL;
158 
159  if(lhs() <= R(-infinity))
160  return LESS_EQUAL;
161 
162  if(lhs() == rhs())
163  return EQUAL;
164 
165  return RANGE;
166  }
167 
168  /// Sets type of (in)equality.
169  void setType(Type p_type)
170  {
171  switch(p_type)
172  {
173  case LESS_EQUAL:
174  left = R(-infinity);
175  break;
176 
177  case EQUAL:
178  if(lhs() > R(-infinity))
179  right = lhs();
180  else
181  left = rhs();
182 
183  break;
184 
185  case GREATER_EQUAL:
186  right = R(infinity);
187  break;
188 
189  case RANGE:
190  MSG_ERROR(std::cerr << "ELPROW01 RANGE not supported in LPRow::setType()"
191  << std::endl;)
192  throw SPxInternalCodeException("XLPROW01 This should never happen.");
193 
194  default:
195  throw SPxInternalCodeException("XLPROW02 This should never happen.");
196  }
197  }
198 
199  /// Right hand side value of (in)equality.
200  /** This method returns \f$\alpha\f$ for a LPRowBase in regular form. However, value() may only be called for
201  * LPRowBase%s with type() != \c RANGE.
202  */
203  R value() const
204  {
205  assert(type() != RANGE);
206 
207  return (rhs() < R(infinity)) ? rhs() : lhs();
208  }
209 
210  /// Left-hand side value.
211  R lhs() const
212  {
213  return left;
214  }
215 
216  /// Sets left-hand side value.
217  void setLhs(const R& p_left)
218  {
219  left = p_left;
220  }
221 
222  /// Right-hand side value.
223  R rhs() const
224  {
225  return right;
226  }
227 
228  /// Sets right-hand side value.
229  void setRhs(const R& p_right)
230  {
231  right = p_right;
232  }
233 
234  /// Objective coefficient value.
235  R obj() const
236  {
237  return object;
238  }
239 
240  /// Sets objective coefficient value.
241  void setObj(const R& p_obj)
242  {
243  object = p_obj;
244  }
245 
246  /// Constraint row vector.
247  const SVectorBase<R>& rowVector() const
248  {
249  return vec;
250  }
251 
252  /// access constraint row vector.
253  void setRowVector(const DSVectorBase<R>& p_vec)
254  {
255  vec = p_vec;
256  }
257 
258  ///@}
259 
260  // ------------------------------------------------------------------------------------------------------------------
261  /**@name Consistency check */
262  ///@{
263 
264  /// Checks consistency.
265  bool isConsistent() const
266  {
267 #ifdef ENABLE_CONSISTENCY_CHECKS
268  return vec.isConsistent();
269 #else
270  return true;
271 #endif
272  }
273 
274  ///@}
275 };
276 
277 } // namespace soplex
278 #endif // _LPROWBASE_H_
Exception class for things that should NEVER happen.This class is derived from the SoPlex exception b...
Definition: exceptions.h:109
THREADLOCAL const Real infinity
Definition: spxdefines.cpp:32
const SVectorBase< R > & rowVector() const
Constraint row vector.
Definition: lprowbase.h:247
R rhs() const
Right-hand side value.
Definition: lprowbase.h:223
R value() const
Right hand side value of (in)equality.
Definition: lprowbase.h:203
Dynamic sparse vectors.Class DSVectorBase implements dynamic sparse vectors, i.e. SVectorBases with a...
Definition: dsvectorbase.h:43
~LPRowBase()
Destructor.
Definition: lprowbase.h:144
void setType(Type p_type)
Sets type of (in)equality.
Definition: lprowbase.h:169
DSVectorBase< R > vec
the row vector
Definition: lprowbase.h:58
bool isConsistent() const
Checks consistency.
Definition: lprowbase.h:265
Type type() const
Gets type of row.
Definition: lprowbase.h:154
R lhs() const
Left-hand side value.
Definition: lprowbase.h:211
#define MSG_ERROR(x)
Prints out message x if the verbosity level is at least SPxOut::ERROR.
Definition: spxdefines.h:152
bool isConsistent() const
Consistency check.
Definition: dsvectorbase.h:294
void setObj(const R &p_obj)
Sets objective coefficient value.
Definition: lprowbase.h:241
(In)equality for LPs.Class LPRowBase provides constraints for linear programs in the form where a is...
Definition: lprowbase.h:45
Debugging, floating point type and parameter definitions.
void setLhs(const R &p_left)
Sets left-hand side value.
Definition: lprowbase.h:217
Collection of dense, sparse, and semi-sparse vectors.
Everything should be within this namespace.
Type
(In)Equality type of an LP row.
Definition: lprowbase.h:72
R obj() const
Objective coefficient value.
Definition: lprowbase.h:235
void setRowVector(const DSVectorBase< R > &p_vec)
access constraint row vector.
Definition: lprowbase.h:253
R right
right-hand side of the constraint
Definition: lprowbase.h:56
R object
objective coefficient of corresponding slack variable s = vec times primal
Definition: lprowbase.h:57
R left
left-hand side of the constraint
Definition: lprowbase.h:55
Sparse vectors.Class SVectorBase provides packed sparse vectors. Such are a sparse vectors...
Definition: ssvectorbase.h:34
void setRhs(const R &p_right)
Sets right-hand side value.
Definition: lprowbase.h:229