this repo has no description
dekker.one
1/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
2/*
3 * Main authors:
4 * Christian Schulte <schulte@gecode.org>
5 * Guido Tack <tack@gecode.org>
6 * Vincent Barichard <Vincent.Barichard@univ-angers.fr>
7 *
8 * Copyright:
9 * Christian Schulte, 2002
10 * Guido Tack, 2004
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
38#ifndef GECODE_FLOAT_HH
39#define GECODE_FLOAT_HH
40
41#include <climits>
42#include <cfloat>
43#include <iostream>
44
45#include <functional>
46
47#include <gecode/kernel.hh>
48#include <gecode/int.hh>
49
50/*
51 * Configure linking
52 *
53 */
54#if !defined(GECODE_STATIC_LIBS) && \
55 (defined(__CYGWIN__) || defined(__MINGW32__) || defined(_MSC_VER))
56
57#ifdef GECODE_BUILD_FLOAT
58#define GECODE_FLOAT_EXPORT __declspec( dllexport )
59#else
60#define GECODE_FLOAT_EXPORT __declspec( dllimport )
61#endif
62
63#else
64
65#ifdef GECODE_GCC_HAS_CLASS_VISIBILITY
66#define GECODE_FLOAT_EXPORT __attribute__ ((visibility("default")))
67#else
68#define GECODE_FLOAT_EXPORT
69#endif
70
71#endif
72
73// Configure auto-linking
74#ifndef GECODE_BUILD_FLOAT
75#define GECODE_LIBRARY_NAME "Float"
76#include <gecode/support/auto-link.hpp>
77#endif
78
79// Include interval implementation
80#include <gecode/third-party/boost/numeric/interval.hpp>
81
82/**
83 * \namespace Gecode::Float
84 * \brief Floating point numbers
85 *
86 * The Gecode::Float namespace contains all functionality required
87 * to program propagators and branchers for floating point numbers.
88 * In addition, all propagators and branchers for floating point
89 * numbers provided by %Gecode are contained as nested namespaces.
90 *
91 */
92
93#include <gecode/float/exception.hpp>
94
95#include <gecode/float/nextafter.hpp>
96
97namespace Gecode {
98
99 /**
100 * \brief Floating point number base type
101 *
102 * This type defines the interval bounds used for representing floating
103 * point values.
104 * \ingroup TaskModelFloatVars
105 */
106 typedef double FloatNum;
107
108 /// Return lower bound of \f$\pi/2\f$
109 FloatNum pi_half_lower(void);
110 /// Return upper bound of \f$\pi/2\f$
111 FloatNum pi_half_upper(void);
112 /// Return lower bound of \f$\pi\f$
113 FloatNum pi_lower(void);
114 /// Return upper bound of \f$\pi\f$
115 FloatNum pi_upper(void);
116 /// Return lower bound of \f$2\pi\f$
117 FloatNum pi_twice_lower(void);
118 /// Return upper bound of \f$2\pi\f$
119 FloatNum pi_twice_upper(void);
120
121 // Forward declaration
122 class FloatVal;
123
124}
125
126#include <gecode/float/num.hpp>
127
128namespace Gecode { namespace Float {
129
130
131#if defined(_MSC_VER) && (defined(_M_X64) || (defined(_M_IX86_FP) && (_M_IX86_FP > 0)))
132
133 /*
134 * This is used for the MSVC compiler for x64 or x86 with SSE enabled.
135 *
136 */
137 /// Rounding Base class (safe version)
138 typedef gecode_boost::numeric::interval_lib::save_state< gecode_boost::numeric::interval_lib::rounded_arith_std<FloatNum> >
139 RoundingBase;
140
141#else
142
143 /// Rounding Base class (optimized version)
144 typedef gecode_boost::numeric::interval_lib::rounded_arith_opp<FloatNum>
145 RoundingBase;
146
147#endif
148
149 /**
150 * \brief Floating point rounding policy
151 *
152 * \ingroup TaskModelFloatVars
153 */
154 class Rounding : public RoundingBase {
155 public:
156 /// \name Constructor and destructor
157 //@{
158 /// Default constructor (configures full rounding mode)
159 Rounding(void);
160 /// Destructor (restores previous rounding mode)
161 ~Rounding(void);
162 //@}
163
164 /// \name Arithmetic operations
165 //@{
166 /// Return lower bound of \a x plus \a y (domain: \f$ [-\infty;+\infty][-\infty;+\infty]\f$)
167 FloatNum add_down(FloatNum x, FloatNum y);
168 /// Return upper bound of \a x plus \a y (domain: \f$ [-\infty;+\infty] [-\infty;+\infty]\f$)
169 FloatNum add_up (FloatNum x, FloatNum y);
170 /// Return lower bound of \a x minus \a y (domain: \f$ [-\infty;+\infty] [-\infty;+\infty]\f$)
171 FloatNum sub_down(FloatNum x, FloatNum y);
172 /// Return upper bound of \a x minus \a y (domain: \f$ [-\infty;+\infty] [-\infty;+\infty]\f$)
173 FloatNum sub_up (FloatNum x, FloatNum y);
174 /// Return lower bound of \a x times \a y (domain: \f$ [-\infty;+\infty] [-\infty;+\infty]\f$)
175 FloatNum mul_down(FloatNum x, FloatNum y);
176 /// Return upper bound of \a x times \a y (domain: \f$ [-\infty;+\infty] [-\infty;+\infty]\f$)
177 FloatNum mul_up (FloatNum x, FloatNum y);
178 /// Return lower bound of \a x divided by \a y (domain: \f$ [-\infty;+\infty] ([-\infty;+\infty]-{0}) \f$)
179 FloatNum div_down(FloatNum x, FloatNum y);
180 /// Return upper bound of \a x divided \a y (domain: \f$ [-\infty;+\infty] ([-\infty;+\infty]-{0})\f$)
181 FloatNum div_up (FloatNum x, FloatNum y);
182 /// Return lower bound of square root of \a x (domain: \f$ ]0;+\infty] \f$)
183 FloatNum sqrt_down(FloatNum x);
184 /// Return upper bound of square root of \a x (domain: \f$ ]0;+\infty]\f$)
185 FloatNum sqrt_up (FloatNum x);
186 //@}
187
188 /// \name Miscellaneous operations
189 //@{
190 /// Return median of \a x and \a y (domain: \f$ [-\infty;+\infty][-\infty;+\infty]\f$)
191 FloatNum median(FloatNum x, FloatNum y);
192 /// Return next downward-rounded integer of \a x (domain: \f$ [-\infty;+\infty]\f$)
193 FloatNum int_down(FloatNum x);
194 /// Return next upward-rounded integer of \a x (domain: \f$ [-\infty;+\infty] \f$)
195 FloatNum int_up (FloatNum x);
196 //@}
197
198#ifdef GECODE_HAS_MPFR
199 /// \name Exponential functions
200 //@{
201 /// Return lower bound of exponential of \a x (domain: \f$ [-\infty;+\infty]\f$)
202 GECODE_FLOAT_EXPORT FloatNum exp_down(FloatNum x);
203 /// Return upper bound of exponential of \a x (domain: \f$ [-\infty;+\infty]\f$)
204 GECODE_FLOAT_EXPORT FloatNum exp_up (FloatNum x);
205 /// Return lower bound of logarithm of \a x (domain: \f$ ]0;+\infty]\f$)
206 GECODE_FLOAT_EXPORT FloatNum log_down(FloatNum x);
207 /// Return upper bound of logarithm of \a x (domain: \f$ ]0;+\infty]\f$)
208 GECODE_FLOAT_EXPORT FloatNum log_up (FloatNum x);
209 //@}
210
211 /// \name Trigonometric functions
212 //@{
213 /// Return lower bound of sine of \a x (domain: \f$ [0;2\pi]\f$)
214 GECODE_FLOAT_EXPORT FloatNum sin_down(FloatNum x);
215 /// Return upper bound of sine of \a x (domain: \f$ [0;2\pi]\f$)
216 GECODE_FLOAT_EXPORT FloatNum sin_up (FloatNum x);
217 /// Return lower bound of cosine of \a x (domain: \f$ [0;2\pi]\f$)
218 GECODE_FLOAT_EXPORT FloatNum cos_down(FloatNum x);
219 /// Return upper bound of cosine of \a x (domain: \f$ [0;2\pi]\f$)
220 GECODE_FLOAT_EXPORT FloatNum cos_up (FloatNum x);
221 /// Return lower bound of tangent of \a x (domain: \f$ ]-\pi/2;\pi/2[\f$)
222 GECODE_FLOAT_EXPORT FloatNum tan_down(FloatNum x);
223 /// Return upper bound of tangent of \a x (domain: \f$ ]-\pi/2;\pi/2[\f$)
224 GECODE_FLOAT_EXPORT FloatNum tan_up (FloatNum x);
225 //@}
226
227 /// \name Inverse trigonometric functions
228 //@{
229 /// Return lower bound of arcsine of \a x (domain: \f$ [-1;1]\f$)
230 GECODE_FLOAT_EXPORT FloatNum asin_down(FloatNum x);
231 /// Return upper bound of arcsine of \a x (domain: \f$ [-1;1]\f$)
232 GECODE_FLOAT_EXPORT FloatNum asin_up (FloatNum x);
233 /// Return lower bound of arccosine of \a x (domain: \f$ [-1;1]\f$)
234 GECODE_FLOAT_EXPORT FloatNum acos_down(FloatNum x);
235 /// Return upper bound of arccossine of \a x (domain: \f$ [-1;1]\f$)
236 GECODE_FLOAT_EXPORT FloatNum acos_up (FloatNum x);
237 /// Return lower bound of arctangent of \a x (domain: \f$ [-\infty;+\infty]\f$)
238 GECODE_FLOAT_EXPORT FloatNum atan_down(FloatNum x);
239 /// Return upper bound of arctangent of \a x (domain: \f$ [-\infty;+\infty]\f$)
240 GECODE_FLOAT_EXPORT FloatNum atan_up (FloatNum x);
241 //@}
242
243 /// \name Hyperbolic functions
244 //@{
245 /// Return lower bound of hyperbolic sine of \a x (domain: \f$ [-\infty;+\infty]\f$)
246 GECODE_FLOAT_EXPORT FloatNum sinh_down(FloatNum x);
247 /// Return upper bound of hyperbolic sine of \a x (domain: \f$ [-\infty;+\infty]\f$)
248 GECODE_FLOAT_EXPORT FloatNum sinh_up (FloatNum x);
249 /// Return lower bound of hyperbolic cosine of \a x (domain: \f$ [-\infty;+\infty]\f$)
250 GECODE_FLOAT_EXPORT FloatNum cosh_down(FloatNum x);
251 /// Return upper bound of hyperbolic cosine of \a x (domain: \f$ [-\infty;+\infty]\f$)
252 GECODE_FLOAT_EXPORT FloatNum cosh_up (FloatNum x);
253 /// Return lower bound of hyperbolic tangent of \a x (domain: \f$ [-\infty;+\infty]\f$)
254 GECODE_FLOAT_EXPORT FloatNum tanh_down(FloatNum x);
255 /// Return upper bound of hyperbolic tangent of \a x (domain: \f$ [-\infty;+\infty]\f$)
256 GECODE_FLOAT_EXPORT FloatNum tanh_up (FloatNum x);
257 //@}
258
259 /// \name Inverse hyperbolic functions
260 //@{
261 /// Return lower bound of hyperbolic arcsine of \a x (domain: \f$ [-\infty;+\infty]\f$)
262 GECODE_FLOAT_EXPORT FloatNum asinh_down(FloatNum x);
263 /// Return upper bound of hyperbolic arcsine of \a x (domain: \f$ [-\infty;+\infty]\f$)
264 GECODE_FLOAT_EXPORT FloatNum asinh_up (FloatNum x);
265 /// Return lower bound of hyperbolic arccosine of \a x (domain: \f$ [1;+\infty]\f$)
266 GECODE_FLOAT_EXPORT FloatNum acosh_down(FloatNum x);
267 /// Return upper bound of hyperbolic arccosine of \a x (domain: \f$ [1;+\infty]\f$)
268 GECODE_FLOAT_EXPORT FloatNum acosh_up (FloatNum x);
269 /// Return lower bound of hyperbolic arctangent of \a x (domain: \f$ [-1;1]\f$)
270 GECODE_FLOAT_EXPORT FloatNum atanh_down(FloatNum x);
271 /// Return upper bound of hyperbolic arctangent of \a x (domain: \f$ [-1;1]\f$)
272 GECODE_FLOAT_EXPORT FloatNum atanh_up (FloatNum x);
273 //@}
274#endif
275 };
276
277}}
278
279#include <gecode/float/rounding.hpp>
280
281namespace Gecode { namespace Float {
282
283 /**
284 * \brief Test whether \a x is a subset of \a y
285 * \relates Gecode::FloatVal
286 */
287 bool subset(const FloatVal& x, const FloatVal& y);
288 /**
289 * \brief Test whether \a x is a proper subset of \a y
290 * \relates Gecode::FloatVal
291 */
292 bool proper_subset(const FloatVal& x, const FloatVal& y);
293 /**
294 * \brief Test whether \a x and \a y overlap
295 * \relates Gecode::FloatVal
296 */
297 bool overlap(const FloatVal& x, const FloatVal& y);
298
299 /**
300 * \brief Return intersection of \a x and \a y
301 * \relates Gecode::FloatVal
302 */
303 FloatVal intersect(const FloatVal& x, const FloatVal& y);
304 /**
305 * \brief Return hull of \a x and \a y
306 * \relates Gecode::FloatVal
307 */
308 FloatVal hull(const FloatVal& x, const FloatVal& y);
309 /**
310 * \brief Return hull of \a x and \a y
311 * \relates Gecode::FloatVal
312 */
313 FloatVal hull(const FloatVal& x, const FloatNum& y);
314 /**
315 * \brief Return hull of \a x and \a y
316 * \relates Gecode::FloatVal
317 */
318 FloatVal hull(const FloatNum& x, const FloatVal& y);
319 /**
320 * \brief Return hull of \a x and \a y
321 * \relates Gecode::FloatVal
322 */
323 FloatVal hull(const FloatNum& x, const FloatNum& y);
324
325}}
326
327namespace Gecode {
328
329 /**
330 * \brief Float value type
331 *
332 * \ingroup TaskModelFloatVars
333 */
334 class FloatVal {
335 friend FloatVal operator +(const FloatVal& x);
336 friend FloatVal operator -(const FloatVal& x);
337 friend FloatVal operator +(const FloatVal& x, const FloatVal& y);
338 friend FloatVal operator +(const FloatVal& x, const FloatNum& y);
339 friend FloatVal operator +(const FloatNum& x, const FloatVal& y);
340 friend FloatVal operator -(const FloatVal& x, const FloatVal& y);
341 friend FloatVal operator -(const FloatVal& x, const FloatNum& y);
342 friend FloatVal operator -(const FloatNum& x, const FloatVal& y);
343 friend FloatVal operator *(const FloatVal& x, const FloatVal& y);
344 friend FloatVal operator *(const FloatVal& x, const FloatNum& y);
345 friend FloatVal operator *(const FloatNum& x, const FloatVal& y);
346 friend FloatVal operator /(const FloatVal& x, const FloatVal& y);
347 friend FloatVal operator /(const FloatVal& x, const FloatNum& y);
348 friend FloatVal operator /(const FloatNum& x, const FloatVal& y);
349
350 friend bool operator <(const FloatVal& x, const FloatVal& y);
351 friend bool operator <(const FloatVal& x, const FloatNum& y);
352 friend bool operator <(const FloatNum& x, const FloatVal& y);
353 friend bool operator <=(const FloatVal& x, const FloatVal& y);
354 friend bool operator <=(const FloatVal& x, const FloatNum& y);
355 friend bool operator <=(const FloatNum& x, const FloatVal& y);
356 friend bool operator >(const FloatVal& x, const FloatVal& y);
357 friend bool operator >(const FloatVal& x, const FloatNum& y);
358 friend bool operator >(const FloatNum& x, const FloatVal& y);
359 friend bool operator >=(const FloatVal& x, const FloatVal& y);
360 friend bool operator >=(const FloatVal& x, const FloatNum& y);
361 friend bool operator >=(const FloatNum& x, const FloatVal& y);
362 friend bool operator ==(const FloatVal& x, const FloatVal& y);
363 friend bool operator ==(const FloatVal& x, const FloatNum& y);
364 friend bool operator ==(const FloatNum& x, const FloatVal& y);
365 friend bool operator !=(const FloatVal& x, const FloatVal& y);
366 friend bool operator !=(const FloatVal& x, const FloatNum& y);
367 friend bool operator !=(const FloatNum& x, const FloatVal& y);
368
369 template<class Char, class Traits>
370 friend std::basic_ostream<Char,Traits>&
371 operator <<(std::basic_ostream<Char,Traits>& os, const FloatVal& x);
372
373 friend FloatVal abs(const FloatVal& x);
374 friend FloatVal sqrt(const FloatVal& x);
375 friend FloatVal sqr(const FloatVal& x);
376 friend FloatVal pow(const FloatVal& x, int n);
377 friend FloatVal nroot(const FloatVal& x, int n);
378
379 friend FloatVal max(const FloatVal& x, const FloatVal& y);
380 friend FloatVal max(const FloatVal& x, const FloatNum& y);
381 friend FloatVal max(const FloatNum& x, const FloatVal& y);
382 friend FloatVal min(const FloatVal& x, const FloatVal& y);
383 friend FloatVal min(const FloatVal& x, const FloatNum& y);
384 friend FloatVal min(const FloatNum& x, const FloatVal& y);
385
386#ifdef GECODE_HAS_MPFR
387 friend FloatVal exp(const FloatVal& x);
388 friend FloatVal log(const FloatVal& x);
389 friend FloatVal fmod(const FloatVal& x, const FloatVal& y);
390 friend FloatVal fmod(const FloatVal& x, const FloatNum& y);
391 friend FloatVal fmod(const FloatNum& x, const FloatVal& y);
392 friend FloatVal sin(const FloatVal& x);
393 friend FloatVal cos(const FloatVal& x);
394 friend FloatVal tan(const FloatVal& x);
395 friend FloatVal asin(const FloatVal& x);
396 friend FloatVal acos(const FloatVal& x);
397 friend FloatVal atan(const FloatVal& x);
398 friend FloatVal sinh(const FloatVal& x);
399 friend FloatVal cosh(const FloatVal& x);
400 friend FloatVal tanh(const FloatVal& x);
401 friend FloatVal asinh(const FloatVal& x);
402 friend FloatVal acosh(const FloatVal& x);
403 friend FloatVal atanh(const FloatVal& x);
404#endif
405
406 friend bool Float::subset(const FloatVal& x, const FloatVal& y);
407 friend bool Float::proper_subset(const FloatVal& x, const FloatVal& y);
408 friend bool Float::overlap(const FloatVal& x, const FloatVal& y);
409 friend FloatVal Float::intersect(const FloatVal& x, const FloatVal& y);
410 friend FloatVal Float::hull(const FloatVal& x, const FloatVal& y);
411 friend FloatVal Float::hull(const FloatVal& x, const FloatNum& y);
412 friend FloatVal Float::hull(const FloatNum& x, const FloatVal& y);
413 friend FloatVal Float::hull(const FloatNum& x, const FloatNum& y);
414 protected:
415 /// Used rounding policies
416 typedef gecode_boost::numeric::interval_lib::save_state<Float::Rounding> R;
417 /// Used checking policy
418 typedef gecode_boost::numeric::interval_lib::checking_strict<FloatNum> P;
419 /// Implementation type for float value
420 typedef gecode_boost::numeric::interval
421 <FloatNum,
422 gecode_boost::numeric::interval_lib::policies<R, P> >
423 FloatValImpType;
424 /// Implementation of float value
425 FloatValImpType x;
426 /// Initialize from implementation \a i
427 explicit FloatVal(const FloatValImpType& i);
428 public:
429 /// \name Constructors and initialization
430 //@{
431 /// Default constructor
432 FloatVal(void);
433 /// Initialize with float number \a n
434 FloatVal(const FloatNum& n);
435 /// Initialize with lower bound \a l and upper bound \a u
436 FloatVal(const FloatNum& l, const FloatNum& u);
437 /// Copy constructor
438 FloatVal(const FloatVal& v);
439
440 /// Assignment operator
441 FloatVal& operator =(const FloatNum& n);
442 /// Assignment operator
443 FloatVal& operator =(const FloatVal& v);
444
445 /// Assign lower bound \a l and upper bound \a u
446 void assign(FloatNum const &l, FloatNum const &u);
447 //@}
448
449 /// \name Value access
450 //@{
451 /// Return lower bound
452 FloatNum min(void) const;
453 /// Return upper bound
454 FloatNum max(void) const;
455 /// Return size of float value (distance between maximum and minimum)
456 FloatNum size(void) const;
457 /// Return median of float value
458 FloatNum med(void) const;
459 //@}
460
461 /// \name Value tests
462 //@{
463 /// Test whether float is tight
464 bool tight(void) const;
465 /// Test whether float is a singleton
466 bool singleton(void) const;
467 /// Test whether \a n is included
468 bool in(FloatNum n) const;
469 /// Test whether zero is included
470 bool zero_in(void) const;
471 //@}
472
473 /// \name Float value construction
474 //@{
475 /// Return hull of \a x and \a y
476 static FloatVal hull(FloatNum x, FloatNum y);
477 /// Return \f$\pi/2\f$
478 static FloatVal pi_half(void);
479 /// Return lower bound of \f$\pi\f$
480 static FloatVal pi(void);
481 /// Return \f$2\pi\f$
482 static FloatVal pi_twice(void);
483 //@}
484
485 /// \name Update operators
486 //@{
487 /// Increment by \a n
488 FloatVal& operator +=(const FloatNum& n);
489 /// Subtract by \a n
490 FloatVal& operator -=(const FloatNum& n);
491 /// Multiply by \a n
492 FloatVal& operator *=(const FloatNum& n);
493 /// Divide by \a n
494 FloatVal& operator /=(const FloatNum& n);
495 /// Increment by \a v
496 FloatVal& operator +=(const FloatVal& v);
497 /// Subtract by \a v
498 FloatVal& operator -=(const FloatVal& v);
499 /// Multiply by \a v
500 FloatVal& operator *=(const FloatVal& v);
501 /// Divide by \a v
502 FloatVal& operator /=(const FloatVal& v);
503 //@}
504 };
505
506 /**
507 * \brief Arithmetic operator
508 * \relates Gecode::FloatVal
509 */
510 FloatVal operator +(const FloatVal& x);
511 /**
512 * \brief Arithmetic operator
513 * \relates Gecode::FloatVal
514 */
515 FloatVal operator -(const FloatVal& x);
516
517 /**
518 * \brief Arithmetic operator
519 * \relates Gecode::FloatVal
520 */
521 FloatVal operator +(const FloatVal& x, const FloatVal& y);
522 /**
523 * \brief Arithmetic operator
524 * \relates Gecode::FloatVal
525 */
526 FloatVal operator +(const FloatVal& x, const FloatNum& y);
527 /**
528 * \brief Arithmetic operator
529 * \relates Gecode::FloatVal
530 */
531 FloatVal operator +(const FloatNum& x, const FloatVal& y);
532 /**
533 * \brief Arithmetic operator
534 * \relates Gecode::FloatVal
535 */
536 FloatVal operator -(const FloatVal& x, const FloatVal& y);
537 /**
538 * \brief Arithmetic operator
539 * \relates Gecode::FloatVal
540 */
541 FloatVal operator -(const FloatVal& x, const FloatNum& y);
542 /**
543 * \brief Arithmetic operator
544 * \relates Gecode::FloatVal
545 */
546 FloatVal operator -(const FloatNum& x, const FloatVal& y);
547 /**
548 * \brief Arithmetic operator
549 * \relates Gecode::FloatVal
550 */
551 FloatVal operator *(const FloatVal& x, const FloatVal& y);
552 /**
553 * \brief Arithmetic operator
554 * \relates Gecode::FloatVal
555 */
556 FloatVal operator *(const FloatVal& x, const FloatNum& y);
557 /**
558 * \brief Arithmetic operator
559 * \relates Gecode::FloatVal
560 */
561 FloatVal operator *(const FloatNum& x, const FloatVal& y);
562 /**
563 * \brief Arithmetic operator
564 * \relates Gecode::FloatVal
565 */
566 FloatVal operator /(const FloatVal& x, const FloatVal& y);
567 /**
568 * \brief Arithmetic operator
569 * \relates Gecode::FloatVal
570 */
571 FloatVal operator /(const FloatVal& x, const FloatNum& y);
572 /**
573 * \brief Arithmetic operator
574 * \relates Gecode::FloatVal
575 */
576 FloatVal operator /(const FloatNum& r, const FloatVal& x);
577
578 /**
579 * \brief Comparison operator
580 * \relates Gecode::FloatVal
581 */
582 bool operator <(const FloatVal& x, const FloatVal& y);
583 /**
584 * \brief Comparison operator
585 * \relates Gecode::FloatVal
586 */
587 bool operator <(const FloatVal& x, const FloatNum& y);
588 /**
589 * \brief Comparison operator
590 * \relates Gecode::FloatVal
591 */
592 bool operator <(const FloatNum& x, const FloatVal& y);
593
594 /**
595 * \brief Comparison operator
596 * \relates Gecode::FloatVal
597 */
598 bool operator <=(const FloatVal& x, const FloatVal& y);
599 /**
600 * \brief Comparison operator
601 * \relates Gecode::FloatVal
602 */
603 bool operator <=(const FloatVal& x, const FloatNum& y);
604 /**
605 * \brief Comparison operator
606 * \relates Gecode::FloatVal
607 */
608 bool operator <=(const FloatNum& x, const FloatVal& y);
609
610 /**
611 * \brief Comparison operator
612 * \relates Gecode::FloatVal
613 */
614 bool operator >(const FloatVal& x, const FloatVal& y);
615 /**
616 * \brief Comparison operator
617 * \relates Gecode::FloatVal
618 */
619 bool operator >(const FloatVal& x, const FloatNum& y);
620 /**
621 * \brief Comparison operator
622 * \relates Gecode::FloatVal
623 */
624 bool operator >(const FloatNum& x, const FloatVal& y);
625
626 /**
627 * \brief Comparison operator
628 * \relates Gecode::FloatVal
629 */
630 bool operator >=(const FloatVal& x, const FloatVal& y);
631 /**
632 * \brief Comparison operator
633 * \relates Gecode::FloatVal
634 */
635 bool operator >=(const FloatVal& x, const FloatNum& y);
636 /**
637 * \brief Comparison operator
638 * \relates Gecode::FloatVal
639 */
640 bool operator >=(const FloatNum& x, const FloatVal& y);
641 /**
642 * \brief Comparison operator
643 * \relates Gecode::FloatVal
644 */
645 bool operator ==(const FloatVal& x, const FloatVal& y);
646 /**
647 * \brief Comparison operator
648 * \relates Gecode::FloatVal
649 */
650 bool operator ==(const FloatVal& x, const FloatNum& y);
651 /**
652 * \brief Comparison operator
653 * \relates Gecode::FloatVal
654 */
655 bool operator ==(const FloatNum& x, const FloatVal& y);
656
657 /**
658 * \brief Comparison operator
659 * \relates Gecode::FloatVal
660 */
661 bool operator !=(const FloatVal& x, const FloatVal& y);
662 /**
663 * \brief Comparison operator
664 * \relates Gecode::FloatVal
665 */
666 bool operator !=(const FloatVal& x, const FloatNum& y);
667 /**
668 * \brief Comparison operator
669 * \relates Gecode::FloatVal
670 */
671 bool operator !=(const FloatNum& x, const FloatVal& y);
672
673 /**
674 * \brief Print float value \a x
675 * \relates Gecode::FloatVal
676 */
677 template<class Char, class Traits>
678 std::basic_ostream<Char,Traits>&
679 operator <<(std::basic_ostream<Char,Traits>& os, const FloatVal& x);
680
681 /**
682 * \brief Return absolute value of \a x
683 * \relates Gecode::FloatVal
684 */
685 FloatVal abs(const FloatVal& x);
686 /**
687 * \brief Return square root of \a x
688 * \relates Gecode::FloatVal
689 */
690 FloatVal sqrt(const FloatVal& x);
691 /**
692 * \brief Return square of \a x
693 * \relates Gecode::FloatVal
694 */
695 FloatVal sqr(const FloatVal& x);
696 /**
697 * \brief Return \a n -th power of \a x
698 * \relates Gecode::FloatVal
699 */
700 FloatVal pow(const FloatVal& x, int n);
701 /**
702 * \brief Return \a n -th root of \a x
703 * \relates Gecode::FloatVal
704 */
705 FloatVal nroot(const FloatVal& x, int n);
706
707 /**
708 * \brief Return maximum of \a x and \a y
709 * \relates Gecode::FloatVal
710 */
711 FloatVal max(const FloatVal& x, const FloatVal& y);
712 /**
713 * \brief Return maximum of \a x and \a y
714 * \relates Gecode::FloatVal
715 */
716 FloatVal max(const FloatVal& x, const FloatNum& y);
717 /**
718 * \brief Return maximum of \a x and \a y
719 * \relates Gecode::FloatVal
720 */
721 FloatVal max(const FloatNum& x, const FloatVal& y);
722 /**
723 * \brief Return minimum of \a x and \a y
724 * \relates Gecode::FloatVal
725 */
726 FloatVal min(const FloatVal& x, const FloatVal& y);
727 /**
728 * \brief Return minimum of \a x and \a y
729 * \relates Gecode::FloatVal
730 */
731 FloatVal min(const FloatVal& x, const FloatNum& y);
732 /**
733 * \brief Return minimum of \a x and \a y
734 * \relates Gecode::FloatVal
735 */
736 FloatVal min(const FloatNum& x, const FloatVal& y);
737
738#ifdef GECODE_HAS_MPFR
739 /* transcendental functions: exp, log */
740 /**
741 * \brief Return exponential of \a x
742 * \relates Gecode::FloatVal
743 */
744 FloatVal exp(const FloatVal& x);
745 /**
746 * \brief Return logarithm of \a x
747 * \relates Gecode::FloatVal
748 */
749 FloatVal log(const FloatVal& x);
750
751 /**
752 * \brief Trigonometric function argument reduction
753 * \relates Gecode::FloatVal
754 */
755 FloatVal fmod(const FloatVal& x, const FloatVal& y);
756 /**
757 * \brief Trigonometric function argument reduction
758 * \relates Gecode::FloatVal
759 */
760 FloatVal fmod(const FloatVal& x, const FloatNum& y);
761 /**
762 * \brief Trigonometric function argument reduction
763 * \relates Gecode::FloatVal
764 */
765 FloatVal fmod(const FloatNum& x, const FloatVal& y);
766
767 /**
768 * \brief Return sine of \a x
769 * \relates Gecode::FloatVal
770 */
771 FloatVal sin(const FloatVal& x);
772 /**
773 * \brief Return cosine of \a x
774 * \relates Gecode::FloatVal
775 */
776 FloatVal cos(const FloatVal& x);
777 /**
778 * \brief Return tangent of \a x
779 * \relates Gecode::FloatVal
780 */
781 FloatVal tan(const FloatVal& x);
782 /**
783 * \brief Return arcsine of \a x
784 * \relates Gecode::FloatVal
785 */
786 FloatVal asin(const FloatVal& x);
787 /**
788 * \brief Return arccosine of \a x
789 * \relates Gecode::FloatVal
790 */
791 FloatVal acos(const FloatVal& x);
792 /**
793 * \brief Return arctangent of \a x
794 * \relates Gecode::FloatVal
795 */
796 FloatVal atan(const FloatVal& x);
797
798 /**
799 * \brief Return hyperbolic of \a x
800 * \relates Gecode::FloatVal
801 */
802 FloatVal sinh(const FloatVal& x);
803 /**
804 * \brief Return hyperbolic of \a x
805 * \relates Gecode::FloatVal
806 */
807 FloatVal cosh(const FloatVal& x);
808 /**
809 * \brief Return hyperbolic of \a x
810 * \relates Gecode::FloatVal
811 */
812 FloatVal tanh(const FloatVal& x);
813 /**
814 * \brief Return hyperbolic of \a x
815 * \relates Gecode::FloatVal
816 */
817 FloatVal asinh(const FloatVal& x);
818 /**
819 * \brief Return hyperbolic of \a x
820 * \relates Gecode::FloatVal
821 */
822 FloatVal acosh(const FloatVal& x);
823 /**
824 * \brief Return hyperbolic of \a x
825 * \relates Gecode::FloatVal
826 */
827 FloatVal atanh(const FloatVal& x);
828
829#endif
830
831}
832
833#include <gecode/float/val.hpp>
834
835namespace Gecode { namespace Float {
836
837 /**
838 * \brief Numerical limits for floating point variables
839 *
840 * \ingroup TaskModelFloatVars
841 */
842 namespace Limits {
843 /// Largest allowed float value
844 const FloatNum max = std::numeric_limits<FloatNum>::max();
845 /// Smallest allowed float value
846 const FloatNum min = -max;
847 /// Return whether float \a n is a valid number
848 bool valid(const FloatVal& n);
849 /// Check whether float \a n is a valid number, otherwise throw out of limits exception with information \a l
850 void check(const FloatVal& n, const char* l);
851 }
852
853}}
854
855#include <gecode/float/limits.hpp>
856
857#include <gecode/float/var-imp.hpp>
858
859namespace Gecode {
860
861 namespace Float {
862 class FloatView;
863 }
864
865 /**
866 * \brief Float variables
867 *
868 * \ingroup TaskModelFloatVars
869 */
870 class FloatVar : public VarImpVar<Float::FloatVarImp> {
871 friend class FloatVarArray;
872 friend class FloatVarArgs;
873 private:
874 using VarImpVar<Float::FloatVarImp>::x;
875 /**
876 * \brief Initialize variable with range domain
877 *
878 * The variable is created with a domain ranging from \a min
879 * to \a max. No exceptions are thrown.
880 */
881 void _init(Space& home, FloatNum min, FloatNum max);
882 public:
883 /// \name Constructors and initialization
884 //@{
885 /// Default constructor
886 FloatVar(void);
887 /// Initialize from float variable \a y
888 FloatVar(const FloatVar& y);
889 /// Initialize from float view \a y
890 FloatVar(const Float::FloatView& y);
891 /**
892 * \brief Initialize variable with range domain
893 *
894 * The variable is created with a domain ranging from \a min
895 * to \a max. The following exceptions might be thrown:
896 * - If \a min is greater than \a max, an exception of type
897 * Gecode::Float::VariableEmptyDomain is thrown.
898 * - If \a min or \a max exceed the limits for floats as defined
899 * in Gecode::Float::Limits, an exception of type
900 * Gecode::Float::OutOfLimits is thrown.
901 */
902 GECODE_FLOAT_EXPORT FloatVar(Space& home, FloatNum min, FloatNum max);
903 //@}
904
905 /// \name Value access
906 //@{
907 /// Return domain
908 FloatVal domain(void) const;
909 /// Return minimum of domain
910 FloatNum min(void) const;
911 /// Return maximum of domain
912 FloatNum max(void) const;
913 /// Return median of domain
914 FloatNum med(void) const;
915 /// Return size of domain (distance between maximum and minimum)
916 FloatNum size(void) const;
917 /**
918 * \brief Return assigned value
919 *
920 * Throws an exception of type Float::ValOfUnassignedVar if variable
921 * is not yet assigned.
922 *
923 */
924 FloatVal val(void) const;
925
926 //@}
927
928 /// \name Domain tests
929 //@{
930 /// Test whether \a n is contained in domain
931 bool in(const FloatVal& n) const;
932 //@}
933 };
934
935 /**
936 * \brief Print float variable \a x
937 * \relates Gecode::FloatVar
938 */
939 template<class Char, class Traits>
940 std::basic_ostream<Char,Traits>&
941 operator <<(std::basic_ostream<Char,Traits>& os, const FloatVar& x);
942}
943
944#include <gecode/float/view.hpp>
945#include <gecode/float/array-traits.hpp>
946
947namespace Gecode {
948
949 /// Passing float arguments
950 class FloatValArgs : public ArgArray<FloatVal> {
951 public:
952 /// \name Constructors and initialization
953 //@{
954 /// Allocate empty array
955 FloatValArgs(void);
956 /// Allocate array with \a n elements
957 explicit FloatValArgs(int n);
958 /// Allocate array and copy elements from \a x
959 FloatValArgs(const SharedArray<FloatVal>& x);
960 /// Allocate array and copy elements from \a x
961 FloatValArgs(const std::vector<FloatVal>& x);
962 /// Allocate array and copy elements from \a x
963 FloatValArgs(std::initializer_list<FloatVal> x);
964 /// Allocate array and copy elements from \a first to \a last
965 template<class InputIterator>
966 FloatValArgs(InputIterator first, InputIterator last);
967 /// Allocate array with \a n elements and initialize with elements from array \a e
968 FloatValArgs(int n, const FloatVal* e);
969 /// Initialize from primitive argument array \a a (copy elements)
970 FloatValArgs(const ArgArray<FloatVal>& a);
971
972 /// Allocate array with \a n elements such that for all \f$0\leq i<n: x_i=\text{start}+i\cdot\text{inc}\f$
973 GECODE_FLOAT_EXPORT
974 static FloatValArgs create(int n, FloatVal start, int inc=1);
975 //@}
976 };
977
978 /// \brief Passing float variables
979 class FloatVarArgs : public VarArgArray<FloatVar> {
980 public:
981 /// \name Constructors and initialization
982 //@{
983 /// Allocate empty array
984 FloatVarArgs(void);
985 /// Allocate array with \a n elements
986 explicit FloatVarArgs(int n);
987 /// Initialize from variable argument array \a a (copy elements)
988 FloatVarArgs(const FloatVarArgs& a);
989 /// Initialize from variable array \a a (copy elements)
990 FloatVarArgs(const VarArray<FloatVar>& a);
991 /// Initialize from vector \a a
992 FloatVarArgs(const std::vector<FloatVar>& a);
993 /// Initialize from list \a a
994 FloatVarArgs(std::initializer_list<FloatVar> a);
995 /// Initialize from InputIterator \a first and \a last
996 template<class InputIterator>
997 FloatVarArgs(InputIterator first, InputIterator last);
998 /**
999 * \brief Initialize array with \a n new variables
1000 *
1001 * The variables are created with a domain ranging from \a min
1002 * to \a max. The following execptions might be thrown:
1003 * - If \a min is greater than \a max, an exception of type
1004 * Gecode::Float::VariableEmptyDomain is thrown.
1005 * - If \a min or \a max exceed the limits for floats as defined
1006 * in Gecode::Float::Limits, an exception of type
1007 * Gecode::Float::OutOfLimits is thrown.
1008 */
1009 GECODE_FLOAT_EXPORT
1010 FloatVarArgs(Space& home, int n, FloatNum min, FloatNum max);
1011 //@}
1012 };
1013 //@}
1014
1015 /**
1016 * \defgroup TaskModelFloatVarArrays Variable arrays
1017 *
1018 * Variable arrays can store variables. They are typically used
1019 * for storing the variables being part of a solution (script). However,
1020 * they can also be used for temporary purposes (even though
1021 * memory is not reclaimed until the space it is created for
1022 * is deleted).
1023 * \ingroup TaskModelFloat
1024 */
1025
1026 /**
1027 * \brief Float variable array
1028 * \ingroup TaskModelFloatVarArrays
1029 */
1030 class FloatVarArray : public VarArray<FloatVar> {
1031 public:
1032 /// \name Creation and initialization
1033 //@{
1034 /// Default constructor (array of size 0)
1035 FloatVarArray(void);
1036 /// Allocate array for \a n float variables (variables are uninitialized)
1037 FloatVarArray(Space& home, int n);
1038 /// Initialize from float variable array \a a (share elements)
1039 FloatVarArray(const FloatVarArray& a);
1040 /// Initialize from float variable argument array \a a (copy elements)
1041 FloatVarArray(Space& home, const FloatVarArgs& a);
1042 /**
1043 * \brief Initialize array with \a n new variables
1044 *
1045 * The variables are created with a domain ranging from \a min
1046 * to \a max. The following execptions might be thrown:
1047 * - If \a min is greater than \a max, an exception of type
1048 * Gecode::Float::VariableEmptyDomain is thrown.
1049 * - If \a min or \a max exceed the limits for floats as defined
1050 * in Gecode::Float::Limits, an exception of type
1051 * Gecode::Float::OutOfLimits is thrown.
1052 */
1053 GECODE_FLOAT_EXPORT
1054 FloatVarArray(Space& home, int n, FloatNum min, FloatNum max);
1055 //@}
1056 };
1057
1058}
1059
1060#include <gecode/float/array.hpp>
1061
1062namespace Gecode {
1063
1064 /**
1065 * \brief Relation types for floats
1066 * \ingroup TaskModelFloat
1067 */
1068 enum FloatRelType {
1069 FRT_EQ, ///< Equality (\f$=\f$)
1070 FRT_NQ, ///< Disequality (\f$\neq\f$)
1071 FRT_LQ, ///< Less or equal (\f$\leq\f$)
1072 FRT_LE, ///< Less (\f$<\f$)
1073 FRT_GQ, ///< Greater or equal (\f$\geq\f$)
1074 FRT_GR ///< Greater (\f$>\f$)
1075 };
1076
1077 /**
1078 * \defgroup TaskModelFloatDomain Domain constraints
1079 * \ingroup TaskModelFloat
1080 *
1081 */
1082
1083 //@{
1084 /// Propagates \f$x=n\f$
1085 GECODE_FLOAT_EXPORT void
1086 dom(Home home, FloatVar x, FloatVal n);
1087 /// Propagates \f$ x_i=n\f$ for all \f$0\leq i<|x|\f$
1088 GECODE_FLOAT_EXPORT void
1089 dom(Home home, const FloatVarArgs& x, FloatVal n);
1090 /// Propagates \f$ l\leq x\leq u\f$
1091 GECODE_FLOAT_EXPORT void
1092 dom(Home home, FloatVar x, FloatNum l, FloatNum m);
1093 /// Propagates \f$ l\leq x_i\leq u\f$ for all \f$0\leq i<|x|\f$
1094 GECODE_FLOAT_EXPORT void
1095 dom(Home home, const FloatVarArgs& x, FloatNum l, FloatNum u);
1096 /// Post domain consistent propagator for \f$ (x=n) \equiv r\f$
1097 GECODE_FLOAT_EXPORT void
1098 dom(Home home, FloatVar x, FloatVal n, Reify r);
1099 /// Post domain consistent propagator for \f$ (l\leq x \leq u) \equiv r\f$
1100 GECODE_FLOAT_EXPORT void
1101 dom(Home home, FloatVar x, FloatNum l, FloatNum u, Reify r);
1102 /// Constrain domain of \a x according to domain of \a d
1103 GECODE_FLOAT_EXPORT void
1104 dom(Home home, FloatVar x, FloatVar d);
1105 /// Constrain domain of \f$ x_i \f$ according to domain of \f$ d_i \f$ for all \f$0\leq i<|x|\f$
1106 GECODE_FLOAT_EXPORT void
1107 dom(Home home, const FloatVarArgs& x, const FloatVarArgs& d);
1108 //@}
1109
1110 /**
1111 * \defgroup TaskModelFloatRelFloat Simple relation constraints over float variables
1112 * \ingroup TaskModelFloat
1113 */
1114 /** \brief Post propagator for \f$ x_0 \sim_{frt} x_1\f$
1115 *
1116 * \ingroup TaskModelFloatRelFloat
1117 */
1118 GECODE_FLOAT_EXPORT void
1119 rel(Home home, FloatVar x0, FloatRelType frt, FloatVar x1);
1120 /** \brief Propagates \f$ x \sim_{frt} c\f$
1121 * \ingroup TaskModelFloatRelFloat
1122 */
1123 GECODE_FLOAT_EXPORT void
1124 rel(Home home, FloatVar x, FloatRelType frt, FloatVal c);
1125 /** \brief Post propagator for \f$(x \sim_{frt} c)\equiv r\f$
1126 * \ingroup TaskModelFloatRelFloat
1127 */
1128 GECODE_FLOAT_EXPORT void
1129 rel(Home home, FloatVar x, FloatRelType frt, FloatVal c, Reify r);
1130 /** \brief Post propagator for \f$(x_0 \sim_{frt} x_1)\equiv r\f$
1131 * \ingroup TaskModelFloatRelFloat
1132 */
1133 GECODE_FLOAT_EXPORT void
1134 rel(Home home, FloatVar x0, FloatRelType frt, FloatVar x1, Reify r);
1135 /** \brief Propagates \f$ x_i \sim_{frt} c \f$ for all \f$0\leq i<|x|\f$
1136 * \ingroup TaskModelFloatRelFloat
1137 */
1138 GECODE_FLOAT_EXPORT void
1139 rel(Home home, const FloatVarArgs& x, FloatRelType frt, FloatVal c);
1140 /** \brief Propagates \f$ x_i \sim_{frt} y \f$ for all \f$0\leq i<|x|\f$
1141 * \ingroup TaskModelFloatRelFloat
1142 */
1143 GECODE_FLOAT_EXPORT void
1144 rel(Home home, const FloatVarArgs& x, FloatRelType frt, FloatVar y);
1145 /** \brief Post propagator for if-then-else constraint
1146 *
1147 * Posts propagator for \f$ z = b ? x : y \f$
1148 *
1149 * \ingroup TaskModelFloatRelFloat
1150 */
1151 GECODE_FLOAT_EXPORT void
1152 ite(Home home, BoolVar b, FloatVar x, FloatVar y, FloatVar z);
1153
1154}
1155
1156
1157namespace Gecode {
1158
1159 /**
1160 * \defgroup TaskModelFloatArith Arithmetic constraints
1161 * \ingroup TaskModelFloat
1162 */
1163
1164 //@{
1165 /** \brief Post propagator for \f$ \min\{x_0,x_1\}=x_2\f$
1166 */
1167 GECODE_FLOAT_EXPORT void
1168 min(Home home, FloatVar x0, FloatVar x1, FloatVar x2);
1169 /** \brief Post propagator for \f$ \min x=y\f$
1170 * If \a x is empty, an exception of type Float::TooFewArguments is thrown.
1171 */
1172 GECODE_FLOAT_EXPORT void
1173 min(Home home, const FloatVarArgs& x, FloatVar y);
1174 /** \brief Post propagator for \f$ \max\{x_0,x_1\}=x_2\f$
1175 */
1176 GECODE_FLOAT_EXPORT void
1177 max(Home home, FloatVar x0, FloatVar x1, FloatVar x2);
1178 /** \brief Post propagator for \f$ \max x=y\f$
1179 * If \a x is empty, an exception of type Float::TooFewArguments is thrown.
1180 */
1181 GECODE_FLOAT_EXPORT void
1182 max(Home home, const FloatVarArgs& x, FloatVar y);
1183
1184 /** \brief Post propagator for \f$ |x_0|=x_1\f$
1185 */
1186 GECODE_FLOAT_EXPORT void
1187 abs(Home home, FloatVar x0, FloatVar x1);
1188
1189 /** \brief Post propagator for \f$x_0\cdot x_1=x_2\f$
1190 */
1191 GECODE_FLOAT_EXPORT void
1192 mult(Home home, FloatVar x0, FloatVar x1, FloatVar x2);
1193
1194 /** \brief Post propagator for \f$x_0\cdot x_0=x_1\f$
1195 */
1196 GECODE_FLOAT_EXPORT void
1197 sqr(Home home, FloatVar x0, FloatVar x1);
1198
1199 /** \brief Post propagator for \f$\sqrt{x_0}=x_1\f$
1200 */
1201 GECODE_FLOAT_EXPORT void
1202 sqrt(Home home, FloatVar x0, FloatVar x1);
1203
1204 /** \brief Post propagator for \f${x_0}^{n}=x_1\f$ for $n\geq 0$
1205 */
1206 GECODE_FLOAT_EXPORT void
1207 pow(Home home, FloatVar x0, int n, FloatVar x1);
1208
1209 /** \brief Post propagator for \f${x_0}^{1/n}=x_1\f$ for $n\geq 0$
1210 */
1211 GECODE_FLOAT_EXPORT void
1212 nroot(Home home, FloatVar x0, int n, FloatVar x1);
1213
1214 /** \brief Post propagator for \f$x_0\ \mathrm{div}\ x_1=x_2\f$
1215 */
1216 GECODE_FLOAT_EXPORT void
1217 div(Home home, FloatVar x0, FloatVar x1, FloatVar x2);
1218#ifdef GECODE_HAS_MPFR
1219 /** \brief Post propagator for \f$ \mathrm{exp}(x_0)=x_1\f$
1220 */
1221 GECODE_FLOAT_EXPORT void
1222 exp(Home home, FloatVar x0, FloatVar x1);
1223 /** \brief Post propagator for \f$ \mathrm{log}_e(x_0)=x_1\f$
1224 */
1225 GECODE_FLOAT_EXPORT void
1226 log(Home home, FloatVar x0, FloatVar x1);
1227 /** \brief Post propagator for \f$ \mathit{base}^{x_0}=x_1\f$
1228 */
1229 GECODE_FLOAT_EXPORT void
1230 pow(Home home, FloatNum base, FloatVar x0, FloatVar x1);
1231 /** \brief Post propagator for \f$ \mathrm{log}_{\mathit{base}}(x_0)=x_1\f$
1232 */
1233 GECODE_FLOAT_EXPORT void
1234 log(Home home, FloatNum base, FloatVar x0, FloatVar x1);
1235 /** \brief Post propagator for \f$ \mathrm{asin}(x_0)=x_1\f$
1236 */
1237 GECODE_FLOAT_EXPORT void
1238 asin(Home home, FloatVar x0, FloatVar x1);
1239 /** \brief Post propagator for \f$ \mathrm{sin}(x_0)=x_1\f$
1240 */
1241 GECODE_FLOAT_EXPORT void
1242 sin(Home home, FloatVar x0, FloatVar x1);
1243 /** \brief Post propagator for \f$ \mathrm{acos}(x_0)=x_1\f$
1244 */
1245 GECODE_FLOAT_EXPORT void
1246 acos(Home home, FloatVar x0, FloatVar x1);
1247 /** \brief Post propagator for \f$ \mathrm{cos}(x_0)=x_1\f$
1248 */
1249 GECODE_FLOAT_EXPORT void
1250 cos(Home home, FloatVar x0, FloatVar x1);
1251 /** \brief Post propagator for \f$ \mathrm{atan}(x_0)=x_1\f$
1252 */
1253 GECODE_FLOAT_EXPORT void
1254 atan(Home home, FloatVar x0, FloatVar x1);
1255 /** \brief Post propagator for \f$ \mathrm{tan}(x_0)=x_1\f$
1256 */
1257 GECODE_FLOAT_EXPORT void
1258 tan(Home home, FloatVar x0, FloatVar x1);
1259 //@}
1260#endif
1261
1262 /**
1263 * \defgroup TaskModelFloatLI Linear constraints over float variables
1264 * \ingroup TaskModelFloat
1265 */
1266 /** \brief Post propagator for \f$\sum_{i=0}^{|x|-1}x_i\sim_{frt} c\f$
1267 *
1268 * \li Throws an exception of type Float::OutOfLimits, if the variables,
1269 * coefficients, or \a c exceed the limits as defined in Float::Limits.
1270 * \li Throws an exception of type Float::ValueMixedSign, if a
1271 * coefficient has mixed signs (that is, the lower bound is strictly
1272 * negative and the upper bound is strictly positive).
1273 *
1274 * \ingroup TaskModelFloatLI
1275 */
1276 GECODE_FLOAT_EXPORT void
1277 linear(Home home, const FloatVarArgs& x,
1278 FloatRelType frt, FloatVal c);
1279 /** \brief Post propagator for \f$\sum_{i=0}^{|x|-1}x_i\sim_{frt} y\f$
1280 * \ingroup TaskModelFloatLI
1281 *
1282 * \li Throws an exception of type Float::OutOfLimits, if the variables,
1283 * coefficients, or \a c exceed the limits as defined in Float::Limits.
1284 * \li Throws an exception of type Float::ValueMixedSign, if a
1285 * coefficient has mixed signs (that is, the lower bound is strictly
1286 * negative and the upper bound is strictly positive).
1287 *
1288 */
1289 GECODE_FLOAT_EXPORT void
1290 linear(Home home, const FloatVarArgs& x,
1291 FloatRelType frt, FloatVar y);
1292 /** \brief Post propagator for \f$\left(\sum_{i=0}^{|x|-1}x_i\sim_{frt} c\right)\equiv r\f$
1293 *
1294 * \li Throws an exception of type Float::OutOfLimits, if the variables,
1295 * coefficients, or \a c exceed the limits as defined in Float::Limits.
1296 * \li Throws an exception of type Float::ValueMixedSign, if a
1297 * coefficient has mixed signs (that is, the lower bound is strictly
1298 * negative and the upper bound is strictly positive).
1299 *
1300 * \ingroup TaskModelFloatLI
1301 */
1302 GECODE_FLOAT_EXPORT void
1303 linear(Home home, const FloatVarArgs& x,
1304 FloatRelType frt, FloatVal c, Reify r);
1305 /** \brief Post propagator for \f$\left(\sum_{i=0}^{|x|-1}x_i\sim_{frt} y\right)\equiv r\f$
1306 *
1307 * \li Throws an exception of type Float::OutOfLimits, if the variables,
1308 * coefficients, or \a c exceed the limits as defined in Float::Limits.
1309 * \li Throws an exception of type Float::ValueMixedSign, if a
1310 * coefficient has mixed signs (that is, the lower bound is strictly
1311 * negative and the upper bound is strictly positive).
1312 *
1313 * \ingroup TaskModelFloatLI
1314 */
1315 GECODE_FLOAT_EXPORT void
1316 linear(Home home, const FloatVarArgs& x,
1317 FloatRelType frt, FloatVar y, Reify r);
1318 /** \brief Post propagator for \f$\sum_{i=0}^{|x|-1}a_i\cdot x_i\sim_{frt} c\f$
1319 *
1320 * \li Throws an exception of type Float::ArgumentSizeMismatch, if
1321 * \a a and \a x are of different size.
1322 * \li Throws an exception of type Float::OutOfLimits, if the variables,
1323 * coefficients, or \a c exceed the limits as defined in Float::Limits.
1324 * \li Throws an exception of type Float::ValueMixedSign, if a
1325 * coefficient has mixed signs (that is, the lower bound is strictly
1326 * negative and the upper bound is strictly positive).
1327 *
1328 * \ingroup TaskModelFloatLI
1329 */
1330 GECODE_FLOAT_EXPORT void
1331 linear(Home home, const FloatValArgs& a, const FloatVarArgs& x,
1332 FloatRelType frt, FloatVal c);
1333 /** \brief Post propagator for \f$\sum_{i=0}^{|x|-1}a_i\cdot x_i\sim_{frt} y\f$
1334 *
1335 *
1336 * \li Throws an exception of type Float::ArgumentSizeMismatch, if
1337 * \a a and \a x are of different size.
1338 * \li Throws an exception of type Float::OutOfLimits, if the variables,
1339 * coefficients, or \a c exceed the limits as defined in Float::Limits.
1340 * \li Throws an exception of type Float::ValueMixedSign, if a
1341 * coefficient has mixed signs (that is, the lower bound is strictly
1342 * negative and the upper bound is strictly positive).
1343 *
1344 * \ingroup TaskModelFloatLI
1345 */
1346 GECODE_FLOAT_EXPORT void
1347 linear(Home home, const FloatValArgs& a, const FloatVarArgs& x,
1348 FloatRelType frt, FloatVar y);
1349 /** \brief Post propagator for \f$\left(\sum_{i=0}^{|x|-1}a_i\cdot x_i\sim_{frt} c\right)\equiv r\f$
1350 *
1351 *
1352 * \li Throws an exception of type Float::ArgumentSizeMismatch, if
1353 * \a a and \a x are of different size.
1354 * \li Throws an exception of type Float::OutOfLimits, if the variables,
1355 * coefficients, or \a c exceed the limits as defined in Float::Limits.
1356 * \li Throws an exception of type Float::ValueMixedSign, if a
1357 * coefficient has mixed signs (that is, the lower bound is strictly
1358 * negative and the upper bound is strictly positive).
1359 *
1360 * \ingroup TaskModelFloatLI
1361 */
1362 GECODE_FLOAT_EXPORT void
1363 linear(Home home, const FloatValArgs& a, const FloatVarArgs& x,
1364 FloatRelType frt, FloatVal c, Reify r);
1365 /** \brief Post propagator for \f$\left(\sum_{i=0}^{|x|-1}a_i\cdot x_i\sim_{frt} y\right)\equiv r\f$
1366 *
1367 *
1368 * \li Throws an exception of type Float::ArgumentSizeMismatch, if
1369 * \a a and \a x are of different size.
1370 * \li Throws an exception of type Float::OutOfLimits, if the variables,
1371 * coefficients, or \a c exceed the limits as defined in Float::Limits.
1372 * \li Throws an exception of type Float::ValueMixedSign, if a
1373 * coefficient has mixed signs (that is, the lower bound is strictly
1374 * negative and the upper bound is strictly positive).
1375 *
1376 * \ingroup TaskModelFloatLI
1377 */
1378 GECODE_FLOAT_EXPORT void
1379 linear(Home home, const FloatValArgs& a, const FloatVarArgs& x,
1380 FloatRelType frt, FloatVar y, Reify r);
1381
1382
1383 /**
1384 * \defgroup TaskModelFloatChannel Channel constraints
1385 * \ingroup TaskModelFloat
1386 */
1387 //@{
1388 /// Post propagator for channeling a float and an integer variable \f$ x_0 = x_1\f$
1389 GECODE_FLOAT_EXPORT void
1390 channel(Home home, FloatVar x0, IntVar x1);
1391 /// Post propagator for channeling a float and an integer variable \f$ x_0 = x_1\f$
1392 void
1393 channel(Home home, IntVar x0, FloatVar x1);
1394 /// Post propagator for channeling a float and a Boolean variable \f$ x_0 = x_1\f$
1395 GECODE_FLOAT_EXPORT void
1396 channel(Home home, FloatVar x0, BoolVar x1);
1397 /// Post propagator for channeling a float and a Boolean variable \f$ x_0 = x_1\f$
1398 void
1399 channel(Home home, BoolVar x0, FloatVar x1);
1400 //@}
1401
1402}
1403
1404#include <gecode/float/channel.hpp>
1405
1406namespace Gecode {
1407
1408 /**
1409 * \defgroup TaskModelFloatExec Synchronized execution
1410 * \ingroup TaskModelFloat
1411 *
1412 * Synchronized execution executes a function or a static member function
1413 * when a certain event happends.
1414 */
1415 //@{
1416 /// Execute \a c when \a x becomes assigned
1417 GECODE_FLOAT_EXPORT void
1418 wait(Home home, FloatVar x, std::function<void(Space& home)> c);
1419 /// Execute \a c when all variables in \a x become assigned
1420 GECODE_FLOAT_EXPORT void
1421 wait(Home home, const FloatVarArgs& x, std::function<void(Space& home)> c);
1422 //@}
1423
1424}
1425
1426namespace Gecode {
1427
1428 /**
1429 * \defgroup TaskModelFloatBranch Branching on float variables
1430 * \ingroup TaskModelFloat
1431 */
1432
1433 /**
1434 * \brief Branch filter function type for float variables
1435 *
1436 * The variable \a x is considered for selection and \a i refers to the
1437 * variable's position in the original array passed to the brancher.
1438 *
1439 * \ingroup TaskModelFloatBranch
1440 */
1441 typedef std::function<bool(const Space& home, FloatVar x, int i)>
1442 FloatBranchFilter;
1443
1444 /**
1445 * \brief Branch merit function type for float variables
1446 *
1447 * The function must return a merit value for the variable
1448 * \a x.
1449 * The value \a i refers to the variable's position in the original array
1450 * passed to the brancher.
1451 *
1452 * \ingroup TaskModelFloatBranch
1453 */
1454 typedef std::function<double(const Space& home, FloatVar x, int i)>
1455 FloatBranchMerit;
1456
1457 /**
1458 * \brief Value description class for branching
1459 *
1460 * \ingroup TaskModelFloatBranch
1461 */
1462 class FloatNumBranch {
1463 public:
1464 /// The middle value for branching
1465 FloatNum n;
1466 /// Whether to try the lower or upper half first
1467 bool l;
1468 };
1469
1470 /**
1471 * \brief Branch value function type for float variables
1472 *
1473 * Returns a value for the variable \a x that is to be used in the
1474 * corresponding branch commit function. The integer \a i refers
1475 * to the variable's position in the original array passed to the
1476 * brancher.
1477 *
1478 * \ingroup TaskModelFloatBranch
1479 */
1480 typedef std::function<FloatNumBranch(const Space& home, FloatVar x, int i)>
1481 FloatBranchVal;
1482
1483 /**
1484 * \brief Branch commit function type for float variables
1485 *
1486 * The function must post a constraint on the variable \a x which
1487 * corresponds to the alternative \a a. The integer \a i refers
1488 * to the variable's position in the original array passed to the
1489 * brancher. The value \a nl is the value description
1490 * computed by the corresponding branch value function.
1491 *
1492 * \ingroup TaskModelFloatBranch
1493 */
1494 typedef std::function<void(Space& home, unsigned int a,
1495 FloatVar x, int i, FloatNumBranch nl)>
1496 FloatBranchCommit;
1497
1498}
1499
1500#include <gecode/float/branch/traits.hpp>
1501
1502namespace Gecode {
1503
1504 /**
1505 * \brief Recording AFC information for float variables
1506 *
1507 * \ingroup TaskModelFloatBranch
1508 */
1509 class FloatAFC : public AFC {
1510 public:
1511 /**
1512 * \brief Construct as not yet initialized
1513 *
1514 * The only member functions that can be used on a constructed but not
1515 * yet initialized AFC storage is init or the assignment operator.
1516 *
1517 */
1518 FloatAFC(void);
1519 /// Copy constructor
1520 FloatAFC(const FloatAFC& a);
1521 /// Assignment operator
1522 FloatAFC& operator =(const FloatAFC& a);
1523 /**
1524 * \brief Initialize for float variables \a x and decay factor \a d
1525 *
1526 * If several AFC objects are created for a space or its clones,
1527 * the AFC values are shared between spaces. If the values should
1528 * not be shared, \a share should be false.
1529 */
1530 FloatAFC(Home home, const FloatVarArgs& x, double d=1.0, bool share=true);
1531 /**
1532 * \brief Initialize for float variables \a x with decay factor \a d
1533 *
1534 * This member function can only be used once and only if the
1535 * AFC storage has been constructed with the default constructor.
1536 *
1537 * If several AFC objects are created for a space or its clones,
1538 * the AFC values are shared between spaces. If the values should
1539 * not be shared, \a share should be false.
1540 */
1541 void init(Home home, const FloatVarArgs& x, double d=1.0, bool share=true);
1542 };
1543
1544}
1545
1546#include <gecode/float/branch/afc.hpp>
1547
1548namespace Gecode {
1549
1550 /**
1551 * \brief Recording actions for float variables
1552 *
1553 * \ingroup TaskModelFloatBranch
1554 */
1555 class FloatAction : public Action {
1556 public:
1557 /**
1558 * \brief Construct as not yet initialized
1559 *
1560 * The only member functions that can be used on a constructed but not
1561 * yet initialized action storage is init or the assignment operator.
1562 *
1563 */
1564 FloatAction(void);
1565 /// Copy constructor
1566 FloatAction(const FloatAction& a);
1567 /// Assignment operator
1568 FloatAction& operator =(const FloatAction& a);
1569 /**
1570 * \brief Initialize for float variables \a x with decay factor \a d
1571 *
1572 * Counts propagation if \a p is true and failure if \a f is true.
1573 *
1574 * If the branch merit function \a bm is different from nullptr, the
1575 * action for each variable is initialized with the merit returned
1576 * by \a bm.
1577 *
1578 */
1579 GECODE_FLOAT_EXPORT
1580 FloatAction(Home home, const FloatVarArgs& x, double d=1.0,
1581 bool p=true, bool f=true,
1582 FloatBranchMerit bm=nullptr);
1583 /**
1584 * \brief Initialize for float variables \a x with decay factor \a d
1585 *
1586 * Counts propagation if \a p is true and failure if \a f is true.
1587 *
1588 * If the branch merit function \a bm is different from nullptr, the
1589 * action for each variable is initialized with the merit returned
1590 * by \a bm.
1591 *
1592 * This member function can only be used once and only if the
1593 * action storage has been constructed with the default constructor.
1594 *
1595 */
1596 GECODE_FLOAT_EXPORT void
1597 init(Home home, const FloatVarArgs& x, double d=1.0,
1598 bool p=true, bool f=true,
1599 FloatBranchMerit bm=nullptr);
1600 };
1601
1602}
1603
1604#include <gecode/float/branch/action.hpp>
1605
1606namespace Gecode {
1607
1608 /**
1609 * \brief Recording CHB for float variables
1610 *
1611 * \ingroup TaskModelFloatBranch
1612 */
1613 class FloatCHB : public CHB {
1614 public:
1615 /**
1616 * \brief Construct as not yet initialized
1617 *
1618 * The only member functions that can be used on a constructed but not
1619 * yet initialized CHB storage is init or the assignment operator.
1620 *
1621 */
1622 FloatCHB(void);
1623 /// Copy constructor
1624 FloatCHB(const FloatCHB& chb);
1625 /// Assignment operator
1626 FloatCHB& operator =(const FloatCHB& chb);
1627 /**
1628 * \brief Initialize for float variables \a x
1629 *
1630 * If the branch merit function \a bm is different from nullptr, the
1631 * action for each variable is initialized with the merit returned
1632 * by \a bm.
1633 *
1634 */
1635 GECODE_FLOAT_EXPORT
1636 FloatCHB(Home home, const FloatVarArgs& x, FloatBranchMerit bm=nullptr);
1637 /**
1638 * \brief Initialize for float variables \a x
1639 *
1640 * If the branch merit function \a bm is different from nullptr, the
1641 * action for each variable is initialized with the merit returned
1642 * by \a bm.
1643 *
1644 * This member function can only be used once and only if the
1645 * action storage has been constructed with the default constructor.
1646 *
1647 */
1648 GECODE_FLOAT_EXPORT void
1649 init(Home home, const FloatVarArgs& x, FloatBranchMerit bm=nullptr);
1650 };
1651
1652}
1653
1654#include <gecode/float/branch/chb.hpp>
1655
1656namespace Gecode {
1657
1658 /// Function type for explaining branching alternatives for float variables
1659 typedef std::function<void(const Space &home, const Brancher& b,
1660 unsigned int a,
1661 FloatVar x, int i, const FloatNumBranch& n,
1662 std::ostream& o)>
1663 FloatVarValPrint;
1664
1665}
1666
1667namespace Gecode {
1668
1669 /**
1670 * \brief Which variable to select for branching
1671 *
1672 * \ingroup TaskModelFloatBranch
1673 */
1674 class FloatVarBranch : public VarBranch<FloatVar> {
1675 public:
1676 /// Which variable selection
1677 enum Select {
1678 SEL_NONE = 0, ///< First unassigned
1679 SEL_RND, ///< Random (uniform, for tie breaking)
1680 SEL_MERIT_MIN, ///< With least merit
1681 SEL_MERIT_MAX, ///< With highest merit
1682 SEL_DEGREE_MIN, ///< With smallest degree
1683 SEL_DEGREE_MAX, ///< With largest degree
1684 SEL_AFC_MIN, ///< With smallest accumulated failure count
1685 SEL_AFC_MAX, ///< With largest accumulated failure count
1686 SEL_ACTION_MIN, ///< With lowest action
1687 SEL_ACTION_MAX, ///< With highest action
1688 SEL_CHB_MIN, ///< With lowest CHB Q-score
1689 SEL_CHB_MAX, ///< With highest CHB Q-score
1690 SEL_MIN_MIN, ///< With smallest min
1691 SEL_MIN_MAX, ///< With largest min
1692 SEL_MAX_MIN, ///< With smallest max
1693 SEL_MAX_MAX, ///< With largest max
1694 SEL_SIZE_MIN, ///< With smallest domain size
1695 SEL_SIZE_MAX, ///< With largest domain size
1696 SEL_DEGREE_SIZE_MIN, ///< With smallest degree divided by domain size
1697 SEL_DEGREE_SIZE_MAX, ///< With largest degree divided by domain size
1698 SEL_AFC_SIZE_MIN, ///< With smallest accumulated failure count divided by domain size
1699 SEL_AFC_SIZE_MAX, ///< With largest accumulated failure count divided by domain size
1700 SEL_ACTION_SIZE_MIN, ///< With smallest action divided by domain size
1701 SEL_ACTION_SIZE_MAX, ///< With largest action divided by domain size
1702 SEL_CHB_SIZE_MIN, ///< With smallest CHB Q-score divided by domain size
1703 SEL_CHB_SIZE_MAX ///< With largest CHB Q-score divided by domain size
1704 };
1705 protected:
1706 /// Which variable to select
1707 Select s;
1708 public:
1709 /// Initialize with strategy SEL_NONE
1710 FloatVarBranch(void);
1711 /// Initialize with random number generator \a r
1712 FloatVarBranch(Rnd r);
1713 /// Initialize with selection strategy \a s and tie-break limit function \a t
1714 FloatVarBranch(Select s, BranchTbl t);
1715 /// Initialize with selection strategy \a s, decay factor \a d, and tie-break limit function \a t
1716 FloatVarBranch(Select s, double, BranchTbl t);
1717 /// Initialize with selection strategy \a s, AFC \a a, and tie-break limit function \a t
1718 FloatVarBranch(Select s, FloatAFC a, BranchTbl t);
1719 /// Initialize with selection strategy \a s, action \a a, and tie-break limit function \a t
1720 FloatVarBranch(Select s, FloatAction a, BranchTbl t);
1721 /// Initialize with selection strategy \a s, CHB \a c, and tie-break limit function \a t
1722 FloatVarBranch(Select s, FloatCHB c, BranchTbl t);
1723 /// Initialize with selection strategy \a s, branch merit function \a mf, and tie-break limit function \a t
1724 FloatVarBranch(Select s, FloatBranchMerit mf, BranchTbl t);
1725 /// Return selection strategy
1726 Select select(void) const;
1727 /// Expand AFC, action, and CHB
1728 void expand(Home home, const FloatVarArgs& x);
1729 };
1730
1731
1732 /**
1733 * \defgroup TaskModelFloatBranchVar Variable selection for float variables
1734 * \ingroup TaskModelFloatBranch
1735 */
1736 //@{
1737 /// Select first unassigned variable
1738 FloatVarBranch FLOAT_VAR_NONE(void);
1739 /// Select random variable (uniform distribution, for tie breaking)
1740 FloatVarBranch FLOAT_VAR_RND(Rnd r);
1741 /// Select variable with least merit according to branch merit function \a bm
1742 FloatVarBranch FLOAT_VAR_MERIT_MIN(FloatBranchMerit bm, BranchTbl tbl=nullptr);
1743 /// Select variable with highest merit according to branch merit function \a bm
1744 FloatVarBranch FLOAT_VAR_MERIT_MAX(FloatBranchMerit bm, BranchTbl tbl=nullptr);
1745 /// Select variable with smallest degree
1746 FloatVarBranch FLOAT_VAR_DEGREE_MIN(BranchTbl tbl=nullptr);
1747 /// Select variable with largest degree
1748 FloatVarBranch FLOAT_VAR_DEGREE_MAX(BranchTbl tbl=nullptr);
1749 /// Select variable with smallest accumulated failure count with decay factor \a d
1750 FloatVarBranch FLOAT_VAR_AFC_MIN(double d=1.0, BranchTbl tbl=nullptr);
1751 /// Select variable with smallest accumulated failure count
1752 FloatVarBranch FLOAT_VAR_AFC_MIN(FloatAFC a, BranchTbl tbl=nullptr);
1753 /// Select variable with largest accumulated failure count with decay factor \a d
1754 FloatVarBranch FLOAT_VAR_AFC_MAX(double d=1.0, BranchTbl tbl=nullptr);
1755 /// Select variable with largest accumulated failure count
1756 FloatVarBranch FLOAT_VAR_AFC_MAX(FloatAFC a, BranchTbl tbl=nullptr);
1757 /// Select variable with lowest action with decay factor \a d
1758 FloatVarBranch FLOAT_VAR_ACTION_MIN(double d=1.0, BranchTbl tbl=nullptr);
1759 /// Select variable with lowest action
1760 FloatVarBranch FLOAT_VAR_ACTION_MIN(FloatAction a, BranchTbl tbl=nullptr);
1761 /// Select variable with highest action with decay factor \a d
1762 FloatVarBranch FLOAT_VAR_ACTION_MAX(double d=1.0, BranchTbl tbl=nullptr);
1763 /// Select variable with highest action
1764 FloatVarBranch FLOAT_VAR_ACTION_MAX(FloatAction a, BranchTbl tbl=nullptr);
1765 /// Select variable with lowest CHB Q-score
1766 FloatVarBranch FLOAT_VAR_CHB_MIN(BranchTbl tbl=nullptr);
1767 /// Select variable with lowest CHB Q-score
1768 FloatVarBranch FLOAT_VAR_CHB_MIN(FloatCHB a, BranchTbl tbl=nullptr);
1769 /// Select variable with highest CHB Q-score
1770 FloatVarBranch FLOAT_VAR_CHB_MAX(BranchTbl tbl=nullptr);
1771 /// Select variable with highest CHB Q-score
1772 FloatVarBranch FLOAT_VAR_CHB_MAX(FloatCHB a, BranchTbl tbl=nullptr);
1773 /// Select variable with smallest min
1774 FloatVarBranch FLOAT_VAR_MIN_MIN(BranchTbl tbl=nullptr);
1775 /// Select variable with largest min
1776 FloatVarBranch FLOAT_VAR_MIN_MAX(BranchTbl tbl=nullptr);
1777 /// Select variable with smallest max
1778 FloatVarBranch FLOAT_VAR_MAX_MIN(BranchTbl tbl=nullptr);
1779 /// Select variable with largest max
1780 FloatVarBranch FLOAT_VAR_MAX_MAX(BranchTbl tbl=nullptr);
1781 /// Select variable with smallest domain size
1782 FloatVarBranch FLOAT_VAR_SIZE_MIN(BranchTbl tbl=nullptr);
1783 /// Select variable with largest domain size
1784 FloatVarBranch FLOAT_VAR_SIZE_MAX(BranchTbl tbl=nullptr);
1785 /// Select variable with smallest degree divided by domain size
1786 FloatVarBranch FLOAT_VAR_DEGREE_SIZE_MIN(BranchTbl tbl=nullptr);
1787 /// Select variable with largest degree divided by domain size
1788 FloatVarBranch FLOAT_VAR_DEGREE_SIZE_MAX(BranchTbl tbl=nullptr);
1789 /// Select variable with smalllest accumulated failure count divided by domain size with decay factor \a d
1790 FloatVarBranch FLOAT_VAR_AFC_SIZE_MIN(double d=1.0, BranchTbl tbl=nullptr);
1791 /// Select variable with smallest accumulated failure count divided by domain size
1792 FloatVarBranch FLOAT_VAR_AFC_SIZE_MIN(FloatAFC a, BranchTbl tbl=nullptr);
1793 /// Select variable with largest accumulated failure count divided by domain size with decay factor \a d
1794 FloatVarBranch FLOAT_VAR_AFC_SIZE_MAX(double d=1.0, BranchTbl tbl=nullptr);
1795 /// Select variable with largest accumulated failure count divided by domain size
1796 FloatVarBranch FLOAT_VAR_AFC_SIZE_MAX(FloatAFC a, BranchTbl tbl=nullptr);
1797 /// Select variable with smallest action divided by domain size with decay factor \a d
1798 FloatVarBranch FLOAT_VAR_ACTION_SIZE_MIN(double d=1.0, BranchTbl tbl=nullptr);
1799 /// Select variable with smallest action divided by domain size
1800 FloatVarBranch FLOAT_VAR_ACTION_SIZE_MIN(FloatAction a, BranchTbl tbl=nullptr);
1801 /// Select variable with largest action divided by domain size with decay factor \a d
1802 FloatVarBranch FLOAT_VAR_ACTION_SIZE_MAX(double d=1.0, BranchTbl tbl=nullptr);
1803 /// Select variable with largest action divided by domain size
1804 FloatVarBranch FLOAT_VAR_ACTION_SIZE_MAX(FloatAction a, BranchTbl tbl=nullptr);
1805 /// Select variable with smallest CHB Q-score divided by domain size
1806 FloatVarBranch FLOAT_VAR_CHB_SIZE_MIN(BranchTbl tbl=nullptr);
1807 /// Select variable with smallest CHB Q-score divided by domain size
1808 FloatVarBranch FLOAT_VAR_CHB_SIZE_MIN(FloatCHB c, BranchTbl tbl=nullptr);
1809 /// Select variable with largest CHB Q-score divided by domain size
1810 FloatVarBranch FLOAT_VAR_CHB_SIZE_MAX(BranchTbl tbl=nullptr);
1811 /// Select variable with largest CHB Q-score divided by domain size
1812 FloatVarBranch FLOAT_VAR_CHB_SIZE_MAX(FloatCHB a, BranchTbl tbl=nullptr);
1813 //@}
1814
1815}
1816
1817#include <gecode/float/branch/var.hpp>
1818
1819namespace Gecode {
1820
1821 /**
1822 * \brief Which values to select for branching first
1823 *
1824 * \ingroup TaskModelFloatBranch
1825 */
1826 class FloatValBranch : public ValBranch<FloatVar> {
1827 public:
1828 /// Which value selection
1829 enum Select {
1830 SEL_SPLIT_MIN, ///< Select values not greater than mean of smallest and largest value
1831 SEL_SPLIT_MAX, ///< Select values greater than mean of smallest and largest value
1832 SEL_SPLIT_RND, ///< Select values randomly which are not greater or not smaller than mean of largest and smallest value
1833 SEL_VAL_COMMIT ///< Select value according to user-defined functions
1834 };
1835 protected:
1836 /// Which value to select
1837 Select s;
1838 public:
1839 /// Initialize with selection strategy \a s
1840 FloatValBranch(Select s = SEL_SPLIT_MIN);
1841 /// Initialize with random number generator \a r
1842 FloatValBranch(Rnd r);
1843 /// Initialize with value function \a f and commit function \a c
1844 FloatValBranch(FloatBranchVal v, FloatBranchCommit c);
1845 /// Return selection strategy
1846 Select select(void) const;
1847 };
1848
1849 /**
1850 * \defgroup TaskModelFloatBranchVal Value selection for float variables
1851 * \ingroup TaskModelFloatBranch
1852 */
1853 //@{
1854 /// Select values not greater than mean of smallest and largest value
1855 FloatValBranch FLOAT_VAL_SPLIT_MIN(void);
1856 /// Select values greater than mean of smallest and largest value
1857 FloatValBranch FLOAT_VAL_SPLIT_MAX(void);
1858 /// Select values randomly which are not greater or not smaller than mean of largest and smallest value
1859 FloatValBranch FLOAT_VAL_SPLIT_RND(Rnd r);
1860 /**
1861 * Select value as defined by the value function \a v and commit function \a c
1862 * The default commit function posts the constraint that the float variable
1863 * \a x must be less or equal than the value \a n for the first
1864 * alternative and that \a x must be greater or equal than \a n otherwise.
1865 */
1866 FloatValBranch FLOAT_VAL(FloatBranchVal v, FloatBranchCommit c=nullptr);
1867 //@}
1868
1869}
1870
1871#include <gecode/float/branch/val.hpp>
1872
1873namespace Gecode {
1874
1875 /**
1876 * \brief Which values to select for assignment
1877 *
1878 * \ingroup TaskModelFloatBranch
1879 */
1880 class FloatAssign : public ValBranch<FloatVar> {
1881 public:
1882 /// Which value selection
1883 enum Select {
1884 SEL_MIN, ///< Select median value of the lower part
1885 SEL_MAX, ///< Select median value of the upper part
1886 SEL_RND, ///< Select median value of a randomly chosen part
1887 SEL_VAL_COMMIT ///< Select value according to user-defined functions
1888 };
1889 protected:
1890 /// Which value to select
1891 Select s;
1892 public:
1893 /// Initialize with selection strategy \a s
1894 FloatAssign(Select s = SEL_MIN);
1895 /// Initialize with random number generator \a r
1896 FloatAssign(Rnd r);
1897 /// Initialize with value function \a f and commit function \a c
1898 FloatAssign(FloatBranchVal v, FloatBranchCommit c);
1899 /// Return selection strategy
1900 Select select(void) const;
1901 };
1902
1903 /**
1904 * \defgroup TaskModelFloatBranchAssign Value selection for assigning float variables
1905 * \ingroup TaskModelFloatBranch
1906 */
1907 //@{
1908 /// Select median value of the lower part
1909 FloatAssign FLOAT_ASSIGN_MIN(void);
1910 /// Select median value of the upper part
1911 FloatAssign FLOAT_ASSIGN_MAX(void);
1912 /// Select median value of a randomly chosen part
1913 FloatAssign FLOAT_ASSIGN_RND(Rnd r);
1914 /**
1915 * Select value as defined by the value function \a v and commit function \a c
1916 * The default commit function posts the constraint that the float variable
1917 * \a x must be less or equal than the value \a n.
1918 */
1919 FloatAssign FLOAT_ASSIGN(FloatBranchVal v, FloatBranchCommit c=nullptr);
1920 //@}
1921
1922}
1923
1924#include <gecode/float/branch/assign.hpp>
1925
1926namespace Gecode {
1927
1928 /**
1929 * \brief Branch over \a x with variable selection \a vars and value selection \a vals
1930 *
1931 * \ingroup TaskModelFloatBranch
1932 */
1933 GECODE_FLOAT_EXPORT void
1934 branch(Home home, const FloatVarArgs& x,
1935 FloatVarBranch vars, FloatValBranch vals,
1936 FloatBranchFilter bf=nullptr,
1937 FloatVarValPrint vvp=nullptr);
1938 /**
1939 * \brief Branch over \a x with tie-breaking variable selection \a vars and value selection \a vals
1940 *
1941 * \ingroup TaskModelFloatBranch
1942 */
1943 GECODE_FLOAT_EXPORT void
1944 branch(Home home, const FloatVarArgs& x,
1945 TieBreak<FloatVarBranch> vars, FloatValBranch vals,
1946 FloatBranchFilter bf=nullptr,
1947 FloatVarValPrint vvp=nullptr);
1948 /**
1949 * \brief Branch over \a x with value selection \a vals
1950 *
1951 * \ingroup TaskModelFloatBranch
1952 */
1953 GECODE_FLOAT_EXPORT void
1954 branch(Home home, FloatVar x, FloatValBranch vals,
1955 FloatVarValPrint vvp=nullptr);
1956
1957 /**
1958 * \brief Assign all \a x with variable selection \a vars and value selection \a vals
1959 *
1960 * \ingroup TaskModelFloatBranch
1961 */
1962 GECODE_FLOAT_EXPORT void
1963 assign(Home home, const FloatVarArgs& x,
1964 FloatVarBranch vars, FloatAssign vals,
1965 FloatBranchFilter bf=nullptr,
1966 FloatVarValPrint vvp=nullptr);
1967 /**
1968 * \brief Assign all \a x with tie-breaking variable selection \a vars and value selection \a vals
1969 *
1970 * \ingroup TaskModelFloatBranch
1971 */
1972 GECODE_FLOAT_EXPORT void
1973 assign(Home home, const FloatVarArgs& x,
1974 TieBreak<FloatVarBranch> vars, FloatAssign vals,
1975 FloatBranchFilter bf=nullptr,
1976 FloatVarValPrint vvp=nullptr);
1977 /**
1978 * \brief Assign \a x with value selection \a vals
1979 *
1980 * \ingroup TaskModelFloatBranch
1981 */
1982 GECODE_FLOAT_EXPORT void
1983 assign(Home home, FloatVar x, FloatAssign vals,
1984 FloatVarValPrint vvp=nullptr);
1985
1986}
1987
1988namespace Gecode {
1989
1990 /**
1991 * \brief Branch over \a x with value selection \a vals
1992 *
1993 * \ingroup TaskModelFloatBranch
1994 */
1995 void
1996 branch(Home home, const FloatVarArgs& x, FloatValBranch vals,
1997 FloatBranchFilter bf=nullptr,
1998 FloatVarValPrint vvp=nullptr);
1999 /**
2000 * \brief Assign all \a x with value selection \a vals
2001 *
2002 * \ingroup TaskModelFloatBranch
2003 */
2004 void
2005 assign(Home home, const FloatVarArgs& x, FloatAssign vals,
2006 FloatBranchFilter bf=nullptr,
2007 FloatVarValPrint vvp=nullptr);
2008
2009}
2010
2011#include <gecode/float/branch.hpp>
2012
2013namespace Gecode {
2014
2015 /*
2016 * \brief Relaxed assignment of variables in \a x from values in \a sx
2017 *
2018 * The variables in \a x are assigned values from the assigned variables
2019 * in the solution \a sx with a relaxation probability \a p. That is,
2020 * if \f$p=0.1\f$ approximately 10% of the variables in \a x will be
2021 * assigned a value from \a sx.
2022 *
2023 * The random numbers are generated from the generator \a r. At least
2024 * one variable will not be assigned: in case the relaxation attempt
2025 * would suggest that all variables should be assigned, a single
2026 * variable will be selected randomly to remain unassigned.
2027 *
2028 * Throws an exception of type Float::ArgumentSizeMismatch, if \a x and
2029 * \a sx are of different size.
2030 *
2031 * Throws an exception of type Float::OutOfLimits, if \a p is not between
2032 * \a 0.0 and \a 1.0.
2033 *
2034 * \ingroup TaskModeFloat
2035 */
2036 GECODE_FLOAT_EXPORT void
2037 relax(Home home, const FloatVarArgs& x, const FloatVarArgs& sx,
2038 Rnd r, double p);
2039
2040}
2041
2042#include <gecode/float/trace/trace-view.hpp>
2043
2044namespace Gecode {
2045
2046 /**
2047 * \defgroup TaskFloatTrace Tracing for float variables
2048 * \ingroup TaskTrace
2049 */
2050
2051 /**
2052 * \brief Trace delta information for float variables
2053 * \ingroup TaskFloatTrace
2054 */
2055 class FloatTraceDelta {
2056 protected:
2057 /// New view
2058 Float::FloatView n;
2059 /// Delta information
2060 const Delta& d;
2061 public:
2062 /// \name Constructor
2063 //@{
2064 /// Initialize with old trace view \a o, new view \a n, and delta \a d
2065 FloatTraceDelta(Float::FloatTraceView o, Float::FloatView n,
2066 const Delta& d);
2067 //@}
2068 /// \name Access
2069 //@{
2070 /// Return minimum
2071 FloatNum min(void) const;
2072 /// Return maximum
2073 FloatNum max(void) const;
2074 //@}
2075 };
2076
2077}
2078
2079#include <gecode/float/trace/delta.hpp>
2080
2081#include <gecode/float/trace/traits.hpp>
2082
2083namespace Gecode {
2084
2085 /**
2086 * \brief Tracer for float variables
2087 * \ingroup TaskFloatTrace
2088 */
2089 typedef ViewTracer<Float::FloatView> FloatTracer;
2090 /**
2091 * \brief Trace recorder for float variables
2092 * \ingroup TaskFloatTrace
2093 */
2094 typedef ViewTraceRecorder<Float::FloatView> FloatTraceRecorder;
2095
2096 /**
2097 * \brief Standard float variable tracer
2098 * \ingroup TaskFloatTrace
2099 */
2100 class GECODE_FLOAT_EXPORT StdFloatTracer : public FloatTracer {
2101 protected:
2102 /// Output stream to use
2103 std::ostream& os;
2104 public:
2105 /// Initialize with output stream \a os0
2106 StdFloatTracer(std::ostream& os0 = std::cerr);
2107 /// Print init information
2108 virtual void init(const Space& home, const FloatTraceRecorder& t);
2109 /// Print prune information
2110 virtual void prune(const Space& home, const FloatTraceRecorder& t,
2111 const ViewTraceInfo& vti, int i, FloatTraceDelta& d);
2112 /// Print fixpoint information
2113 virtual void fix(const Space& home, const FloatTraceRecorder& t);
2114 /// Print failure information
2115 virtual void fail(const Space& home, const FloatTraceRecorder& t);
2116 /// Print that trace recorder is done
2117 virtual void done(const Space& home, const FloatTraceRecorder& t);
2118 /// Default tracer (printing to std::cerr)
2119 static StdFloatTracer def;
2120 };
2121
2122
2123 /**
2124 * \brief Create a tracer for float variables
2125 * \ingroup TaskFloatTrace
2126 */
2127 GECODE_FLOAT_EXPORT void
2128 trace(Home home, const FloatVarArgs& x,
2129 TraceFilter tf,
2130 int te = (TE_INIT | TE_PRUNE | TE_FIX | TE_FAIL | TE_DONE),
2131 FloatTracer& t = StdFloatTracer::def);
2132 /**
2133 * \brief Create a tracer for float variables
2134 * \ingroup TaskFloatTrace
2135 */
2136 void
2137 trace(Home home, const FloatVarArgs& x,
2138 int te = (TE_INIT | TE_PRUNE | TE_FIX | TE_FAIL | TE_DONE),
2139 FloatTracer& t = StdFloatTracer::def);
2140
2141}
2142
2143#include <gecode/float/trace.hpp>
2144
2145#endif
2146
2147// IFDEF: GECODE_HAS_FLOAT_VARS
2148// STATISTICS: float-post
2149