Generated on Sat Feb 7 2015 02:01:15 for Gecode by doxygen 1.8.9.1
val.hpp
Go to the documentation of this file.
1 /* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
2 /*
3  * Main authors:
4  * Vincent Barichard <Vincent.Barichard@univ-angers.fr>
5  *
6  * Contributing authors:
7  * Christian Schulte <schulte@gecode.org>
8  *
9  * Copyright:
10  * Christian Schulte, 2012
11  * Vincent Barichard, 2012
12  *
13  * Last modified:
14  * $Date: 2014-10-03 15:34:37 +0200 (Fri, 03 Oct 2014) $ by $Author: schulte $
15  * $Revision: 14241 $
16  *
17  * This file is part of Gecode, the generic constraint
18  * development environment:
19  * http://www.gecode.org
20  *
21  * Permission is hereby granted, free of charge, to any person obtaining
22  * a copy of this software and associated documentation files (the
23  * "Software"), to deal in the Software without restriction, including
24  * without limitation the rights to use, copy, modify, merge, publish,
25  * distribute, sublicense, and/or sell copies of the Software, and to
26  * permit persons to whom the Software is furnished to do so, subject to
27  * the following conditions:
28  *
29  * The above copyright notice and this permission notice shall be
30  * included in all copies or substantial portions of the Software.
31  *
32  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
33  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
34  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
35  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
36  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
37  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
38  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
39  *
40  */
41 
42 namespace Gecode {
43 
44  /*
45  * Floating point value: member functions
46  *
47  */
51  FloatVal::FloatVal(const FloatNum& n) : x(n) {}
53  FloatVal::FloatVal(const FloatNum& l, const FloatNum& u) : x(l,u) {}
57  FloatVal::FloatVal(const FloatVal& v) : x(v.x) {}
58 
61  x = n; return *this;
62  }
65  x = v.x; return *this;
66  }
67 
68  forceinline void
69  FloatVal::assign(FloatNum const &l, FloatNum const &u) {
70  x.assign(l,u);
71  }
72 
74  FloatVal::min(void) const {
75  return x.lower();
76  }
78  FloatVal::max(void) const {
79  return x.upper();
80  }
82  FloatVal::size(void) const {
83  return gecode_boost::numeric::width(x);
84  }
86  FloatVal::med(void) const {
87  return gecode_boost::numeric::median(x);
88  }
89 
90  forceinline bool
91  FloatVal::tight(void) const {
93  (nextafter(x.lower(),x.upper()) == x.upper()));
94  }
95  forceinline bool
96  FloatVal::singleton(void) const {
98  }
99  forceinline bool
101  return gecode_boost::numeric::in(n,x);
102  }
103  forceinline bool
104  FloatVal::zero_in(void) const {
105  return gecode_boost::numeric::zero_in(x);
106  }
107 
110  FloatVal h(FloatVal::hull(x,y)); return h;
111  }
114  FloatVal p(gecode_boost::numeric::interval_lib::pi_half<FloatValImpType>());
115  return p;
116  }
118  FloatVal::pi(void) {
119  FloatVal p(gecode_boost::numeric::interval_lib::pi<FloatValImpType>());
120  return p;
121  }
124  FloatVal p(gecode_boost::numeric::interval_lib::pi_twice<FloatValImpType>());
125  return p;
126  }
127 
130  x += n; return *this;
131  }
134  x -= n; return *this;
135  }
138  x *= n; return *this;
139  }
142  x /= n; return *this;
143  }
144 
147  x += v.x; return *this;
148  }
151  x -= v.x; return *this;
152  }
155  x *= v.x; return *this;
156  }
159  x /= v.x; return *this;
160  }
161 
162  /*
163  * Operators and functions on float values
164  *
165  */
166 
169  return FloatVal(+x.x);
170  }
171  forceinline FloatVal
173  FloatNum mmi = (x.min() == 0.0) ? 0.0 : -x.min();
174  FloatNum mma = (x.max() == 0.0) ? 0.0 :-x.max();
175  return FloatVal(mma,mmi);
176  }
177  forceinline FloatVal
178  operator +(const FloatVal& x, const FloatVal& y) {
179  return FloatVal(x.x+y.x);
180  }
181  forceinline FloatVal
182  operator +(const FloatVal& x, const FloatNum& y) {
183  return FloatVal(x.x+y);
184  }
185  forceinline FloatVal
186  operator +(const FloatNum& x, const FloatVal& y) {
187  return FloatVal(x+y.x);
188  }
189 
190  forceinline FloatVal
191  operator -(const FloatVal& x, const FloatVal& y) {
192  return FloatVal(x.x-y.x);
193  }
194  forceinline FloatVal
195  operator -(const FloatVal& x, const FloatNum& y) {
196  return FloatVal(x.x-y);
197  }
198  forceinline FloatVal
199  operator -(const FloatNum& x, const FloatVal& y) {
200  return FloatVal(x-y.x);
201  }
202 
203  forceinline FloatVal
204  operator *(const FloatVal& x, const FloatVal& y) {
205  return FloatVal(x.x*y.x);
206  }
207  forceinline FloatVal
208  operator *(const FloatVal& x, const FloatNum& y) {
209  return FloatVal(x.x*y);
210  }
211  forceinline FloatVal
212  operator *(const FloatNum& x, const FloatVal& y) {
213  return FloatVal(x*y.x);
214  }
215 
216  forceinline FloatVal
217  operator /(const FloatVal& x, const FloatVal& y) {
218  return FloatVal(x.x/y.x);
219  }
220  forceinline FloatVal
221  operator /(const FloatVal& x, const FloatNum& y) {
222  return FloatVal(x.x/y);
223  }
224  forceinline FloatVal
225  operator /(const FloatNum& x, const FloatVal& y) {
226  return FloatVal(x/y.x);
227  }
228 
229  forceinline bool
230  operator <(const FloatVal& x, const FloatVal& y) {
231  try {
232  return x.x < y.x;
233  } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
234  return false;
235  }
236  }
237  forceinline bool
238  operator <(const FloatVal& x, const FloatNum& y) {
239  try {
240  return x.x < y;
241  } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
242  return false;
243  }
244  }
245 
246  forceinline bool
247  operator <=(const FloatVal& x, const FloatVal& y) {
248  try {
249  return x.x <= y.x;
250  } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
251  return false;
252  }
253  }
254  forceinline bool
255  operator <=(const FloatVal& x, const FloatNum& y) {
256  try {
257  return x.x <= y;
258  } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
259  return false;
260  }
261  }
262 
263  forceinline bool
264  operator >(const FloatVal& x, const FloatVal& y) {
265  try {
266  return x.x > y.x;
267  } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
268  return false;
269  }
270  }
271  forceinline bool
272  operator >(const FloatVal& x, const FloatNum& y) {
273  try {
274  return x.x > y;
275  } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
276  return false;
277  }
278  }
279 
280  forceinline bool
281  operator >=(const FloatVal& x, const FloatVal& y) {
282  try {
283  return x.x >= y.x;
284  } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
285  return false;
286  }
287  }
288  forceinline bool
289  operator >=(const FloatVal& x, const FloatNum& y) {
290  try {
291  return x.x >= y;
292  } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
293  return false;
294  }
295  }
296 
297  forceinline bool
298  operator ==(const FloatVal& x, const FloatVal& y) {
299  try {
300  return x.x == y.x;
301  } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
302  return false;
303  }
304  }
305  forceinline bool
306  operator ==(const FloatVal& x, const FloatNum& y) {
307  if (!gecode_boost::numeric::interval_lib::checking_strict<FloatNum>
308  ::is_empty(x.x.lower(), x.x.upper())) {
309  if ((x.x.lower() == y) && (x.x.upper() == y))
310  return true;
311  }
312  if (((x.x.lower() == y) &&
313  (nextafter(x.x.lower(),x.x.upper()) == x.x.upper())) ||
314  ((x.x.upper() == y) &&
315  (nextafter(x.x.upper(),x.x.lower()) == x.x.lower())))
316  return true;
317  return false;
318  }
319 
320  forceinline bool
321  operator !=(const FloatVal& x, const FloatVal& y) {
322  try {
323  return x.x != y.x;
324  } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
325  return false;
326  }
327  }
328  forceinline bool
329  operator !=(const FloatVal& x, const FloatNum& y) {
330  try {
331  return x.x != y;
332  } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
333  return false;
334  }
335  }
336 
337  forceinline bool
338  operator <(const FloatNum& x, const FloatVal& y) {
339  return y > x;
340  }
341  forceinline bool
342  operator <=(const FloatNum& x, const FloatVal& y) {
343  return y >= x;
344  }
345  forceinline bool
346  operator >(const FloatNum& x, const FloatVal& y) {
347  return y < x;
348  }
349  forceinline bool
350  operator >=(const FloatNum& x, const FloatVal& y) {
351  return y <= x;
352  }
353  forceinline bool
354  operator ==(const FloatNum& x, const FloatVal& y) {
355  return y == x;
356  }
357  forceinline bool
358  operator !=(const FloatNum& x, const FloatVal& y) {
359  return y != x;
360  }
361 
362  template<class Char, class Traits>
363  std::basic_ostream<Char,Traits>&
364  operator <<(std::basic_ostream<Char,Traits>& os, const FloatVal& x) {
365  return os << x.x;
366  }
367 
368  forceinline FloatVal
369  abs(const FloatVal& x) {
370  return FloatVal(abs(x.x));
371  }
372  forceinline FloatVal
373  sqrt(const FloatVal& x) {
374  return FloatVal(sqrt(x.x));
375  }
376  forceinline FloatVal
377  sqr(const FloatVal& x) {
378  return FloatVal(square(x.x));
379  }
380  forceinline FloatVal
381  pow(const FloatVal& x, int n) {
382  return FloatVal(pow(x.x,n));
383  }
384  forceinline FloatVal
385  nroot(const FloatVal& x, int n) {
386  return FloatVal(nth_root(x.x,n));
387  }
388 
389  forceinline FloatVal
390  max(const FloatVal& x, const FloatVal& y) {
391  return FloatVal(max(x.x,y.x));
392  }
393  forceinline FloatVal
394  max(const FloatVal& x, const FloatNum& y) {
395  return FloatVal(max(x.x,y));
396  }
397  forceinline FloatVal
398  max(const FloatNum& x, const FloatVal& y) {
399  return FloatVal(max(x,y.x));
400  }
401  forceinline FloatVal
402  min(const FloatVal& x, const FloatVal& y) {
403  return FloatVal(min(x.x,y.x));
404  }
405  forceinline FloatVal
406  min(const FloatVal& x, const FloatNum& y) {
407  return FloatVal(min(x.x,y));
408  }
409  forceinline FloatVal
410  min(const FloatNum& x, const FloatVal& y) {
411  return FloatVal(min(x,y.x));
412  }
413 
414 #ifdef GECODE_HAS_MPFR
415 
416  forceinline FloatVal
417  exp(const FloatVal& x) {
418  return FloatVal(exp(x.x));
419  }
420  forceinline FloatVal
421  log(const FloatVal& x) {
422  return FloatVal(log(x.x));
423  }
424 
425  forceinline FloatVal
426  fmod(const FloatVal& x, const FloatVal& y) {
427  return FloatVal(fmod(x.x,y.x));
428  }
429  forceinline FloatVal
430  fmod(const FloatVal& x, const FloatNum& y) {
431  return FloatVal(fmod(x.x,y));
432  }
433  forceinline FloatVal
434  fmod(const FloatNum& x, const FloatVal& y) {
435  return FloatVal(fmod(x,y.x));
436  }
437 
438  forceinline FloatVal
439  sin(const FloatVal& x) {
440  return FloatVal(sin(x.x));
441  }
442  forceinline FloatVal
443  cos(const FloatVal& x) {
444  return FloatVal(cos(x.x));
445  }
446  forceinline FloatVal
447  tan(const FloatVal& x) {
448  return FloatVal(tan(x.x));
449  }
450  forceinline FloatVal
451  asin(const FloatVal& x) {
452  return FloatVal(asin(x.x));
453  }
454  forceinline FloatVal
455  acos(const FloatVal& x) {
456  return FloatVal(acos(x.x));
457  }
458  forceinline FloatVal
459  atan(const FloatVal& x) {
460  return FloatVal(atan(x.x));
461  }
462 
463  forceinline FloatVal
464  sinh(const FloatVal& x) {
465  return FloatVal(sinh(x.x));
466  }
467  forceinline FloatVal
468  cosh(const FloatVal& x) {
469  return FloatVal(cosh(x.x));
470  }
471  forceinline FloatVal
472  tanh(const FloatVal& x) {
473  return FloatVal(tanh(x.x));
474  }
475  forceinline FloatVal
476  asinh(const FloatVal& x) {
477  return FloatVal(asinh(x.x));
478  }
479  forceinline FloatVal
480  acosh(const FloatVal& x) {
481  return FloatVal(acosh(x.x));
482  }
483  forceinline FloatVal
484  atanh(const FloatVal& x) {
485  return FloatVal(atanh(x.x));
486  }
487 
488 #endif
489 }
490 
491 namespace Gecode { namespace Float {
492 
493  forceinline bool
494  subset(const FloatVal& x, const FloatVal& y) {
495  return subset(x.x,y.x);
496  }
497  forceinline bool
498  proper_subset(const FloatVal& x, const FloatVal& y) {
499  return proper_subset(x.x,y.x);
500  }
501  forceinline bool
502  overlap(const FloatVal& x, const FloatVal& y) {
503  return overlap(x.x,y.x);
504  }
505 
507  intersect(const FloatVal& x, const FloatVal& y) {
508  return FloatVal(intersect(x.x,y.x));
509  }
511  hull(const FloatVal& x, const FloatVal& y) {
512  return FloatVal(hull(x.x,y.x));
513  }
515  hull(const FloatVal& x, const FloatNum& y) {
516  return FloatVal(hull(x.x,y));
517  }
519  hull(const FloatNum& x, const FloatVal& y) {
520  return FloatVal(hull(x,y.x));
521  }
523  hull(const FloatNum& x, const FloatNum& y) {
524  return FloatVal(hull(x,y));
525  }
526 
527 }}
528 
529 // STATISTICS: float-var
530 
FloatVal operator-(const FloatVal &x)
Definition: val.hpp:172
SetExpr singleton(const LinIntExpr &e)
Singleton expression.
Definition: set-expr.cpp:691
NNF * l
Left subtree.
Definition: bool-expr.cpp:244
bool subset(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:494
void log(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition: arithmetic.cpp:151
FloatVal operator/(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:217
FloatVal fmod(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:426
FloatVal & operator/=(const FloatNum &n)
Divide by n.
Definition: val.hpp:141
void max(Home home, FloatVar x0, FloatVar x1, FloatVar x2)
Post propagator for .
Definition: arithmetic.cpp:57
void abs(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition: arithmetic.cpp:49
void nroot(Home home, FloatVar x0, int n, FloatVar x1)
Post propagator for for $n 0$.
Definition: arithmetic.cpp:126
bool overlap(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:502
void pow(Home home, FloatVar x0, int n, FloatVar x1)
Post propagator for for $n 0$.
Definition: arithmetic.cpp:117
FloatVal hull(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:511
FloatVal & operator-=(const FloatNum &n)
Subtract by n.
Definition: val.hpp:133
static FloatVal pi_twice(void)
Return .
Definition: val.hpp:123
gecode_boost::numeric::interval< FloatNum, gecode_boost::numeric::interval_lib::policies< R, P > > FloatValImpType
Implementation type for float value.
Definition: float.hh:410
FloatVal(void)
Default constructor.
Definition: val.hpp:49
static FloatVal hull(FloatNum x, FloatNum y)
Return hull of x and y.
Definition: val.hpp:109
FloatValImpType x
Implementation of float value.
Definition: float.hh:412
bool tight(void) const
Test whether float is tight.
Definition: val.hpp:91
bool singleton(void) const
Test whether float is a singleton.
Definition: val.hpp:96
int p
Number of positive literals for node type.
Definition: bool-expr.cpp:236
bool proper_subset(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:498
Gecode::IntArgs i(4, 1, 2, 3, 4)
FloatNum med(void) const
Return median of float value.
Definition: val.hpp:86
int n
Number of negative literals for node type.
Definition: bool-expr.cpp:238
FloatVal & operator*=(const FloatNum &n)
Multiply by n.
Definition: val.hpp:137
FloatVal sinh(const FloatVal &x)
Definition: val.hpp:464
FloatNum min(void) const
Return lower bound.
Definition: val.hpp:74
FloatVal intersect(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:507
FloatVal operator+(const FloatVal &x)
Definition: val.hpp:168
void sqr(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition: arithmetic.cpp:103
bool operator!=(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:321
void sqrt(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition: arithmetic.cpp:110
FloatVal cosh(const FloatVal &x)
Definition: val.hpp:468
static FloatVal pi(void)
Return lower bound of .
Definition: val.hpp:118
FloatVal & operator=(const FloatNum &n)
Assignment operator.
Definition: val.hpp:60
void asin(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition: arithmetic.cpp:175
FloatVal & operator+=(const FloatNum &n)
Increment by n.
Definition: val.hpp:129
union Gecode::@518::NNF::@57 u
Union depending on nodetype t.
const int v[7]
Definition: distinct.cpp:207
void min(Home home, FloatVar x0, FloatVar x1, FloatVar x2)
Post propagator for .
Definition: arithmetic.cpp:75
void cos(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition: arithmetic.cpp:196
Float value type.
Definition: float.hh:321
FloatVal operator*(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:204
Node * x
Pointer to corresponding Boolean expression node.
Definition: bool-expr.cpp:253
void tan(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition: arithmetic.cpp:210
bool in(FloatNum n) const
Test whether n is included.
Definition: val.hpp:100
static FloatVal pi_half(void)
Return .
Definition: val.hpp:113
bool operator>=(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:281
FloatVal acosh(const FloatVal &x)
Definition: val.hpp:480
#define forceinline
Definition: config.hpp:132
bool zero_in(void) const
Test whether zero is included.
Definition: val.hpp:104
FloatVal atanh(const FloatVal &x)
Definition: val.hpp:484
FloatVal asinh(const FloatVal &x)
Definition: val.hpp:476
void assign(FloatNum const &l, FloatNum const &u)
Assign lower bound l and upper bound u.
Definition: val.hpp:69
bool operator>(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:264
bool operator<(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:230
bool operator==(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:298
bool operator<=(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:247
FloatNum size(void) const
Return size of float value (distance between maximum and minimum)
Definition: val.hpp:82
Gecode toplevel namespace
void sin(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition: arithmetic.cpp:182
void acos(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition: arithmetic.cpp:189
void exp(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition: arithmetic.cpp:144
friend FloatVal max(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:390
friend FloatVal min(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:402
FloatVal tanh(const FloatVal &x)
Definition: val.hpp:472
FloatNum max(void) const
Return upper bound.
Definition: val.hpp:78
double FloatNum
Floating point number base type.
Definition: float.hh:108
void atan(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition: arithmetic.cpp:203