this repo has no description
dekker.one
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 * This file is part of Gecode, the generic constraint
14 * development environment:
15 * http://www.gecode.org
16 *
17 * Permission is hereby granted, free of charge, to any person obtaining
18 * a copy of this software and associated documentation files (the
19 * "Software"), to deal in the Software without restriction, including
20 * without limitation the rights to use, copy, modify, merge, publish,
21 * distribute, sublicense, and/or sell copies of the Software, and to
22 * permit persons to whom the Software is furnished to do so, subject to
23 * the following conditions:
24 *
25 * The above copyright notice and this permission notice shall be
26 * included in all copies or substantial portions of the Software.
27 *
28 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
29 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
30 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
31 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
32 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
33 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
34 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
35 *
36 */
37
38namespace Gecode {
39
40 /*
41 * Floating point value: member functions
42 *
43 */
44 forceinline
45 FloatVal::FloatVal(void) {}
46 forceinline
47 FloatVal::FloatVal(const FloatNum& n) : x(n) {}
48 forceinline
49 FloatVal::FloatVal(const FloatNum& l, const FloatNum& u) : x(l,u) {}
50 forceinline
51 FloatVal::FloatVal(const FloatValImpType& i) : x(i) {}
52 forceinline
53 FloatVal::FloatVal(const FloatVal& v) : x(v.x) {}
54
55 forceinline FloatVal&
56 FloatVal::operator =(const FloatNum& n) {
57 x = n; return *this;
58 }
59 forceinline FloatVal&
60 FloatVal::operator =(const FloatVal& v) {
61 x = v.x; return *this;
62 }
63
64 forceinline void
65 FloatVal::assign(FloatNum const &l, FloatNum const &u) {
66 x.assign(l,u);
67 }
68
69 forceinline FloatNum
70 FloatVal::min(void) const {
71 return x.lower();
72 }
73 forceinline FloatNum
74 FloatVal::max(void) const {
75 return x.upper();
76 }
77 forceinline FloatNum
78 FloatVal::size(void) const {
79 return gecode_boost::numeric::width(x);
80 }
81 forceinline FloatNum
82 FloatVal::med(void) const {
83 return gecode_boost::numeric::median(x);
84 }
85
86 forceinline bool
87 FloatVal::tight(void) const {
88 return (gecode_boost::numeric::singleton(x) ||
89 (nextafter(x.lower(),x.upper()) == x.upper()));
90 }
91 forceinline bool
92 FloatVal::singleton(void) const {
93 return gecode_boost::numeric::singleton(x);
94 }
95 forceinline bool
96 FloatVal::in(FloatNum n) const {
97 return gecode_boost::numeric::in(n,x);
98 }
99 forceinline bool
100 FloatVal::zero_in(void) const {
101 return gecode_boost::numeric::zero_in(x);
102 }
103
104 forceinline FloatVal
105 FloatVal::hull(FloatNum x, FloatNum y) {
106 FloatVal h(x,y); return h;
107 }
108 forceinline FloatVal
109 FloatVal::pi_half(void) {
110 FloatVal p(gecode_boost::numeric::interval_lib::pi_half<FloatValImpType>());
111 return p;
112 }
113 forceinline FloatVal
114 FloatVal::pi(void) {
115 FloatVal p(gecode_boost::numeric::interval_lib::pi<FloatValImpType>());
116 return p;
117 }
118 forceinline FloatVal
119 FloatVal::pi_twice(void) {
120 FloatVal p(gecode_boost::numeric::interval_lib::pi_twice<FloatValImpType>());
121 return p;
122 }
123
124 forceinline FloatVal&
125 FloatVal::operator +=(const FloatNum& n) {
126 x += n; return *this;
127 }
128 forceinline FloatVal&
129 FloatVal::operator -=(const FloatNum& n) {
130 x -= n; return *this;
131 }
132 forceinline FloatVal&
133 FloatVal::operator *=(const FloatNum& n) {
134 x *= n; return *this;
135 }
136 forceinline FloatVal&
137 FloatVal::operator /=(const FloatNum& n) {
138 x /= n; return *this;
139 }
140
141 forceinline FloatVal&
142 FloatVal::operator +=(const FloatVal& v) {
143 x += v.x; return *this;
144 }
145 forceinline FloatVal&
146 FloatVal::operator -=(const FloatVal& v) {
147 x -= v.x; return *this;
148 }
149 forceinline FloatVal&
150 FloatVal::operator *=(const FloatVal& v) {
151 x *= v.x; return *this;
152 }
153 forceinline FloatVal&
154 FloatVal::operator /=(const FloatVal& v) {
155 x /= v.x; return *this;
156 }
157
158 /*
159 * Operators and functions on float values
160 *
161 */
162
163 forceinline FloatVal
164 operator +(const FloatVal& x) {
165 return FloatVal(+x.x);
166 }
167 forceinline FloatVal
168 operator -(const FloatVal& x) {
169 FloatNum mmi = (x.min() == 0.0) ? 0.0 : -x.min();
170 FloatNum mma = (x.max() == 0.0) ? 0.0 :-x.max();
171 return FloatVal(mma,mmi);
172 }
173 forceinline FloatVal
174 operator +(const FloatVal& x, const FloatVal& y) {
175 return FloatVal(x.x+y.x);
176 }
177 forceinline FloatVal
178 operator +(const FloatVal& x, const FloatNum& y) {
179 return FloatVal(x.x+y);
180 }
181 forceinline FloatVal
182 operator +(const FloatNum& x, const FloatVal& y) {
183 return FloatVal(x+y.x);
184 }
185
186 forceinline FloatVal
187 operator -(const FloatVal& x, const FloatVal& y) {
188 return FloatVal(x.x-y.x);
189 }
190 forceinline FloatVal
191 operator -(const FloatVal& x, const FloatNum& y) {
192 return FloatVal(x.x-y);
193 }
194 forceinline FloatVal
195 operator -(const FloatNum& x, const FloatVal& y) {
196 return FloatVal(x-y.x);
197 }
198
199 forceinline FloatVal
200 operator *(const FloatVal& x, const FloatVal& y) {
201 return FloatVal(x.x*y.x);
202 }
203 forceinline FloatVal
204 operator *(const FloatVal& x, const FloatNum& y) {
205 return FloatVal(x.x*y);
206 }
207 forceinline FloatVal
208 operator *(const FloatNum& x, const FloatVal& y) {
209 return FloatVal(x*y.x);
210 }
211
212 forceinline FloatVal
213 operator /(const FloatVal& x, const FloatVal& y) {
214 return FloatVal(x.x/y.x);
215 }
216 forceinline FloatVal
217 operator /(const FloatVal& x, const FloatNum& y) {
218 return FloatVal(x.x/y);
219 }
220 forceinline FloatVal
221 operator /(const FloatNum& x, const FloatVal& y) {
222 return FloatVal(x/y.x);
223 }
224
225 inline bool
226 operator <(const FloatVal& x, const FloatVal& y) {
227 try {
228 return x.x < y.x;
229 } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
230 return false;
231 }
232 }
233 inline bool
234 operator <(const FloatVal& x, const FloatNum& y) {
235 try {
236 return x.x < y;
237 } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
238 return false;
239 }
240 }
241
242 inline bool
243 operator <=(const FloatVal& x, const FloatVal& y) {
244 try {
245 return x.x <= y.x;
246 } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
247 return false;
248 }
249 }
250 inline bool
251 operator <=(const FloatVal& x, const FloatNum& y) {
252 try {
253 return x.x <= y;
254 } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
255 return false;
256 }
257 }
258
259 inline bool
260 operator >(const FloatVal& x, const FloatVal& y) {
261 try {
262 return x.x > y.x;
263 } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
264 return false;
265 }
266 }
267 inline bool
268 operator >(const FloatVal& x, const FloatNum& y) {
269 try {
270 return x.x > y;
271 } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
272 return false;
273 }
274 }
275
276 inline bool
277 operator >=(const FloatVal& x, const FloatVal& y) {
278 try {
279 return x.x >= y.x;
280 } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
281 return false;
282 }
283 }
284 inline bool
285 operator >=(const FloatVal& x, const FloatNum& y) {
286 try {
287 return x.x >= y;
288 } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
289 return false;
290 }
291 }
292
293 inline bool
294 operator ==(const FloatVal& x, const FloatVal& y) {
295 try {
296 return x.x == y.x;
297 } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
298 return false;
299 }
300 }
301 inline bool
302 operator ==(const FloatVal& x, const FloatNum& y) {
303 if (!gecode_boost::numeric::interval_lib::checking_strict<FloatNum>
304 ::is_empty(x.x.lower(), x.x.upper())) {
305 if ((x.x.lower() == y) && (x.x.upper() == y))
306 return true;
307 }
308 if (((x.x.lower() == y) &&
309 (nextafter(x.x.lower(),x.x.upper()) == x.x.upper())) ||
310 ((x.x.upper() == y) &&
311 (nextafter(x.x.upper(),x.x.lower()) == x.x.lower())))
312 return true;
313 return false;
314 }
315
316 inline bool
317 operator !=(const FloatVal& x, const FloatVal& y) {
318 try {
319 return x.x != y.x;
320 } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
321 return false;
322 }
323 }
324 inline bool
325 operator !=(const FloatVal& x, const FloatNum& y) {
326 try {
327 return x.x != y;
328 } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
329 return false;
330 }
331 }
332
333 forceinline bool
334 operator <(const FloatNum& x, const FloatVal& y) {
335 return y > x;
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
358 template<class Char, class Traits>
359 std::basic_ostream<Char,Traits>&
360 operator <<(std::basic_ostream<Char,Traits>& os, const FloatVal& x) {
361 return os << '[' << x.min() << ".." << x.max() << ']';
362 }
363
364 forceinline FloatVal
365 abs(const FloatVal& x) {
366 return FloatVal(abs(x.x));
367 }
368 forceinline FloatVal
369 sqrt(const FloatVal& x) {
370 return FloatVal(sqrt(x.x));
371 }
372 forceinline FloatVal
373 sqr(const FloatVal& x) {
374 return FloatVal(square(x.x));
375 }
376 forceinline FloatVal
377 pow(const FloatVal& x, int n) {
378 return FloatVal(pow(x.x,n));
379 }
380 forceinline FloatVal
381 nroot(const FloatVal& x, int n) {
382 return FloatVal(nth_root(x.x,n));
383 }
384
385 forceinline FloatVal
386 max(const FloatVal& x, const FloatVal& y) {
387 return FloatVal(max(x.x,y.x));
388 }
389 forceinline FloatVal
390 max(const FloatVal& x, const FloatNum& y) {
391 return FloatVal(max(x.x,y));
392 }
393 forceinline FloatVal
394 max(const FloatNum& x, const FloatVal& y) {
395 return FloatVal(max(x,y.x));
396 }
397 forceinline FloatVal
398 min(const FloatVal& x, const FloatVal& y) {
399 return FloatVal(min(x.x,y.x));
400 }
401 forceinline FloatVal
402 min(const FloatVal& x, const FloatNum& y) {
403 return FloatVal(min(x.x,y));
404 }
405 forceinline FloatVal
406 min(const FloatNum& x, const FloatVal& y) {
407 return FloatVal(min(x,y.x));
408 }
409
410#ifdef GECODE_HAS_MPFR
411
412 forceinline FloatVal
413 exp(const FloatVal& x) {
414 return FloatVal(exp(x.x));
415 }
416 forceinline FloatVal
417 log(const FloatVal& x) {
418 return FloatVal(log(x.x));
419 }
420
421 forceinline FloatVal
422 fmod(const FloatVal& x, const FloatVal& y) {
423 return FloatVal(fmod(x.x,y.x));
424 }
425 forceinline FloatVal
426 fmod(const FloatVal& x, const FloatNum& y) {
427 return FloatVal(fmod(x.x,y));
428 }
429 forceinline FloatVal
430 fmod(const FloatNum& x, const FloatVal& y) {
431 return FloatVal(fmod(x,y.x));
432 }
433
434 forceinline FloatVal
435 sin(const FloatVal& x) {
436 return FloatVal(sin(x.x));
437 }
438 forceinline FloatVal
439 cos(const FloatVal& x) {
440 return FloatVal(cos(x.x));
441 }
442 forceinline FloatVal
443 tan(const FloatVal& x) {
444 return FloatVal(tan(x.x));
445 }
446 forceinline FloatVal
447 asin(const FloatVal& x) {
448 return FloatVal(asin(x.x));
449 }
450 forceinline FloatVal
451 acos(const FloatVal& x) {
452 return FloatVal(acos(x.x));
453 }
454 forceinline FloatVal
455 atan(const FloatVal& x) {
456 return FloatVal(atan(x.x));
457 }
458
459 forceinline FloatVal
460 sinh(const FloatVal& x) {
461 return FloatVal(sinh(x.x));
462 }
463 forceinline FloatVal
464 cosh(const FloatVal& x) {
465 return FloatVal(cosh(x.x));
466 }
467 forceinline FloatVal
468 tanh(const FloatVal& x) {
469 return FloatVal(tanh(x.x));
470 }
471 forceinline FloatVal
472 asinh(const FloatVal& x) {
473 return FloatVal(asinh(x.x));
474 }
475 forceinline FloatVal
476 acosh(const FloatVal& x) {
477 return FloatVal(acosh(x.x));
478 }
479 forceinline FloatVal
480 atanh(const FloatVal& x) {
481 return FloatVal(atanh(x.x));
482 }
483
484#endif
485}
486
487namespace Gecode { namespace Float {
488
489 forceinline bool
490 subset(const FloatVal& x, const FloatVal& y) {
491 return subset(x.x,y.x);
492 }
493 forceinline bool
494 proper_subset(const FloatVal& x, const FloatVal& y) {
495 return proper_subset(x.x,y.x);
496 }
497 forceinline bool
498 overlap(const FloatVal& x, const FloatVal& y) {
499 return overlap(x.x,y.x);
500 }
501
502 forceinline FloatVal
503 intersect(const FloatVal& x, const FloatVal& y) {
504 return FloatVal(intersect(x.x,y.x));
505 }
506 forceinline FloatVal
507 hull(const FloatVal& x, const FloatVal& y) {
508 return FloatVal(hull(x.x,y.x));
509 }
510 forceinline FloatVal
511 hull(const FloatVal& x, const FloatNum& y) {
512 return FloatVal(hull(x.x,y));
513 }
514 forceinline FloatVal
515 hull(const FloatNum& x, const FloatVal& y) {
516 return FloatVal(hull(x,y.x));
517 }
518 forceinline FloatVal
519 hull(const FloatNum& x, const FloatNum& y) {
520 return FloatVal(x,y);
521 }
522
523}}
524
525// STATISTICS: float-var
526