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-2020 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 visit scipopt.org. */
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  */
49  static SCIP_Real infinity;
50 
51  /** default constructor -> gives entire interval */
52  SCIPInterval()
53  {
55  }
56 
57  // cppcheck-suppress noExplicitConstructor
58  /** constructor for an SCIP_INTERVAL struct */
59  SCIPInterval(
60  const SCIP_INTERVAL& x /**< interval to copy */
61  )
62  {
63  SCIPintervalSetBounds(this, x.inf, x.sup);
64  }
65 
66  /** constructor for an interval giving pointwise bounds */
67  SCIPInterval(
68  SCIP_Real infinum, /**< lower bound of interval */
69  SCIP_Real supremum /**< upper bound of interval */
70  )
71  {
72  SCIPintervalSetBounds(this, infinum, supremum);
73  }
74 
75  // cppcheck-suppress noExplicitConstructor
76  /** constructor for a singleton */
77  SCIPInterval(
78  SCIP_Real number /**< number to be represented by interval */
79  )
80  {
81  SCIPintervalSet(this, number);
82  }
83 
84  /** sets interval bounds */
85  void setBounds(
86  SCIP_Real newinf, /**< lower bound of interval */
87  SCIP_Real newsup /**< upper bound of interval */
88  )
89  {
90  SCIPintervalSetBounds(this, newinf, newsup);
91  }
92 
93  /** returns whether this interval is equal to another one */
94  bool operator==(
95  const SCIP_INTERVAL& y /**< interval to compare with */
96  ) const
97  {
99  return false;
100  if( this->inf <= -SCIPInterval::infinity && y.inf > -SCIPInterval::infinity )
101  return false;
102  if( this->sup >= SCIPInterval::infinity && y.sup < SCIPInterval::infinity )
103  return false;
104  return (this->inf == y.inf) && (this->sup == y.sup);
105  }
106 
107  /** returns whether this interval is not equal to another one */
108  bool operator!=(
109  const SCIP_INTERVAL& y /**< interval to compare with */
110  ) const
111  {
112  return !operator==(y);
113  }
114 
115  /** returns whether this interval is equal to a given number */
116  bool operator==(
117  const SCIP_Real& y /**< number to compare with */
118  ) const
119  {
120  return ( (inf == y) && (sup == y) ) ||
121  ( sup <= -SCIPInterval::infinity && y <= -SCIPInterval::infinity ) ||
123  }
124 
125  /** adds another interval to this one */
126  SCIPInterval& operator+=(
127  const SCIPInterval& y /**< interval to add in */
128  )
129  {
130  SCIPintervalAdd(SCIPInterval::infinity, this, *this, y);
131  return *this;
132  }
133 
134  /** subtracts an interval from this one */
135  SCIPInterval& operator-=(
136  const SCIPInterval& y /**< interval to substract */
137  )
138  {
139  SCIPintervalSub(SCIPInterval::infinity, this, *this, y);
140  return *this;
141  }
142 
143  /** multiplies an interval with this one */
144  SCIPInterval& operator*=(
145  const SCIPInterval& y /**< interval to multiply with */
146  )
147  {
148  SCIPintervalMul(SCIPInterval::infinity, this, *this, y);
149  return *this;
150  }
151 
152  /** divides this interval by another one */
153  SCIPInterval& operator/=(
154  const SCIPInterval& y /**< interval to divide by */
155  )
156  {
157  SCIPintervalDiv(SCIPInterval::infinity, this, *this, y);
158  return *this;
159  }
160 
161  /** assigns a number to this interval */
162  SCIPInterval& operator=(
163  const SCIP_Real& y /**< new value for both interval bounds */
164  )
165  {
166  SCIPintervalSet(this, y);
167  return *this;
168  }
169 
170  /** assign an interval to this interval */
171  SCIPInterval& operator=(
172  const SCIP_INTERVAL& y /**< new value for this interval */
173  )
174  {
175  SCIPintervalSetBounds(this, y.inf, y.sup);
176  return *this;
177  }
178 
179 };
180 
181 /** addition of two intervals */
182 inline
183 SCIPInterval operator+(
184  const SCIPInterval& x, /**< first operand */
185  const SCIPInterval& y /**< second operand */
186  )
187 {
188  SCIPInterval resultant;
189 
190  SCIPintervalAdd(SCIPInterval::infinity, &resultant, x, y);
191 
192  return resultant;
193 }
194 
195 /** substraction for two intervals */
196 inline
197 SCIPInterval operator-(
198  const SCIPInterval& x, /**< first operand */
199  const SCIPInterval& y /**< second operand */
200  )
201 {
202  SCIPInterval resultant;
203 
204  SCIPintervalSub(SCIPInterval::infinity, &resultant, x, y);
205 
206  return resultant;
207 }
208 
209 /** negation of an interval */
210 inline
211 SCIPInterval operator-(
212  const SCIPInterval& y /**< operand */
213  )
214 {
215  SCIPInterval resultant;
216 
217  SCIPintervalSetBounds(&resultant, -y.sup, -y.inf);
218 
219  return resultant;
220 }
221 
222 /** multiplication of two intervals */
223 inline
224 SCIPInterval operator*(
225  const SCIPInterval& x, /**< first operand */
226  const SCIPInterval& y /**< second operand */
227  )
228 {
229  SCIPInterval resultant;
230 
231  SCIPintervalMul(SCIPInterval::infinity, &resultant, x, y);
232 
233  return resultant;
234 }
235 
236 /** division for two intervals */
237 inline
238 SCIPInterval operator/(
239  const SCIPInterval& x, /**< first operand */
240  const SCIPInterval& y /**< second operand */
241  )
242 {
243  SCIPInterval resultant;
244 
245  SCIPintervalDiv(SCIPInterval::infinity, &resultant, x, y);
246 
247  return resultant;
248 }
249 
250 /** cosine of an interval */
251 inline
252 SCIPInterval cos(
253  const SCIPInterval& x /**< operand */
254  )
255 {
256  SCIPInterval resultant;
257 
258  SCIPintervalCos(SCIPInterval::infinity, &resultant, x);
259 
260  return resultant;
261 }
262 
263 /** exponential of an interval */
264 inline
265 SCIPInterval exp(
266  const SCIPInterval& x /**< operand */
267  )
268 {
269  SCIPInterval resultant;
270 
271  SCIPintervalExp(SCIPInterval::infinity, &resultant, x);
272 
273  return resultant;
274 }
275 
276 /** natural logarithm of an interval */
277 inline
278 SCIPInterval log(
279  const SCIPInterval& x /**< operand */
280  )
281 {
282  SCIPInterval resultant;
283 
284  SCIPintervalLog(SCIPInterval::infinity, &resultant, x);
285 
286  return resultant;
287 }
288 
289 /** power of an interval to another interval */
290 inline
291 SCIPInterval pow(
292  const SCIPInterval& x, /**< first operand */
293  const SCIPInterval& y /**< second operand */
294  )
295 {
296  SCIPInterval resultant;
297 
298  SCIPintervalPower(SCIPInterval::infinity, &resultant, x, y);
299 
300  return resultant;
301 }
302 
303 /** power of an interval to a scalar */
304 inline
305 SCIPInterval pow(
306  const SCIPInterval& x, /**< first operand */
307  const SCIP_Real& y /**< exponent */
308  )
309 {
310  SCIPInterval resultant;
311 
313 
314  return resultant;
315 }
316 
317 /** signpower of an interval to a scalar */
318 inline
319 SCIPInterval signpow(
320  const SCIPInterval& x, /**< first operand */
321  const SCIP_Real p /**< exponent */
322  )
323 {
324  SCIPInterval resultant;
325 
327 
328  return resultant;
329 }
330 
331 /** sine of an interval */
332 inline
333 SCIPInterval sin(
334  const SCIPInterval& x /**< operand */
335  )
336 {
337  SCIPInterval resultant;
338 
339  SCIPintervalSin(SCIPInterval::infinity, &resultant, x);
340 
341  return resultant;
342 }
343 
344 /** square an interval */
345 inline
346 SCIPInterval square(
347  const SCIPInterval& x /**< operand */
348  )
349 {
350  SCIPInterval resultant;
351 
353 
354  return resultant;
355 }
356 
357 /** square root of an interval */
358 inline
359 SCIPInterval sqrt(
360  const SCIPInterval& x /**< operand */
361  )
362 {
363  SCIPInterval resultant;
364 
366 
367  return resultant;
368 }
369 
370 /** absolute value of an interval */
371 inline
372 SCIPInterval abs(
373  const SCIPInterval& x /**< operand */
374  )
375 {
376  SCIPInterval resultant;
377 
378  SCIPintervalAbs(SCIPInterval::infinity, &resultant, x);
379 
380  return resultant;
381 }
382 
383 /** absolute value of an interval */
384 inline
385 SCIPInterval fabs(
386  const SCIPInterval& x /**< operand */
387  )
388 {
389  SCIPInterval resultant;
390 
391  SCIPintervalAbs(SCIPInterval::infinity, &resultant, x);
392 
393  return resultant;
394 }
395 
396 /** sign of an interval */
397 inline
398 SCIPInterval sign(
399  const SCIPInterval& x /**< operand */
400  )
401 {
402  SCIPInterval resultant;
403 
405 
406  return resultant;
407 }
408 
409 /** macro for easy definition of not implemented interval functions */
410 #define SCIP_INTERVALARITH_UNDEFFUNC(function) \
411 inline \
412 SCIPInterval function( \
413  const SCIPInterval& x /**< operand */ \
414  ) \
415 { \
416  SCIPerrorMessage("Error: " #function " not implemented for intervals.\n"); \
417  return SCIPInterval(); \
418 }
419 
433 #undef SCIP_INTERVALARITH_UNDEFFUNC
434 
435 #ifdef SCIPInterval_NAMESPACE
436 } /* namespace SCIPInterval_NAMESPACE */
437 #endif
438 
439 #endif
void SCIPintervalSignPowerScalar(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL operand1, SCIP_Real operand2)
SCIPInterval square(const SCIPInterval &x)
SCIP_Bool SCIPintervalIsEmpty(SCIP_Real infinity, SCIP_INTERVAL operand)
void SCIPintervalSign(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL operand)
#define infinity
Definition: gastrans.c:71
SCIPInterval pow(const SCIPInterval &x, const SCIPInterval &y)
SCIPInterval cos(const SCIPInterval &x)
void SCIPintervalMul(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL operand1, SCIP_INTERVAL operand2)
SCIPInterval operator-(const SCIPInterval &x, const SCIPInterval &y)
SCIPInterval exp(const SCIPInterval &x)
void SCIPintervalSetBounds(SCIP_INTERVAL *resultant, SCIP_Real inf, SCIP_Real sup)
void SCIPintervalPowerScalar(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL operand1, SCIP_Real operand2)
SCIP_VAR ** x
Definition: circlepacking.c:54
void SCIPintervalDiv(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL operand1, SCIP_INTERVAL operand2)
SCIPInterval abs(const SCIPInterval &x)
void SCIPintervalSin(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL operand)
SCIPInterval signpow(const SCIPInterval &x, const SCIP_Real p)
SCIP_Real inf
Definition: intervalarith.h:39
#define SCIP_INTERVALARITH_UNDEFFUNC(function)
interval arithmetics for provable bounds
void SCIPintervalLog(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL operand)
SCIPInterval sqrt(const SCIPInterval &x)
SCIPInterval sign(const SCIPInterval &x)
SCIPInterval fabs(const SCIPInterval &x)
#define SCIPInterval_NAMESPACE
SCIPInterval operator+(const SCIPInterval &x, const SCIPInterval &y)
SCIP_Real sup
Definition: intervalarith.h:40
void SCIPintervalSet(SCIP_INTERVAL *resultant, SCIP_Real value)
void SCIPintervalCos(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL operand)
SCIPInterval sin(const SCIPInterval &x)
void SCIPintervalSquareRoot(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL operand)
void SCIPintervalSquare(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL operand)
void SCIPintervalAdd(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL operand1, SCIP_INTERVAL operand2)
SCIPInterval log(const SCIPInterval &x)
static long * number
void SCIPintervalAbs(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL operand)
void SCIPintervalExp(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL operand)
public methods for message output
#define SCIP_Real
Definition: def.h:163
SCIPInterval operator*(const SCIPInterval &x, const SCIPInterval &y)
SCIP_VAR ** y
Definition: circlepacking.c:55
void SCIPintervalSub(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL operand1, SCIP_INTERVAL operand2)
SCIPInterval operator/(const SCIPInterval &x, const SCIPInterval &y)
void SCIPintervalPower(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL operand1, SCIP_INTERVAL operand2)