Scippy

SCIP

Solving Constraint Integer Programs

intervalarithext.h
Go to the documentation of this file.
1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2 /* */
3 /* This file is part of the program and library */
4 /* SCIP --- Solving Constraint Integer Programs */
5 /* */
6 /* Copyright (C) 2002-2016 Konrad-Zuse-Zentrum */
7 /* fuer Informationstechnik Berlin */
8 /* */
9 /* SCIP is distributed under the terms of the ZIB Academic License. */
10 /* */
11 /* You should have received a copy of the ZIB Academic License */
12 /* along with SCIP; see the file COPYING. If not email to scip@zib.de. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file intervalarithext.h
17  * @brief C++ extensions to interval arithmetics for provable bounds
18  * @author Stefan Vigerske
19  */
20 
21 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
22 
23 #ifndef __SCIP_INTERVALARITHEXT_HPP__
24 #define __SCIP_INTERVALARITHEXT_HPP__
25 
26 #include "scip/intervalarith.h"
27 #include "scip/pub_message.h"
28 
29 /* In some cases, a user may need the SCIPInterval class to be defined in some namespace.
30  * To allow this, the symbol SCIPInterval_NAMESPACE should be defined to the name of that namespace
31  * before inclusion of this header file
32  * It is in the users responsibility to implement the corresponding symbols from nlpi/intervalarith.c.
33  */
34 #ifdef SCIPInterval_NAMESPACE
35 namespace SCIPInterval_NAMESPACE {
36 #endif
37 
38 /** an interval that extends the SCIP_INTERVAL struct
39  *
40  * Used by various methods to allow calculating with intervals as with ordinary numbers.
41  */
42 class SCIPInterval : public SCIP_INTERVAL
43 {
44 public:
45  /** value to use for infinity
46  *
47  * Currently a global variable, thus use with care!
48  */
50 
51  /** default constructor -> gives entire interval */
53  {
54  SCIPintervalSetBounds(this, -SCIPInterval::infinity,SCIPInterval::infinity);
55  }
56 
57  /** constructor for an SCIP_INTERVAL struct */
59  const SCIP_INTERVAL& x /**< interval to copy */
60  )
61  {
62  SCIPintervalSetBounds(this, x.inf, x.sup);
63  }
64 
65  /** constructor for an interval giving pointwise bounds */
67  SCIP_Real infinum, /**< lower bound of interval */
68  SCIP_Real supremum /**< upper bound of interval */
69  )
70  {
71  SCIPintervalSetBounds(this, infinum, supremum);
72  }
73 
74  /** constructor for a singleton */
76  SCIP_Real number /**< number to be represented by interval */
77  )
78  {
79  SCIPintervalSet(this, number);
80  }
81 
82  /** sets interval bounds */
83  void setBounds(
84  SCIP_Real newinf, /**< lower bound of interval */
85  SCIP_Real newsup /**< upper bound of interval */
86  )
87  {
88  SCIPintervalSetBounds(this, newinf, newsup);
89  }
90 
91  /** returns whether this interval is equal to another one */
92  bool operator==(
93  const SCIP_INTERVAL& y /**< interval to compare with */
94  ) const
95  {
96  if( SCIPintervalIsEmpty(SCIPInterval::infinity, *this) && !SCIPintervalIsEmpty(SCIPInterval::infinity, y) )
97  return false;
98  if( this->inf <= -SCIPInterval::infinity && y.inf > -SCIPInterval::infinity )
99  return false;
100  if( this->sup >= SCIPInterval::infinity && y.sup < SCIPInterval::infinity )
101  return false;
102  return (this->inf == y.inf) && (this->sup == y.sup);
103  }
104 
105  /** returns whether this interval is not equal to another one */
107  const SCIP_INTERVAL& y /**< interval to compare with */
108  ) const
109  {
110  return !operator==(y);
111  }
112 
113  /** returns whether this interval is equal to a given number */
115  const SCIP_Real& y /**< number to compare with */
116  ) const
117  {
118  return ( (inf == y) && (sup == y) ) ||
119  ( sup <= -SCIPInterval::infinity && y <= -SCIPInterval::infinity ) ||
121  }
122 
123  /** adds another interval to this one */
125  const SCIPInterval& y /**< interval to add in */
126  )
127  {
128  SCIPintervalAdd(SCIPInterval::infinity, this, *this, y);
129  return *this;
130  }
131 
132  /** subtracts an interval from this one */
134  const SCIPInterval& y /**< interval to substract */
135  )
136  {
137  SCIPintervalSub(SCIPInterval::infinity, this, *this, y);
138  return *this;
139  }
140 
141  /** multiplies an interval with this one */
143  const SCIPInterval& y /**< interval to multiply with */
144  )
145  {
146  SCIPintervalMul(SCIPInterval::infinity, this, *this, y);
147  return *this;
148  }
149 
150  /** divides this interval by another one */
152  const SCIPInterval& y /**< interval to divide by */
153  )
154  {
155  SCIPintervalDiv(SCIPInterval::infinity, this, *this, y);
156  return *this;
157  }
158 
159  /** assigns a number to this interval */
161  const SCIP_Real& y /**< new value for both interval bounds */
162  )
163  {
164  SCIPintervalSet(this, y);
165  return *this;
166  }
167 
168  /** assign an interval to this interval */
170  const SCIP_INTERVAL& y /**< new value for this interval */
171  )
172  {
173  SCIPintervalSetBounds(this, y.inf, y.sup);
174  return *this;
175  }
176 
177 };
178 
179 /** addition of two intervals */
180 inline
182  const SCIPInterval& x, /**< first operand */
183  const SCIPInterval& y /**< second operand */
184  )
185 {
186  SCIPInterval resultant;
187 
188  SCIPintervalAdd(SCIPInterval::infinity, &resultant, x, y);
189 
190  return resultant;
191 }
192 
193 /** substraction for two intervals */
194 inline
196  const SCIPInterval& x, /**< first operand */
197  const SCIPInterval& y /**< second operand */
198  )
199 {
200  SCIPInterval resultant;
201 
202  SCIPintervalSub(SCIPInterval::infinity, &resultant, x, y);
203 
204  return resultant;
205 }
206 
207 /** negation of an interval */
208 inline
210  const SCIPInterval& y /**< operand */
211  )
212 {
213  SCIPInterval resultant;
214 
215  SCIPintervalSetBounds(&resultant, -y.sup, -y.inf);
216 
217  return resultant;
218 }
219 
220 /** multiplication of two intervals */
221 inline
223  const SCIPInterval& x, /**< first operand */
224  const SCIPInterval& y /**< second operand */
225  )
226 {
227  SCIPInterval resultant;
228 
229  SCIPintervalMul(SCIPInterval::infinity, &resultant, x, y);
230 
231  return resultant;
232 }
233 
234 /** division for two intervals */
235 inline
237  const SCIPInterval& x, /**< first operand */
238  const SCIPInterval& y /**< second operand */
239  )
240 {
241  SCIPInterval resultant;
242 
243  SCIPintervalDiv(SCIPInterval::infinity, &resultant, x, y);
244 
245  return resultant;
246 }
247 
248 /** cosine of an interval */
249 inline
251  const SCIPInterval& x /**< operand */
252  )
253 {
254  /* @todo implement cosine for intervals */
255  SCIPerrorMessage("Cosine of interval not implemented. Returning trivial interval [-1,1].\n");
256 
257  return SCIPInterval(-1.0, 1.0);
258 }
259 
260 /** exponential of an interval */
261 inline
263  const SCIPInterval& x /**< operand */
264  )
265 {
266  SCIPInterval resultant;
267 
268  SCIPintervalExp(SCIPInterval::infinity, &resultant, x);
269 
270  return resultant;
271 }
272 
273 /** natural logarithm of an interval */
274 inline
276  const SCIPInterval& x /**< operand */
277  )
278 {
279  SCIPInterval resultant;
280 
281  SCIPintervalLog(SCIPInterval::infinity, &resultant, x);
282 
283  return resultant;
284 }
285 
286 /** power of an interval to another interval */
287 inline
289  const SCIPInterval& x, /**< first operand */
290  const SCIPInterval& y /**< second operand */
291  )
292 {
293  SCIPInterval resultant;
294 
295  SCIPintervalPower(SCIPInterval::infinity, &resultant, x, y);
296 
297  return resultant;
298 }
299 
300 /** power of an interval to a scalar */
301 inline
303  const SCIPInterval& x, /**< first operand */
304  const SCIP_Real& y /**< exponent */
305  )
306 {
307  SCIPInterval resultant;
308 
309  SCIPintervalPowerScalar(SCIPInterval::infinity, &resultant, x, y);
310 
311  return resultant;
312 }
313 
314 /** signpower of an interval to a scalar */
315 inline
317  const SCIPInterval& x, /**< first operand */
318  const SCIP_Real p /**< exponent */
319  )
320 {
321  SCIPInterval resultant;
322 
323  SCIPintervalSignPowerScalar(SCIPInterval::infinity, &resultant, x, p);
324 
325  return resultant;
326 }
327 
328 /** sine of an interval */
329 inline
331  const SCIPInterval& x /**< operand */
332  )
333 {
334  /* @todo implement sine for intervals */
335  SCIPerrorMessage("Sine of interval not implemented. Returning trivial interval [-1,1].\n");
336 
337  return SCIPInterval(-1.0, 1.0);
338 }
339 
340 /** square an interval */
341 inline
343  const SCIPInterval& x /**< operand */
344  )
345 {
346  SCIPInterval resultant;
347 
348  SCIPintervalSquare(SCIPInterval::infinity, &resultant, x);
349 
350  return resultant;
351 }
352 
353 /** square root of an interval */
354 inline
356  const SCIPInterval& x /**< operand */
357  )
358 {
359  SCIPInterval resultant;
360 
361  SCIPintervalSquareRoot(SCIPInterval::infinity, &resultant, x);
362 
363  return resultant;
364 }
365 
366 /** absolute value of an interval */
367 inline
369  const SCIPInterval& x /**< operand */
370  )
371 {
372  SCIPInterval resultant;
373 
374  SCIPintervalAbs(SCIPInterval::infinity, &resultant, x);
375 
376  return resultant;
377 }
378 
379 /** sign of an interval */
380 inline
382  const SCIPInterval& x /**< operand */
383  )
384 {
385  SCIPInterval resultant;
386 
387  SCIPintervalSign(SCIPInterval::infinity, &resultant, x);
388 
389  return resultant;
390 }
391 
392 /** macro for easy definition of not implemented interval functions */
393 #define SCIP_INTERVALARITH_UNDEFFUNC(function) \
394 inline \
395 SCIPInterval function( \
396  const SCIPInterval& x /**< operand */ \
397  ) \
398 { \
399  SCIPerrorMessage("Error: " #function " not implemented for intervals.\n"); \
400  return SCIPInterval(); \
401 }
402 
411 #undef SCIP_INTERVALARITH_UNDEFFUNC
412 
413 #ifdef SCIPInterval_NAMESPACE
414 } /* namespace SCIPInterval_NAMESPACE */
415 #endif
416 
417 #endif
SCIPInterval square(const SCIPInterval &x)
SCIPInterval & operator*=(const SCIPInterval &y)
bool operator!=(const SCIP_INTERVAL &y) const
SCIPInterval & operator=(const SCIP_INTERVAL &y)
SCIPInterval pow(const SCIPInterval &x, const SCIPInterval &y)
SCIPInterval cos(const SCIPInterval &x)
void setBounds(SCIP_Real newinf, SCIP_Real newsup)
SCIPInterval operator-(const SCIPInterval &x, const SCIPInterval &y)
static SCIP_Real infinity
SCIPInterval exp(const SCIPInterval &x)
SCIPInterval & operator=(const SCIP_Real &y)
SCIPInterval & operator-=(const SCIPInterval &y)
SCIPInterval abs(const SCIPInterval &x)
SCIPInterval & operator/=(const SCIPInterval &y)
SCIPInterval signpow(const SCIPInterval &x, const SCIP_Real p)
#define SCIPerrorMessage
Definition: pub_message.h:45
SCIPInterval(const SCIP_INTERVAL &x)
SCIPInterval(SCIP_Real infinum, SCIP_Real supremum)
SCIPInterval sqrt(const SCIPInterval &x)
SCIPInterval sign(const SCIPInterval &x)
#define SCIPInterval_NAMESPACE
SCIPInterval operator+(const SCIPInterval &x, const SCIPInterval &y)
SCIPInterval sin(const SCIPInterval &x)
SCIPInterval log(const SCIPInterval &x)
SCIPInterval & operator+=(const SCIPInterval &y)
bool operator==(const SCIP_Real &y) const
#define SCIP_INTERVALARITH_UNDEFFUNC(function)
public methods for message output
#define SCIP_Real
Definition: def.h:127
SCIPInterval operator*(const SCIPInterval &x, const SCIPInterval &y)
bool operator==(const SCIP_INTERVAL &y) const
SCIPInterval operator/(const SCIPInterval &x, const SCIPInterval &y)
SCIPInterval(SCIP_Real number)