Generated on Tue Oct 22 2013 00:48:59 for Gecode by doxygen 1.8.4
float.hh
Go to the documentation of this file.
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  * Last modified:
14  * $Date: 2013-05-29 13:53:43 +0200 (Wed, 29 May 2013) $ by $Author: schulte $
15  * $Revision: 13672 $
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 #ifndef __GECODE_FLOAT_HH__
43 #define __GECODE_FLOAT_HH__
44 
45 #include <climits>
46 #include <cfloat>
47 #include <iostream>
48 
49 #include <gecode/kernel.hh>
50 #include <gecode/int.hh>
51 
52 /*
53  * Configure linking
54  *
55  */
56 #if !defined(GECODE_STATIC_LIBS) && \
57  (defined(__CYGWIN__) || defined(__MINGW32__) || defined(_MSC_VER))
58 
59 #ifdef GECODE_BUILD_FLOAT
60 #define GECODE_FLOAT_EXPORT __declspec( dllexport )
61 #else
62 #define GECODE_FLOAT_EXPORT __declspec( dllimport )
63 #endif
64 
65 #else
66 
67 #ifdef GECODE_GCC_HAS_CLASS_VISIBILITY
68 #define GECODE_FLOAT_EXPORT __attribute__ ((visibility("default")))
69 #else
70 #define GECODE_FLOAT_EXPORT
71 #endif
72 
73 #endif
74 
75 // Configure auto-linking
76 #ifndef GECODE_BUILD_FLOAT
77 #define GECODE_LIBRARY_NAME "Float"
79 #endif
80 
81 // Include interval implementation
82 #include <gecode/third-party/boost/numeric/interval.hpp>
83 
96 
98 
99 namespace Gecode {
100 
108  typedef double FloatNum;
109 
111  FloatNum pi_half_lower(void);
113  FloatNum pi_half_upper(void);
115  FloatNum pi_lower(void);
117  FloatNum pi_upper(void);
119  FloatNum pi_twice_lower(void);
121  FloatNum pi_twice_upper(void);
122 
123  // Forward declaration
124  class FloatVal;
125 
126 }
127 
128 #include <gecode/float/num.hpp>
129 
130 namespace Gecode { namespace Float {
131 
137  class Rounding :
138  public boost::numeric::interval_lib::rounded_arith_opp<FloatNum> {
139  protected:
141  typedef boost::numeric::interval_lib::rounded_arith_opp<FloatNum> Base;
142  public:
144 
145  Rounding(void);
148  ~Rounding(void);
150 
152 
174 
176 
184 
185 #ifdef GECODE_HAS_MPFR
186 
197 
199 
213 
215 
229 
231 
245 
247 
261 #endif
262  };
263 
264 }}
265 
266 #include <gecode/float/rounding.hpp>
267 
268 namespace Gecode { namespace Float {
269 
274  bool subset(const FloatVal& x, const FloatVal& y);
279  bool proper_subset(const FloatVal& x, const FloatVal& y);
284  bool overlap(const FloatVal& x, const FloatVal& y);
285 
290  FloatVal intersect(const FloatVal& x, const FloatVal& y);
295  FloatVal hull(const FloatVal& x, const FloatVal& y);
300  FloatVal hull(const FloatVal& x, const FloatNum& y);
305  FloatVal hull(const FloatNum& x, const FloatVal& y);
310  FloatVal hull(const FloatNum& x, const FloatNum& y);
311 
312 }}
313 
314 namespace Gecode {
315 
321  class FloatVal {
322  friend FloatVal operator +(const FloatVal& x);
323  friend FloatVal operator -(const FloatVal& x);
324  friend FloatVal operator +(const FloatVal& x, const FloatVal& y);
325  friend FloatVal operator +(const FloatVal& x, const FloatNum& y);
326  friend FloatVal operator +(const FloatNum& x, const FloatVal& y);
327  friend FloatVal operator -(const FloatVal& x, const FloatVal& y);
328  friend FloatVal operator -(const FloatVal& x, const FloatNum& y);
329  friend FloatVal operator -(const FloatNum& x, const FloatVal& y);
330  friend FloatVal operator *(const FloatVal& x, const FloatVal& y);
331  friend FloatVal operator *(const FloatVal& x, const FloatNum& y);
332  friend FloatVal operator *(const FloatNum& x, const FloatVal& y);
333  friend FloatVal operator /(const FloatVal& x, const FloatVal& y);
334  friend FloatVal operator /(const FloatVal& x, const FloatNum& y);
335  friend FloatVal operator /(const FloatNum& x, const FloatVal& y);
336 
337  friend bool operator <(const FloatVal& x, const FloatVal& y);
338  friend bool operator <(const FloatVal& x, const FloatNum& y);
339  friend bool operator <(const FloatNum& x, const FloatVal& y);
340  friend bool operator <=(const FloatVal& x, const FloatVal& y);
341  friend bool operator <=(const FloatVal& x, const FloatNum& y);
342  friend bool operator <=(const FloatNum& x, const FloatVal& y);
343  friend bool operator >(const FloatVal& x, const FloatVal& y);
344  friend bool operator >(const FloatVal& x, const FloatNum& y);
345  friend bool operator >(const FloatNum& x, const FloatVal& y);
346  friend bool operator >=(const FloatVal& x, const FloatVal& y);
347  friend bool operator >=(const FloatVal& x, const FloatNum& y);
348  friend bool operator >=(const FloatNum& x, const FloatVal& y);
349  friend bool operator ==(const FloatVal& x, const FloatVal& y);
350  friend bool operator ==(const FloatVal& x, const FloatNum& y);
351  friend bool operator ==(const FloatNum& x, const FloatVal& y);
352  friend bool operator !=(const FloatVal& x, const FloatVal& y);
353  friend bool operator !=(const FloatVal& x, const FloatNum& y);
354  friend bool operator !=(const FloatNum& x, const FloatVal& y);
355 
356  template<class Char, class Traits>
357  friend std::basic_ostream<Char,Traits>&
358  operator <<(std::basic_ostream<Char,Traits>& os, const FloatVal& x);
359 
360  friend FloatVal abs(const FloatVal& x);
361  friend FloatVal sqrt(const FloatVal& x);
362  friend FloatVal sqr(const FloatVal& x);
363  friend FloatVal pow(const FloatVal& x, int n);
364  friend FloatVal nroot(const FloatVal& x, int n);
365 
366  friend FloatVal max(const FloatVal& x, const FloatVal& y);
367  friend FloatVal max(const FloatVal& x, const FloatNum& y);
368  friend FloatVal max(const FloatNum& x, const FloatVal& y);
369  friend FloatVal min(const FloatVal& x, const FloatVal& y);
370  friend FloatVal min(const FloatVal& x, const FloatNum& y);
371  friend FloatVal min(const FloatNum& x, const FloatVal& y);
372 
373 #ifdef GECODE_HAS_MPFR
374  friend FloatVal exp(const FloatVal& x);
375  friend FloatVal log(const FloatVal& x);
376  friend FloatVal fmod(const FloatVal& x, const FloatVal& y);
377  friend FloatVal fmod(const FloatVal& x, const FloatNum& y);
378  friend FloatVal fmod(const FloatNum& x, const FloatVal& y);
379  friend FloatVal sin(const FloatVal& x);
380  friend FloatVal cos(const FloatVal& x);
381  friend FloatVal tan(const FloatVal& x);
382  friend FloatVal asin(const FloatVal& x);
383  friend FloatVal acos(const FloatVal& x);
384  friend FloatVal atan(const FloatVal& x);
385  friend FloatVal sinh(const FloatVal& x);
386  friend FloatVal cosh(const FloatVal& x);
387  friend FloatVal tanh(const FloatVal& x);
388  friend FloatVal asinh(const FloatVal& x);
389  friend FloatVal acosh(const FloatVal& x);
390  friend FloatVal atanh(const FloatVal& x);
391 #endif
392 
393  friend bool Float::subset(const FloatVal& x, const FloatVal& y);
394  friend bool Float::proper_subset(const FloatVal& x, const FloatVal& y);
395  friend bool Float::overlap(const FloatVal& x, const FloatVal& y);
396  friend FloatVal Float::intersect(const FloatVal& x, const FloatVal& y);
397  friend FloatVal Float::hull(const FloatVal& x, const FloatVal& y);
398  friend FloatVal Float::hull(const FloatVal& x, const FloatNum& y);
399  friend FloatVal Float::hull(const FloatNum& x, const FloatVal& y);
400  friend FloatVal Float::hull(const FloatNum& x, const FloatNum& y);
401  protected:
403  typedef boost::numeric::interval_lib::save_state<Float::Rounding> R;
405  typedef boost::numeric::interval_lib::checking_strict<FloatNum> P;
407  typedef boost::numeric::interval
408  <FloatNum,
409  boost::numeric::interval_lib::policies<R, P> >
414  explicit FloatVal(const FloatValImpType& i);
415  public:
417 
418  FloatVal(void);
421  FloatVal(const FloatNum& n);
423  FloatVal(const FloatNum& l, const FloatNum& u);
425  FloatVal(const FloatVal& v);
426 
428  FloatVal& operator =(const FloatNum& n);
430  FloatVal& operator =(const FloatVal& v);
431 
433  void assign(FloatNum const &l, FloatNum const &u);
435 
437 
438  FloatNum min(void) const;
441  FloatNum max(void) const;
443  FloatNum size(void) const;
445  FloatNum med(void) const;
447 
449 
450  bool tight(void) const;
453  bool singleton(void) const;
455  bool in(FloatNum n) const;
457  bool zero_in(void) const;
459 
461 
462  static FloatVal hull(FloatNum x, FloatNum y);
465  static FloatVal pi_half(void);
467  static FloatVal pi(void);
469  static FloatVal pi_twice(void);
471 
473 
474  FloatVal& operator +=(const FloatNum& n);
477  FloatVal& operator -=(const FloatNum& n);
479  FloatVal& operator *=(const FloatNum& n);
481  FloatVal& operator /=(const FloatNum& n);
483  FloatVal& operator +=(const FloatVal& v);
485  FloatVal& operator -=(const FloatVal& v);
487  FloatVal& operator *=(const FloatVal& v);
489  FloatVal& operator /=(const FloatVal& v);
491  };
492 
497  FloatVal operator +(const FloatVal& x);
502  FloatVal operator -(const FloatVal& x);
503 
508  FloatVal operator +(const FloatVal& x, const FloatVal& y);
513  FloatVal operator +(const FloatVal& x, const FloatNum& y);
518  FloatVal operator +(const FloatNum& x, const FloatVal& y);
523  FloatVal operator -(const FloatVal& x, const FloatVal& y);
528  FloatVal operator -(const FloatVal& x, const FloatNum& y);
533  FloatVal operator -(const FloatNum& x, const FloatVal& y);
538  FloatVal operator *(const FloatVal& x, const FloatVal& y);
543  FloatVal operator *(const FloatVal& x, const FloatNum& y);
548  FloatVal operator *(const FloatNum& x, const FloatVal& y);
553  FloatVal operator /(const FloatVal& x, const FloatVal& y);
558  FloatVal operator /(const FloatVal& x, const FloatNum& y);
563  FloatVal operator /(const FloatNum& r, const FloatVal& x);
564 
569  bool operator <(const FloatVal& x, const FloatVal& y);
574  bool operator <(const FloatVal& x, const FloatNum& y);
579  bool operator <(const FloatNum& x, const FloatVal& y);
580 
585  bool operator <=(const FloatVal& x, const FloatVal& y);
590  bool operator <=(const FloatVal& x, const FloatNum& y);
595  bool operator <=(const FloatNum& x, const FloatVal& y);
596 
601  bool operator >(const FloatVal& x, const FloatVal& y);
606  bool operator >(const FloatVal& x, const FloatNum& y);
611  bool operator >(const FloatNum& x, const FloatVal& y);
612 
617  bool operator >=(const FloatVal& x, const FloatVal& y);
622  bool operator >=(const FloatVal& x, const FloatNum& y);
627  bool operator >=(const FloatNum& x, const FloatVal& y);
632  bool operator ==(const FloatVal& x, const FloatVal& y);
637  bool operator ==(const FloatVal& x, const FloatNum& y);
642  bool operator ==(const FloatNum& x, const FloatVal& y);
643 
648  bool operator !=(const FloatVal& x, const FloatVal& y);
653  bool operator !=(const FloatVal& x, const FloatNum& y);
658  bool operator !=(const FloatNum& x, const FloatVal& y);
659 
664  template<class Char, class Traits>
665  std::basic_ostream<Char,Traits>&
666  operator <<(std::basic_ostream<Char,Traits>& os, const FloatVal& x);
667 
672  FloatVal abs(const FloatVal& x);
677  FloatVal sqrt(const FloatVal& x);
682  FloatVal sqr(const FloatVal& x);
687  FloatVal pow(const FloatVal& x, int n);
692  FloatVal nroot(const FloatVal& x, int n);
693 
698  FloatVal max(const FloatVal& x, const FloatVal& y);
703  FloatVal max(const FloatVal& x, const FloatNum& y);
708  FloatVal max(const FloatNum& x, const FloatVal& y);
713  FloatVal min(const FloatVal& x, const FloatVal& y);
718  FloatVal min(const FloatVal& x, const FloatNum& y);
723  FloatVal min(const FloatNum& x, const FloatVal& y);
724 
725 #ifdef GECODE_HAS_MPFR
726  /* transcendental functions: exp, log */
731  FloatVal exp(const FloatVal& x);
736  FloatVal log(const FloatVal& x);
737 
742  FloatVal fmod(const FloatVal& x, const FloatVal& y);
747  FloatVal fmod(const FloatVal& x, const FloatNum& y);
752  FloatVal fmod(const FloatNum& x, const FloatVal& y);
753 
758  FloatVal sin(const FloatVal& x);
763  FloatVal cos(const FloatVal& x);
768  FloatVal tan(const FloatVal& x);
773  FloatVal asin(const FloatVal& x);
778  FloatVal acos(const FloatVal& x);
783  FloatVal atan(const FloatVal& x);
784 
789  FloatVal sinh(const FloatVal& x);
794  FloatVal cosh(const FloatVal& x);
799  FloatVal tanh(const FloatVal& x);
804  FloatVal asinh(const FloatVal& x);
809  FloatVal acosh(const FloatVal& x);
814  FloatVal atanh(const FloatVal& x);
815 
816 #endif
817 
818 }
819 
820 #include <gecode/float/val.hpp>
821 
822 namespace Gecode { namespace Float {
823 
829  namespace Limits {
833  const FloatNum min = -max;
835  bool valid(const FloatVal& n);
837  void check(const FloatVal& n, const char* l);
838  }
839 
840 }}
841 
842 #include <gecode/float/limits.hpp>
843 
844 #include <gecode/float/var-imp.hpp>
845 
846 namespace Gecode {
847 
848  namespace Float {
849  class FloatView;
850  }
851 
857  class FloatVar : public VarImpVar<Float::FloatVarImp> {
858  friend class FloatVarArray;
859  friend class FloatVarArgs;
860  private:
868  void _init(Space& home, FloatNum min, FloatNum max);
869  public:
871 
872  FloatVar(void);
875  FloatVar(const FloatVar& y);
877  FloatVar(const Float::FloatView& y);
891 
893 
894  FloatVal domain(void) const;
897  FloatNum min(void) const;
899  FloatNum max(void) const;
901  FloatNum med(void) const;
903  FloatNum size(void) const;
911  FloatVal val(void) const;
912 
914 
916 
917  bool in(const FloatVal& n) const;
920  };
921 
926  template<class Char, class Traits>
927  std::basic_ostream<Char,Traits>&
928  operator <<(std::basic_ostream<Char,Traits>& os, const FloatVar& x);
929 }
930 
931 #include <gecode/float/view.hpp>
933 
934 namespace Gecode {
935 
937  class FloatValArgs : public PrimArgArray<FloatVal> {
938  public:
940 
941  FloatValArgs(void);
944  explicit FloatValArgs(int n);
948  FloatValArgs(const std::vector<FloatVal>& x);
950  template<class InputIterator>
951  FloatValArgs(InputIterator first, InputIterator last);
954  FloatValArgs(int n, int e0, ...);
956  FloatValArgs(int n, const FloatVal* e);
959 
961  static FloatValArgs create(int n, FloatVal start, int inc=1);
963  };
964 
966  class FloatVarArgs : public VarArgArray<FloatVar> {
967  public:
969 
970  FloatVarArgs(void) {}
973  explicit FloatVarArgs(int n) : VarArgArray<FloatVar>(n) {}
979  FloatVarArgs(const std::vector<FloatVar>& a) : VarArgArray<FloatVar>(a) {}
981  template<class InputIterator>
982  FloatVarArgs(InputIterator first, InputIterator last)
983  : VarArgArray<FloatVar>(first,last) {}
996  FloatVarArgs(Space& home, int n, FloatNum min, FloatNum max);
998  };
1000 
1016  class FloatVarArray : public VarArray<FloatVar> {
1017  public:
1019 
1020  FloatVarArray(void);
1023  FloatVarArray(Space& home, int n);
1025  FloatVarArray(const FloatVarArray& a);
1027  FloatVarArray(Space& home, const FloatVarArgs& a);
1040  FloatVarArray(Space& home, int n, FloatNum min, FloatNum max);
1042  };
1043 
1044 }
1045 
1046 #include <gecode/float/array.hpp>
1047 
1048 namespace Gecode {
1049 
1061  };
1062 
1070  GECODE_FLOAT_EXPORT void
1072  dom(Home home, FloatVar x, FloatVal n);
1074  GECODE_FLOAT_EXPORT void
1075  dom(Home home, const FloatVarArgs& x, FloatVal n);
1077  GECODE_FLOAT_EXPORT void
1078  dom(Home home, FloatVar x, FloatNum l, FloatNum m);
1080  GECODE_FLOAT_EXPORT void
1081  dom(Home home, const FloatVarArgs& x, FloatNum l, FloatNum u);
1083  GECODE_FLOAT_EXPORT void
1084  dom(Home home, FloatVar x, FloatVal n, Reify r);
1086  GECODE_FLOAT_EXPORT void
1087  dom(Home home, FloatVar x, FloatNum l, FloatNum u, Reify r);
1089  GECODE_FLOAT_EXPORT void
1090  dom(Home home, FloatVar x, FloatVar d);
1092  GECODE_FLOAT_EXPORT void
1093  dom(Home home, const FloatVarArgs& x, const FloatVarArgs& d);
1095 
1104  GECODE_FLOAT_EXPORT void
1105  rel(Home home, FloatVar x0, FloatRelType frt, FloatVar x1);
1109  GECODE_FLOAT_EXPORT void
1110  rel(Home home, FloatVar x, FloatRelType frt, FloatVal c);
1114  GECODE_FLOAT_EXPORT void
1115  rel(Home home, FloatVar x, FloatRelType frt, FloatVal c, Reify r);
1119  GECODE_FLOAT_EXPORT void
1120  rel(Home home, FloatVar x0, FloatRelType frt, FloatVar x1, Reify r);
1124  GECODE_FLOAT_EXPORT void
1125  rel(Home home, const FloatVarArgs& x, FloatRelType frt, FloatVal c);
1129  GECODE_FLOAT_EXPORT void
1130  rel(Home home, const FloatVarArgs& x, FloatRelType frt, FloatVar y);
1131 
1132 }
1133 
1134 
1135 namespace Gecode {
1136 
1145  GECODE_FLOAT_EXPORT void
1146  min(Home home, FloatVar x0, FloatVar x1, FloatVar x2);
1150  GECODE_FLOAT_EXPORT void
1151  min(Home home, const FloatVarArgs& x, FloatVar y);
1154  GECODE_FLOAT_EXPORT void
1155  max(Home home, FloatVar x0, FloatVar x1, FloatVar x2);
1159  GECODE_FLOAT_EXPORT void
1160  max(Home home, const FloatVarArgs& x, FloatVar y);
1161 
1164  GECODE_FLOAT_EXPORT void
1165  abs(Home home, FloatVar x0, FloatVar x1);
1166 
1169  GECODE_FLOAT_EXPORT void
1170  mult(Home home, FloatVar x0, FloatVar x1, FloatVar x2);
1171 
1174  GECODE_FLOAT_EXPORT void
1175  sqr(Home home, FloatVar x0, FloatVar x1);
1176 
1179  GECODE_FLOAT_EXPORT void
1180  sqrt(Home home, FloatVar x0, FloatVar x1);
1181 
1184  GECODE_FLOAT_EXPORT void
1185  pow(Home home, FloatVar x0, int n, FloatVar x1);
1186 
1189  GECODE_FLOAT_EXPORT void
1190  nroot(Home home, FloatVar x0, int n, FloatVar x1);
1191 
1194  GECODE_FLOAT_EXPORT void
1195  div(Home home, FloatVar x0, FloatVar x1, FloatVar x2);
1196 #ifdef GECODE_HAS_MPFR
1197 
1199  GECODE_FLOAT_EXPORT void
1200  exp(Home home, FloatVar x0, FloatVar x1);
1203  GECODE_FLOAT_EXPORT void
1204  log(Home home, FloatVar x0, FloatVar x1);
1207  GECODE_FLOAT_EXPORT void
1208  pow(Home home, FloatNum base, FloatVar x0, FloatVar x1);
1211  GECODE_FLOAT_EXPORT void
1212  log(Home home, FloatNum base, FloatVar x0, FloatVar x1);
1215  GECODE_FLOAT_EXPORT void
1216  asin(Home home, FloatVar x0, FloatVar x1);
1219  GECODE_FLOAT_EXPORT void
1220  sin(Home home, FloatVar x0, FloatVar x1);
1223  GECODE_FLOAT_EXPORT void
1224  acos(Home home, FloatVar x0, FloatVar x1);
1227  GECODE_FLOAT_EXPORT void
1228  cos(Home home, FloatVar x0, FloatVar x1);
1231  GECODE_FLOAT_EXPORT void
1232  atan(Home home, FloatVar x0, FloatVar x1);
1235  GECODE_FLOAT_EXPORT void
1236  tan(Home home, FloatVar x0, FloatVar x1);
1238 #endif
1239 
1247  GECODE_FLOAT_EXPORT void
1248  linear(Home home, const FloatVarArgs& x,
1249  FloatRelType frt, FloatNum c);
1253  GECODE_FLOAT_EXPORT void
1254  linear(Home home, const FloatVarArgs& x,
1255  FloatRelType frt, FloatVar y);
1259  GECODE_FLOAT_EXPORT void
1260  linear(Home home, const FloatVarArgs& x,
1261  FloatRelType frt, FloatNum c, Reify r);
1265  GECODE_FLOAT_EXPORT void
1266  linear(Home home, const FloatVarArgs& x,
1267  FloatRelType frt, FloatVar y, Reify r);
1274  GECODE_FLOAT_EXPORT void
1275  linear(Home home, const FloatValArgs& a, const FloatVarArgs& x,
1276  FloatRelType frt, FloatNum c);
1283  GECODE_FLOAT_EXPORT void
1284  linear(Home home, const FloatValArgs& a, const FloatVarArgs& x,
1285  FloatRelType frt, FloatVar y);
1292  GECODE_FLOAT_EXPORT void
1293  linear(Home home, const FloatValArgs& a, const FloatVarArgs& x,
1294  FloatRelType frt, FloatNum c, Reify r);
1301  GECODE_FLOAT_EXPORT void
1302  linear(Home home, const FloatValArgs& a, const FloatVarArgs& x,
1303  FloatRelType frt, FloatVar y, Reify r);
1304 
1305 
1311  GECODE_FLOAT_EXPORT void
1313  channel(Home home, FloatVar x0, IntVar x1);
1315  GECODE_FLOAT_EXPORT void
1316  channel(Home home, IntVar x0, FloatVar x1);
1318 
1319 
1328  GECODE_FLOAT_EXPORT void
1330  wait(Home home, FloatVar x, void (*c)(Space& home));
1332  GECODE_FLOAT_EXPORT void
1333  wait(Home home, const FloatVarArgs& x, void (*c)(Space& home));
1335 
1336 }
1337 
1338 namespace Gecode {
1339 
1353  typedef bool (*FloatBranchFilter)(const Space& home, FloatVar x, int i);
1354 
1365  typedef double (*FloatBranchMerit)(const Space& home, FloatVar x, int i);
1366 
1373  public:
1377  bool l;
1378  };
1379 
1390  typedef FloatNumBranch (*FloatBranchVal)(const Space& home, FloatVar x, int i);
1391 
1403  typedef void (*FloatBranchCommit)(Space& home, unsigned int a,
1404  FloatVar x, int i, FloatNumBranch nl);
1405 
1406 }
1407 
1409 
1410 namespace Gecode {
1411 
1417  class FloatAFC : public AFC {
1418  public:
1426  FloatAFC(void);
1428  FloatAFC(const FloatAFC& a);
1430  FloatAFC& operator =(const FloatAFC& a);
1432  FloatAFC(Home home, const FloatVarArgs& x, double d=1.0);
1440  void init(Home, const FloatVarArgs& x, double d=1.0);
1441  };
1442 
1443 }
1444 
1445 #include <gecode/float/branch/afc.hpp>
1446 
1447 namespace Gecode {
1448 
1454  class FloatActivity : public Activity {
1455  public:
1463  FloatActivity(void);
1465  FloatActivity(const FloatActivity& a);
1470  FloatActivity(Home home, const FloatVarArgs& x, double d=1.0);
1478  GECODE_FLOAT_EXPORT void
1479  init(Home, const FloatVarArgs& x, double d=1.0);
1480  };
1481 
1482 }
1483 
1485 
1486 namespace Gecode {
1487 
1489  typedef void (*FloatVarValPrint)(const Space &home, const BrancherHandle& bh,
1490  unsigned int a,
1491  FloatVar x, int i, const FloatNumBranch& n,
1492  std::ostream& o);
1493 
1494 }
1495 
1496 namespace Gecode {
1497 
1503  class FloatVarBranch : public VarBranch {
1504  public:
1506  enum Select {
1507  SEL_NONE = 0,
1529  };
1530  protected:
1533  public:
1535  FloatVarBranch(void);
1537  FloatVarBranch(Rnd r);
1541  FloatVarBranch(Select s, double, BranchTbl t);
1549  Select select(void) const;
1551  void expand(Home home, const FloatVarArgs& x);
1552  };
1553 
1554 
1573  FloatVarBranch FLOAT_VAR_AFC_MIN(double d=1.0, BranchTbl tbl=NULL);
1577  FloatVarBranch FLOAT_VAR_AFC_MAX(double d=1.0, BranchTbl tbl=NULL);
1621 
1622 }
1623 
1624 #include <gecode/float/branch/var.hpp>
1625 
1626 namespace Gecode {
1627 
1633  class FloatValBranch : public ValBranch {
1634  public:
1636  enum Select {
1641  };
1642  protected:
1645  public:
1649  FloatValBranch(Rnd r);
1653  Select select(void) const;
1654  };
1655 
1675 
1676 }
1677 
1678 #include <gecode/float/branch/val.hpp>
1679 
1680 namespace Gecode {
1681 
1687  class FloatAssign : public ValBranch {
1688  public:
1690  enum Select {
1695  };
1696  protected:
1699  public:
1703  FloatAssign(Rnd r);
1707  Select select(void) const;
1708  };
1709 
1728 
1729 }
1730 
1732 
1733 namespace Gecode {
1734 
1740  GECODE_FLOAT_EXPORT BrancherHandle
1741  branch(Home home, const FloatVarArgs& x,
1742  FloatVarBranch vars, FloatValBranch vals,
1743  FloatBranchFilter bf=NULL,
1744  FloatVarValPrint vvp=NULL);
1750  GECODE_FLOAT_EXPORT BrancherHandle
1751  branch(Home home, const FloatVarArgs& x,
1752  TieBreak<FloatVarBranch> vars, FloatValBranch vals,
1753  FloatBranchFilter bf=NULL,
1754  FloatVarValPrint vvp=NULL);
1760  GECODE_FLOAT_EXPORT BrancherHandle
1761  branch(Home home, FloatVar x, FloatValBranch vals,
1762  FloatVarValPrint vvp=NULL);
1763 
1769  GECODE_FLOAT_EXPORT BrancherHandle
1770  assign(Home home, const FloatVarArgs& x, FloatAssign vals,
1771  FloatBranchFilter fbf=NULL,
1772  FloatVarValPrint vvp=NULL);
1778  GECODE_FLOAT_EXPORT BrancherHandle
1779  assign(Home home, FloatVar x, FloatAssign vals,
1780  FloatVarValPrint vvp=NULL);
1782 
1783 }
1784 
1785 #endif
1786 
1787 // IFDEF: GECODE_HAS_FLOAT_VARS
1788 // STATISTICS: float-post
1789