Generated on Thu Apr 5 2018 19:44:19 for Gecode by doxygen 1.8.13
minimodel.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  * Matthias Balzer <matthias.balzer@itwm.fraunhofer.de>
7  * Mikael Lagerkvist <lagerkvist@gecode.org>
8  * Vincent Barichard <Vincent.Barichard@univ-angers.fr>
9  *
10  * Copyright:
11  * Christian Schulte, 2004
12  * Fraunhofer ITWM, 2017
13  * Guido Tack, 2004
14  * Mikael Lagerkvist, 2005
15  * Vincent Barichard, 2012
16  *
17  * Last modified:
18  * $Date$ by $Author$
19  * $Revision$
20  *
21  * This file is part of Gecode, the generic constraint
22  * development environment:
23  * http://www.gecode.org
24  *
25  * Permission is hereby granted, free of charge, to any person obtaining
26  * a copy of this software and associated documentation files (the
27  * "Software"), to deal in the Software without restriction, including
28  * without limitation the rights to use, copy, modify, merge, publish,
29  * distribute, sublicense, and/or sell copies of the Software, and to
30  * permit persons to whom the Software is furnished to do so, subject to
31  * the following conditions:
32  *
33  * The above copyright notice and this permission notice shall be
34  * included in all copies or substantial portions of the Software.
35  *
36  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
37  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
38  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
39  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
40  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
41  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
42  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
43  *
44  */
45 
46 #ifndef __GECODE_MINIMODEL_HH__
47 #define __GECODE_MINIMODEL_HH__
48 
49 #include <gecode/kernel.hh>
50 #include <gecode/int.hh>
51 #ifdef GECODE_HAS_SET_VARS
52 #include <gecode/set.hh>
53 #endif
54 #ifdef GECODE_HAS_FLOAT_VARS
55 #include <gecode/float.hh>
56 #endif
57 
58 #include <iostream>
59 
60 /*
61  * Support for DLLs under Windows
62  *
63  */
64 
65 #if !defined(GECODE_STATIC_LIBS) && \
66  (defined(__CYGWIN__) || defined(__MINGW32__) || defined(_MSC_VER))
67 
68 #ifdef GECODE_BUILD_MINIMODEL
69 #define GECODE_MINIMODEL_EXPORT __declspec( dllexport )
70 #else
71 #define GECODE_MINIMODEL_EXPORT __declspec( dllimport )
72 #endif
73 
74 #else
75 
76 #ifdef GECODE_GCC_HAS_CLASS_VISIBILITY
77 
78 #define GECODE_MINIMODEL_EXPORT __attribute__ ((visibility("default")))
79 
80 #else
81 
82 #define GECODE_MINIMODEL_EXPORT
83 
84 #endif
85 #endif
86 
87 // Configure auto-linking
88 #ifndef GECODE_BUILD_MINIMODEL
89 #define GECODE_LIBRARY_NAME "MiniModel"
91 #endif
92 
93 namespace Gecode {
94 
96  namespace MiniModel {}
97 
98 }
99 
101 
102 namespace Gecode {
103 
104  class LinIntRel;
105 #ifdef GECODE_HAS_SET_VARS
106  class SetExpr;
107 #endif
108 #ifdef GECODE_HAS_FLOAT_VARS
109  class LinFloatExpr;
110 #endif
111 
114  public:
116  virtual IntVar post(Home home, IntVar* ret, IntPropLevel ipl) const = 0;
118  virtual void post(Home home, IntRelType irt, int c,
119  IntPropLevel ipl) const = 0;
121  virtual void post(Home home, IntRelType irt, int c,
122  BoolVar b, IntPropLevel ipl) const = 0;
124  virtual ~NonLinIntExpr(void) {}
126  static IntVar result(Home home, IntVar* x) {
127  if (x==NULL)
129  return *x;
130  }
132  static IntVar result(Home home, IntVar* x, IntVar y) {
133  if (x!=NULL)
134  rel(home,*x,IRT_EQ,y);
135  return y;
136  }
138  void* operator new(size_t size) { return heap.ralloc(size); }
140  void operator delete(void* p, size_t) { heap.rfree(p); }
141  };
142 
144  class LinIntExpr {
145  friend class LinIntRel;
146 #ifdef GECODE_HAS_SET_VARS
147  friend class SetExpr;
148 #endif
149 #ifdef GECODE_HAS_FLOAT_VARS
150  friend class LinFloatExpr;
151 #endif
152  public:
154  enum NodeType {
163  NT_MUL
164  };
165  private:
167  class Node;
169  Node* n;
170  public:
173  LinIntExpr(void);
176  LinIntExpr(int c);
179  LinIntExpr(const IntVar& x, int a=1);
182  LinIntExpr(const BoolVar& x, int a=1);
185  explicit LinIntExpr(const IntVarArgs& x);
188  LinIntExpr(const IntArgs& a, const IntVarArgs& x);
191  explicit LinIntExpr(const BoolVarArgs& x);
194  LinIntExpr(const IntArgs& a, const BoolVarArgs& x);
197  LinIntExpr(const LinIntExpr& e);
200  LinIntExpr(const LinIntExpr& e0, NodeType t, const LinIntExpr& e1);
203  LinIntExpr(const LinIntExpr& e0, NodeType t, int c);
206  LinIntExpr(int a, const LinIntExpr& e);
209  explicit LinIntExpr(NonLinIntExpr* e);
212  const LinIntExpr& operator =(const LinIntExpr& e);
215  void post(Home home, IntRelType irt, IntPropLevel ipl) const;
218  void post(Home home, IntRelType irt, const BoolVar& b,
219  IntPropLevel ipl) const;
222  IntVar post(Home home, IntPropLevel ipl) const;
225  NonLinIntExpr* nle(void) const;
228  ~LinIntExpr(void);
229  };
230 
231  class BoolExpr;
232 
234  class LinIntRel {
235  friend class BoolExpr;
236  private:
238  LinIntExpr e;
240  IntRelType irt;
242  static IntRelType neg(IntRelType irt);
244  LinIntRel(void);
245  public:
247  LinIntRel(const LinIntExpr& l, IntRelType irt, const LinIntExpr& r);
249  LinIntRel(const LinIntExpr& l, IntRelType irt, int r);
251  LinIntRel(int l, IntRelType irt, const LinIntExpr& r);
253  void post(Home home, bool t, IntPropLevel ipl) const;
255  void post(Home home, const BoolVar& b, bool t, IntPropLevel ipl) const;
256  };
257 
278  operator +(int, const IntVar&);
281  operator +(int, const BoolVar&);
284  operator +(int, const LinIntExpr&);
287  operator +(const IntVar&, int);
290  operator +(const BoolVar&, int);
293  operator +(const LinIntExpr&, int);
296  operator +(const IntVar&, const IntVar&);
299  operator +(const IntVar&, const BoolVar&);
302  operator +(const BoolVar&, const IntVar&);
305  operator +(const BoolVar&, const BoolVar&);
308  operator +(const IntVar&, const LinIntExpr&);
311  operator +(const BoolVar&, const LinIntExpr&);
314  operator +(const LinIntExpr&, const IntVar&);
317  operator +(const LinIntExpr&, const BoolVar&);
320  operator +(const LinIntExpr&, const LinIntExpr&);
321 
324  operator -(int, const IntVar&);
327  operator -(int, const BoolVar&);
330  operator -(int, const LinIntExpr&);
333  operator -(const IntVar&, int);
336  operator -(const BoolVar&, int);
339  operator -(const LinIntExpr&, int);
342  operator -(const IntVar&, const IntVar&);
345  operator -(const IntVar&, const BoolVar&);
348  operator -(const BoolVar&, const IntVar&);
351  operator -(const BoolVar&, const BoolVar&);
354  operator -(const IntVar&, const LinIntExpr&);
357  operator -(const BoolVar&, const LinIntExpr&);
360  operator -(const LinIntExpr&, const IntVar&);
363  operator -(const LinIntExpr&, const BoolVar&);
366  operator -(const LinIntExpr&, const LinIntExpr&);
367 
370  operator -(const IntVar&);
373  operator -(const BoolVar&);
376  operator -(const LinIntExpr&);
377 
380  operator *(int, const IntVar&);
383  operator *(int, const BoolVar&);
386  operator *(const IntVar&, int);
389  operator *(const BoolVar&, int);
392  operator *(const LinIntExpr&, int);
395  operator *(int, const LinIntExpr&);
396 
399  sum(const IntVarArgs& x);
402  sum(const IntArgs& a, const IntVarArgs& x);
405  sum(const BoolVarArgs& x);
408  sum(const IntArgs& a, const BoolVarArgs& x);
411  sum(const IntArgs& args);
412 
415  operator ==(int l, const IntVar& r);
418  operator ==(int l, const BoolVar& r);
421  operator ==(int l, const LinIntExpr& r);
424  operator ==(const IntVar& l, int r);
427  operator ==(const BoolVar& l, int r);
430  operator ==(const LinIntExpr& l, int r);
433  operator ==(const IntVar& l, const IntVar& r);
436  operator ==(const IntVar& l, const BoolVar& r);
439  operator ==(const BoolVar& l, const IntVar& r);
442  operator ==(const BoolVar& l, const BoolVar& r);
445  operator ==(const IntVar& l, const LinIntExpr& r);
448  operator ==(const BoolVar& l, const LinIntExpr& r);
451  operator ==(const LinIntExpr& l, const IntVar& r);
454  operator ==(const LinIntExpr& l, const BoolVar& r);
457  operator ==(const LinIntExpr& l, const LinIntExpr& r);
458 
461  operator !=(int l, const IntVar& r);
464  operator !=(int l, const BoolVar& r);
467  operator !=(int l, const LinIntExpr& r);
470  operator !=(const IntVar& l, int r);
473  operator !=(const BoolVar& l, int r);
476  operator !=(const LinIntExpr& l, int r);
479  operator !=(const IntVar& l, const IntVar& r);
482  operator !=(const IntVar& l, const BoolVar& r);
485  operator !=(const BoolVar& l, const IntVar& r);
488  operator !=(const BoolVar& l, const BoolVar& r);
491  operator !=(const IntVar& l, const LinIntExpr& r);
494  operator !=(const BoolVar& l, const LinIntExpr& r);
497  operator !=(const LinIntExpr& l, const IntVar& r);
500  operator !=(const LinIntExpr& l, const BoolVar& r);
503  operator !=(const LinIntExpr& l, const LinIntExpr& r);
504 
507  operator <(int l, const IntVar& r);
510  operator <(int l, const BoolVar& r);
513  operator <(int l, const LinIntExpr& r);
516  operator <(const IntVar& l, int r);
519  operator <(const BoolVar& l, int r);
522  operator <(const LinIntExpr& l, int r);
525  operator <(const IntVar& l, const IntVar& r);
528  operator <(const IntVar& l, const BoolVar& r);
531  operator <(const BoolVar& l, const IntVar& r);
534  operator <(const BoolVar& l, const BoolVar& r);
537  operator <(const IntVar& l, const LinIntExpr& r);
540  operator <(const BoolVar& l, const LinIntExpr& r);
543  operator <(const LinIntExpr& l, const IntVar& r);
546  operator <(const LinIntExpr& l, const BoolVar& r);
549  operator <(const LinIntExpr& l, const LinIntExpr& r);
550 
553  operator <=(int l, const IntVar& r);
556  operator <=(int l, const BoolVar& r);
559  operator <=(int l, const LinIntExpr& r);
562  operator <=(const IntVar& l, int r);
565  operator <=(const BoolVar& l, int r);
568  operator <=(const LinIntExpr& l, int r);
571  operator <=(const IntVar& l, const IntVar& r);
574  operator <=(const IntVar& l, const BoolVar& r);
577  operator <=(const BoolVar& l, const IntVar& r);
580  operator <=(const BoolVar& l, const BoolVar& r);
583  operator <=(const IntVar& l, const LinIntExpr& r);
586  operator <=(const BoolVar& l, const LinIntExpr& r);
589  operator <=(const LinIntExpr& l, const IntVar& r);
592  operator <=(const LinIntExpr& l, const BoolVar& r);
595  operator <=(const LinIntExpr& l, const LinIntExpr& r);
596 
599  operator >(int l, const IntVar& r);
602  operator >(int l, const BoolVar& r);
605  operator >(int l, const LinIntExpr& r);
608  operator >(const IntVar& l, int r);
611  operator >(const BoolVar& l, int r);
614  operator >(const LinIntExpr& l, int r);
617  operator >(const IntVar& l, const IntVar& r);
620  operator >(const IntVar& l, const BoolVar& r);
623  operator >(const BoolVar& l, const IntVar& r);
626  operator >(const BoolVar& l, const BoolVar& r);
629  operator >(const IntVar& l, const LinIntExpr& r);
632  operator >(const BoolVar& l, const LinIntExpr& r);
635  operator >(const LinIntExpr& l, const IntVar& r);
638  operator >(const LinIntExpr& l, const BoolVar& r);
641  operator >(const LinIntExpr& l, const LinIntExpr& r);
642 
645  operator >=(int l, const IntVar& r);
648  operator >=(int l, const BoolVar& r);
651  operator >=(int l, const LinIntExpr& r);
654  operator >=(const IntVar& l, int r);
657  operator >=(const BoolVar& l, int r);
660  operator >=(const LinIntExpr& l, int r);
663  operator >=(const IntVar& l, const IntVar& r);
666  operator >=(const IntVar& l, const BoolVar& r);
669  operator >=(const BoolVar& l, const IntVar& r);
672  operator >=(const BoolVar& l, const BoolVar& r);
675  operator >=(const IntVar& l, const LinIntExpr& r);
678  operator >=(const BoolVar& l, const LinIntExpr& r);
681  operator >=(const LinIntExpr& l, const IntVar& r);
684  operator >=(const LinIntExpr& l, const BoolVar& r);
687  operator >=(const LinIntExpr& l, const LinIntExpr& r);
689 
690 #ifdef GECODE_HAS_FLOAT_VARS
691  class NonLinFloatExpr {
693  public:
695  virtual FloatVar post(Home home, FloatVar* ret) const = 0;
697  virtual void post(Home home, FloatRelType frt, FloatVal c) const = 0;
699  virtual void post(Home home, FloatRelType frt, FloatVal c,
700  BoolVar b) const = 0;
702  virtual ~NonLinFloatExpr(void) {}
704  static FloatVar result(Home home, FloatVar* x) {
705  if (x == NULL)
707  return *x;
708  }
710  static FloatVar result(Home home, FloatVar* x, FloatVar y) {
711  if (x!=NULL)
712  rel(home,*x,FRT_EQ,y);
713  return y;
714  }
716  void* operator new(size_t size) { return heap.ralloc(size); }
718  void operator delete(void* p, size_t) { heap.rfree(p); }
719  };
720 
722  class LinFloatExpr {
723  friend class LinFloatRel;
724  public:
726  enum NodeType {
733  NT_MUL
734  };
735  private:
737  class Node;
738  Node* n;
739  public:
742  LinFloatExpr(void);
745  LinFloatExpr(const FloatVal& c);
748  LinFloatExpr(const FloatVar& x);
751  LinFloatExpr(const FloatVar& x, FloatVal a);
754  explicit LinFloatExpr(const FloatVarArgs& x);
757  LinFloatExpr(const FloatValArgs& a, const FloatVarArgs& x);
760  LinFloatExpr(const LinFloatExpr& e);
763  LinFloatExpr(const LinFloatExpr& e0, NodeType t, const LinFloatExpr& e1);
766  LinFloatExpr(const LinFloatExpr& e0, NodeType t, const FloatVal& c);
769  LinFloatExpr(FloatVal a, const LinFloatExpr& e);
772  explicit LinFloatExpr(NonLinFloatExpr* e);
775  const LinFloatExpr& operator =(const LinFloatExpr& e);
778  void post(Home home, FloatRelType frt) const;
781  void post(Home home, FloatRelType frt, const BoolVar& b) const;
784  FloatVar post(Home home) const;
787  NonLinFloatExpr* nlfe(void) const;
790  ~LinFloatExpr(void);
791  };
792 
793  class BoolExpr;
794 
796  class LinFloatRel {
797  friend class BoolExpr;
798  private:
800  LinFloatExpr e;
802  FloatRelType frt;
804  static FloatRelType neg(FloatRelType frt);
806  LinFloatRel(void);
807  public:
809  LinFloatRel(const LinFloatExpr& l, FloatRelType frt, const LinFloatExpr& r);
815  void post(Home home, bool t) const;
817  void post(Home home, const BoolVar& b, bool t) const;
818  };
819 
835  operator +(const FloatVal&, const FloatVar&);
838  operator +(const FloatVal&, const LinFloatExpr&);
841  operator +(const FloatVar&, const FloatVal&);
844  operator +(const LinFloatExpr&, const FloatVal&);
847  operator +(const FloatVar&, const FloatVar&);
850  operator +(const FloatVar&, const LinFloatExpr&);
853  operator +(const LinFloatExpr&, const FloatVar&);
856  operator +(const LinFloatExpr&, const LinFloatExpr&);
857 
860  operator -(const FloatVal&, const FloatVar&);
863  operator -(const FloatVal&, const LinFloatExpr&);
866  operator -(const FloatVar&, const FloatVal&);
869  operator -(const LinFloatExpr&, const FloatVal&);
872  operator -(const FloatVar&, const FloatVar&);
875  operator -(const FloatVar&, const LinFloatExpr&);
878  operator -(const LinFloatExpr&, const FloatVar&);
881  operator -(const LinFloatExpr&, const LinFloatExpr&);
882 
885  operator -(const FloatVar&);
888  operator -(const LinFloatExpr&);
889 
892  operator *(const FloatVal&, const FloatVar&);
895  operator *(const FloatVar&, const FloatVal&);
898  operator *(const LinFloatExpr&, const FloatVal&);
901  operator *(const FloatVal&, const LinFloatExpr&);
902 
905  sum(const FloatVarArgs& x);
908  sum(const FloatValArgs& a, const FloatVarArgs& x);
909 
912  operator ==(const FloatVal& l, const FloatVar& r);
915  operator ==(const FloatVal& l, const LinFloatExpr& r);
918  operator ==(const FloatVar& l, const FloatVal& r);
921  operator ==(const LinFloatExpr& l, const FloatVal& r);
924  operator ==(const FloatVar& l, const FloatVar& r);
927  operator ==(const FloatVar& l, const LinFloatExpr& r);
930  operator ==(const LinFloatExpr& l, const FloatVar& r);
933  operator ==(const LinFloatExpr& l, const LinFloatExpr& r);
934 
937  operator !=(const FloatVal& l, const FloatVar& r);
940  operator !=(const FloatVal& l, const LinFloatExpr& r);
943  operator !=(const FloatVar& l, const FloatVal& r);
946  operator !=(const LinFloatExpr& l, const FloatVal& r);
949  operator !=(const FloatVar& l, const FloatVar& r);
952  operator !=(const FloatVar& l, const LinFloatExpr& r);
955  operator !=(const LinFloatExpr& l, const FloatVar& r);
958  operator !=(const LinFloatExpr& l, const LinFloatExpr& r);
959 
962  operator <(const FloatVal& l, const FloatVar& r);
965  operator <(const FloatVal& l, const LinFloatExpr& r);
968  operator <(const FloatVar& l, const FloatVal& r);
971  operator <(const LinFloatExpr& l, const FloatVal& r);
974  operator <(const FloatVar& l, const FloatVar& r);
977  operator <(const FloatVar& l, const LinFloatExpr& r);
980  operator <(const LinFloatExpr& l, const FloatVar& r);
983  operator <(const LinFloatExpr& l, const LinFloatExpr& r);
984 
987  operator <=(const FloatVal& l, const FloatVar& r);
990  operator <=(const FloatVal& l, const LinFloatExpr& r);
993  operator <=(const FloatVar& l, const FloatVal& r);
996  operator <=(const LinFloatExpr& l, const FloatVal& r);
999  operator <=(const FloatVar& l, const FloatVar& r);
1002  operator <=(const FloatVar& l, const LinFloatExpr& r);
1005  operator <=(const LinFloatExpr& l, const FloatVar& r);
1008  operator <=(const LinFloatExpr& l, const LinFloatExpr& r);
1009 
1012  operator >(const FloatVal& l, const FloatVar& r);
1015  operator >(const FloatVal& l, const LinFloatExpr& r);
1018  operator >(const FloatVar& l, const FloatVal& r);
1021  operator >(const LinFloatExpr& l, const FloatVal& r);
1024  operator >(const FloatVar& l, const FloatVar& r);
1027  operator >(const FloatVar& l, const LinFloatExpr& r);
1030  operator >(const LinFloatExpr& l, const FloatVar& r);
1033  operator >(const LinFloatExpr& l, const LinFloatExpr& r);
1034 
1037  operator >=(const FloatVal& l, const FloatVar& r);
1040  operator >=(const FloatVal& l, const LinFloatExpr& r);
1043  operator >=(const FloatVar& l, const FloatVal& r);
1046  operator >=(const LinFloatExpr& l, const FloatVal& r);
1049  operator >=(const FloatVar& l, const FloatVar& r);
1052  operator >=(const FloatVar& l, const LinFloatExpr& r);
1055  operator >=(const LinFloatExpr& l, const FloatVar& r);
1058  operator >=(const LinFloatExpr& l, const LinFloatExpr& r);
1060 #endif
1061 
1062 #ifdef GECODE_HAS_SET_VARS
1063  class SetExpr {
1065  public:
1067  enum NodeType {
1074  NT_DUNION
1075  };
1077  class Node;
1078  private:
1080  Node* n;
1081  public:
1083  SetExpr(void);
1086  SetExpr(const SetExpr& e);
1089  SetExpr(const SetExpr& l, NodeType t, const SetExpr& r);
1092  SetExpr(const SetVar& x);
1095  explicit SetExpr(const LinIntExpr& x);
1098  SetExpr(const IntSet& s);
1101  SetExpr(const SetExpr& e, NodeType t);
1104  SetVar post(Home home) const;
1107  void post(Home home, SetRelType srt, const SetExpr& e) const;
1110  void post(Home home, BoolVar b, bool t,
1111  SetRelType srt, const SetExpr& e) const;
1114  const SetExpr& operator =(const SetExpr& e);
1117  ~SetExpr(void);
1118  };
1119 
1121  class SetCmpRel {
1122  public:
1130  SetCmpRel(const SetExpr& l, SetRelType srt, const SetExpr& r);
1131  };
1132 
1134  class SetRel {
1135  private:
1137  SetExpr _e0;
1139  SetRelType _srt;
1141  SetExpr _e1;
1142  public:
1144  SetRel(void);
1146  SetRel(const SetExpr& e0, SetRelType srt, const SetExpr& e1);
1148  SetRel(const SetCmpRel& r);
1150  void post(Home home, bool t) const;
1152  void post(Home home, BoolVar b, bool t) const;
1153  };
1154 
1167  singleton(const LinIntExpr&);
1170  operator -(const SetExpr&);
1173  operator &(const SetExpr&, const SetExpr&);
1176  operator |(const SetExpr&, const SetExpr&);
1179  operator +(const SetExpr&, const SetExpr&);
1182  operator -(const SetExpr&, const SetExpr&);
1183 
1186  inter(const SetVarArgs&);
1189  setunion(const SetVarArgs&);
1192  setdunion(const SetVarArgs&);
1193 
1196  cardinality(const SetExpr&);
1199  min(const SetExpr&);
1202  max(const SetExpr&);
1203 
1206  operator ==(const SetExpr&, const SetExpr&);
1209  operator !=(const SetExpr&, const SetExpr&);
1212  operator <=(const SetExpr&, const SetExpr&);
1215  operator <=(const SetCmpRel&, const SetExpr&);
1218  operator >=(const SetExpr&, const SetExpr&);
1221  operator >=(const SetCmpRel&, const SetExpr&);
1224  operator ||(const SetExpr&, const SetExpr&);
1226 #endif
1227 
1229  class BoolExpr {
1230  public:
1232  enum NodeType {
1241  NT_MISC
1242  };
1245  public:
1247  Misc(void);
1252  virtual void post(Home home, BoolVar b, bool neg,
1253  IntPropLevel ipl) = 0;
1255  virtual GECODE_MINIMODEL_EXPORT ~Misc(void);
1256  };
1258  class Node;
1259  private:
1261  Node* n;
1262  public:
1265  BoolExpr(void);
1268  BoolExpr(const BoolExpr& e);
1271  BoolExpr(const BoolExpr& l, NodeType t, const BoolExpr& r);
1274  BoolExpr(const BoolVar& x);
1277  BoolExpr(const BoolExpr& e, NodeType t);
1280  BoolExpr(const LinIntRel& rl);
1281 #ifdef GECODE_HAS_FLOAT_VARS
1284  BoolExpr(const LinFloatRel& rfl);
1285 #endif
1286 #ifdef GECODE_HAS_SET_VARS
1289  BoolExpr(const SetRel& rs);
1292  BoolExpr(const SetCmpRel& rs);
1293 #endif
1296  explicit BoolExpr(Misc* m);
1299  BoolVar expr(Home home, IntPropLevel ipl) const;
1302  void rel(Home home, IntPropLevel ipl) const;
1305  const BoolExpr& operator =(const BoolExpr& e);
1308  ~BoolExpr(void);
1309  };
1310 
1323  operator !(const BoolExpr&);
1326  operator &&(const BoolExpr&, const BoolExpr&);
1329  operator ||(const BoolExpr&, const BoolExpr&);
1332  operator ^(const BoolExpr&, const BoolExpr&);
1333 
1336  operator !=(const BoolExpr&, const BoolExpr&);
1339  operator ==(const BoolExpr&, const BoolExpr&);
1342  operator >>(const BoolExpr&, const BoolExpr&);
1345  operator <<(const BoolExpr&, const BoolExpr&);
1346 
1348 
1358  dom(const IntVar& x, int n);
1361  dom(const IntVar& x, int l, int m);
1364  dom(const IntVar& x, const IntSet& s);
1365 
1366 #ifdef GECODE_HAS_SET_VARS
1369  dom(const SetVar& x, SetRelType rt, int i);
1372  dom(const SetVar& x, SetRelType rt, int i, int j);
1375  dom(const SetVar& x, SetRelType rt, const IntSet& s);
1376 #endif
1377 
1378 #ifdef GECODE_HAS_FLOAT_VARS
1381  dom(const FloatVar& x, const FloatVal& n);
1384  dom(const FloatVar& x, FloatNum l, FloatNum u);
1385 #endif
1386 
1387 
1395 #ifdef GECODE_HAS_SET_VARS
1398  operator ==(const SetExpr& s, const LinIntExpr& x);
1401  operator ==(const LinIntExpr& x, const SetExpr& s);
1403  BoolExpr
1404  operator ==(const LinIntExpr&, IntSet) = delete;
1406  BoolExpr
1407  operator ==(IntSet, const LinIntExpr&) = delete;
1408 
1411  operator !=(const SetExpr& s, const LinIntExpr& x);
1414  operator !=(const LinIntExpr& x, const SetExpr& s);
1416  BoolExpr
1417  operator !=(const LinIntExpr&, IntSet) = delete;
1419  BoolExpr
1420  operator !=(IntSet, const LinIntExpr&) = delete;
1421 
1424  operator <=(const SetExpr& s, const LinIntExpr& x);
1427  operator <=(const LinIntExpr& x, const SetExpr& s);
1429  BoolExpr
1430  operator <=(const LinIntExpr&, IntSet) = delete;
1432  BoolExpr
1433  operator <=(IntSet, const LinIntExpr&) = delete;
1434 
1437  operator <(const SetExpr& s, const LinIntExpr& x);
1440  operator <(const LinIntExpr& x, const SetExpr& s);
1442  BoolExpr
1443  operator <(const LinIntExpr&, IntSet) = delete;
1445  BoolExpr
1446  operator <(IntSet, const LinIntExpr&) = delete;
1447 
1450  operator >=(const SetExpr& s, const LinIntExpr& x);
1453  operator >=(const LinIntExpr& x, const SetExpr& s);
1455  BoolExpr
1456  operator >=(const LinIntExpr&, IntSet) = delete;
1458  BoolExpr
1459  operator >=(IntSet, const LinIntExpr&) = delete;
1460 
1463  operator >(const SetExpr& s, const LinIntExpr& x);
1466  operator >(const LinIntExpr& x, const SetExpr& s);
1468  BoolExpr
1469  operator >(const LinIntExpr&, IntSet) = delete;
1471  BoolExpr
1472  operator >(IntSet, const LinIntExpr&) = delete;
1473 #endif
1474 
1475 
1484  expr(Home home, const LinIntExpr& e, IntPropLevel ipl=IPL_DEF);
1485 #ifdef GECODE_HAS_FLOAT_VARS
1488  expr(Home home, const LinFloatExpr& e);
1489 #endif
1490 #ifdef GECODE_HAS_SET_VARS
1493  expr(Home home, const SetExpr& e);
1494 #endif
1497  expr(Home home, const BoolExpr& e, IntPropLevel ipl=IPL_DEF);
1500  rel(Home home, const BoolExpr& e, IntPropLevel ipl=IPL_DEF);
1502 
1503 }
1504 
1510 
1511 namespace Gecode {
1512 
1513  namespace MiniModel {
1514  class ExpInfo;
1515  }
1516 
1523  friend class MiniModel::ExpInfo;
1524  private:
1526  class Exp;
1528  Exp* e;
1530  REG(Exp* e);
1532  std::string toString(void) const;
1533  public:
1535  REG(void);
1537  REG(int s);
1544  REG(const IntArgs& x);
1545 
1547  REG(const REG& r);
1549  const REG& operator =(const REG& r);
1550 
1552  REG operator +(const REG& r);
1554  REG& operator +=(const REG& r);
1556  REG operator |(const REG& r);
1558  REG& operator |=(const REG& r);
1560  REG operator *(void);
1562  REG operator +(void);
1564  REG operator ()(unsigned int n, unsigned int m);
1566  REG operator ()(unsigned int n);
1568  template<class Char, class Traits>
1569  std::basic_ostream<Char,Traits>&
1570  print(std::basic_ostream<Char,Traits>& os) const;
1572  operator DFA(void);
1574  ~REG(void);
1575  };
1576 
1580  template<class Char, class Traits>
1581  std::basic_ostream<Char,Traits>&
1582  operator <<(std::basic_ostream<Char,Traits>& os, const REG& r);
1583 
1584 }
1585 
1586 #include <gecode/minimodel/reg.hpp>
1587 
1588 namespace Gecode {
1589 
1598  abs(const LinIntExpr& e);
1601  min(const LinIntExpr& x, const LinIntExpr& y);
1604  min(const IntVarArgs& x);
1607  max(const LinIntExpr& x, const LinIntExpr& y);
1610  max(const IntVarArgs& x);
1611 #ifdef GECODE_HAS_FLOAT_VARS
1614  operator *(const FloatVar&, const FloatVar&);
1617  operator *(const FloatVar&, const LinFloatExpr&);
1620  operator *(const LinFloatExpr&, const FloatVar&);
1621 #endif
1624  operator *(const LinIntExpr& x, const LinIntExpr& y);
1627  operator /(const LinIntExpr& x, const LinIntExpr& y);
1630  operator %(const LinIntExpr& x, const LinIntExpr& y);
1633  sqr(const LinIntExpr& x);
1636  sqrt(const LinIntExpr& x);
1639  pow(const LinIntExpr& x, int n);
1642  nroot(const LinIntExpr& x, int n);
1645  element(const IntVarArgs& x, const LinIntExpr& y);
1648  element(const BoolVarArgs& x, const LinIntExpr& y);
1651  element(const IntArgs& x, const LinIntExpr& y);
1654  ite(const BoolExpr& b, const LinIntExpr& x, const LinIntExpr& y);
1656 
1657 #ifdef GECODE_HAS_FLOAT_VARS
1660  abs(const LinFloatExpr& e);
1663  min(const LinFloatExpr& x, const LinFloatExpr& y);
1666  min(const FloatVarArgs& x);
1669  max(const LinFloatExpr& x, const LinFloatExpr& y);
1672  max(const FloatVarArgs& x);
1675  operator *(const LinFloatExpr& x, const LinFloatExpr& y);
1678  operator /(const LinFloatExpr& x, const LinFloatExpr& y);
1681  sqr(const LinFloatExpr& x);
1684  sqrt(const LinFloatExpr& x);
1687  pow(const LinFloatExpr& x, int n);
1690  nroot(const LinFloatExpr& x, int n);
1692 
1693 #ifdef GECODE_HAS_MPFR
1694 
1702  exp(const LinFloatExpr& x);
1705  log(const LinFloatExpr& x);
1707 
1716  asin(const LinFloatExpr& x);
1719  sin(const LinFloatExpr& x);
1722  acos(const LinFloatExpr& x);
1725  cos(const LinFloatExpr& x);
1728  atan(const LinFloatExpr& x);
1731  tan(const LinFloatExpr& x);
1733 #endif
1734 #endif
1735 
1742  inline BoolVar
1745  IntPropLevel ipl=IPL_DEF) {
1746  (void) ipl;
1747  BoolVar b(home,0,1); channel(home,b,x);
1748  return b;
1749  }
1751  inline IntVar
1753  IntPropLevel ipl=IPL_DEF) {
1754  (void) ipl;
1755  IntVar x(home,0,1); channel(home,b,x);
1756  return x;
1757  }
1758 #ifdef GECODE_HAS_FLOAT_VARS
1759  inline IntVar
1762  int min = static_cast<int>(std::max(static_cast<double>(Int::Limits::min),
1763  std::ceil(f.min())));
1764  int max = static_cast<int>(std::min(static_cast<double>(Int::Limits::max),
1765  std::floor(f.max())));
1766  IntVar x(home,min,max);
1767  channel(home,f,x);
1768  return x;
1769  }
1770 #endif
1771 #ifdef GECODE_HAS_SET_VARS
1772  inline SetVar
1775  (void) ipl;
1777  rel(home,SOT_UNION,x,s);
1778  nvalues(home,x,IRT_EQ,expr(home,cardinality(s)));
1779  return s;
1780  }
1781 #endif
1782 
1783 
1784 }
1785 
1786 namespace Gecode {
1787 
1802  inline void
1803  atmost(Home home, const IntVarArgs& x, int n, int m,
1804  IntPropLevel ipl=IPL_DEF) {
1805  count(home,x,n,IRT_LQ,m,ipl);
1806  }
1811  inline void
1812  atmost(Home home, const IntVarArgs& x, IntVar y, int m,
1813  IntPropLevel ipl=IPL_DEF) {
1814  count(home,x,y,IRT_LQ,m,ipl);
1815  }
1823  inline void
1824  atmost(Home home, const IntVarArgs& x, const IntArgs& y, int m,
1825  IntPropLevel ipl=IPL_DEF) {
1826  count(home,x,y,IRT_LQ,m,ipl);
1827  }
1832  inline void
1833  atmost(Home home, const IntVarArgs& x, int n, IntVar z,
1834  IntPropLevel ipl=IPL_DEF) {
1835  count(home,x,n,IRT_LQ,z,ipl);
1836  }
1841  inline void
1843  IntPropLevel ipl=IPL_DEF) {
1844  count(home,x,y,IRT_LQ,z,ipl);
1845  }
1853  inline void
1854  atmost(Home home, const IntVarArgs& x, const IntArgs& y, IntVar z,
1855  IntPropLevel ipl=IPL_DEF) {
1856  count(home,x,y,IRT_LQ,z,ipl);
1857  }
1858 
1863  inline void
1864  atleast(Home home, const IntVarArgs& x, int n, int m,
1865  IntPropLevel ipl=IPL_DEF) {
1866  count(home,x,n,IRT_GQ,m,ipl);
1867  }
1872  inline void
1873  atleast(Home home, const IntVarArgs& x, IntVar y, int m,
1874  IntPropLevel ipl=IPL_DEF) {
1875  count(home,x,y,IRT_GQ,m,ipl);
1876  }
1884  inline void
1885  atleast(Home home, const IntVarArgs& x, const IntArgs& y, int m,
1886  IntPropLevel ipl=IPL_DEF) {
1887  count(home,x,y,IRT_GQ,m,ipl);
1888  }
1893  inline void
1894  atleast(Home home, const IntVarArgs& x, int n, IntVar z,
1895  IntPropLevel ipl=IPL_DEF) {
1896  count(home,x,n,IRT_GQ,z,ipl);
1897  }
1902  inline void
1904  IntPropLevel ipl=IPL_DEF) {
1905  count(home,x,y,IRT_GQ,z,ipl);
1906  }
1914  inline void
1915  atleast(Home home, const IntVarArgs& x, const IntArgs& y, IntVar z,
1916  IntPropLevel ipl=IPL_DEF) {
1917  count(home,x,y,IRT_GQ,z,ipl);
1918  }
1919 
1924  inline void
1925  exactly(Home home, const IntVarArgs& x, int n, int m,
1926  IntPropLevel ipl=IPL_DEF) {
1927  count(home,x,n,IRT_EQ,m,ipl);
1928  }
1933  inline void
1934  exactly(Home home, const IntVarArgs& x, IntVar y, int m,
1935  IntPropLevel ipl=IPL_DEF) {
1936  count(home,x,y,IRT_EQ,m,ipl);
1937  }
1945  inline void
1946  exactly(Home home, const IntVarArgs& x, const IntArgs& y, int m,
1947  IntPropLevel ipl=IPL_DEF) {
1948  count(home,x,y,IRT_EQ,m,ipl);
1949  }
1954  inline void
1955  exactly(Home home, const IntVarArgs& x, int n, IntVar z,
1956  IntPropLevel ipl=IPL_DEF) {
1957  count(home,x,n,IRT_EQ,z,ipl);
1958  }
1963  inline void
1965  IntPropLevel ipl=IPL_DEF) {
1966  count(home,x,y,IRT_EQ,z,ipl);
1967  }
1975  inline void
1976  exactly(Home home, const IntVarArgs& x, const IntArgs& y, IntVar z,
1977  IntPropLevel ipl=IPL_DEF) {
1978  count(home,x,y,IRT_EQ,z,ipl);
1979  }
1982  inline void
1983  lex(Home home, const IntVarArgs& x, IntRelType r, const IntVarArgs& y,
1984  IntPropLevel ipl=IPL_DEF) {
1985  rel(home,x,r,y,ipl);
1986  }
1989  inline void
1990  lex(Home home, const BoolVarArgs& x, IntRelType r, const BoolVarArgs& y,
1991  IntPropLevel ipl=IPL_DEF) {
1992  rel(home,x,r,y,ipl);
1993  }
1996  inline void
1997  values(Home home, const IntVarArgs& x, IntSet y,
1998  IntPropLevel ipl=IPL_DEF) {
1999  dom(home,x,y,ipl);
2000  nvalues(home,x,IRT_EQ,static_cast<int>(y.size()),ipl);
2001  }
2002 
2004 
2005 #ifdef GECODE_HAS_SET_VARS
2006 
2021  inline void
2022  channel(Home home, const IntVarArgs& x, SetVar y) {
2023  rel(home,SOT_UNION,x,y);
2024  nvalues(home,x,IRT_EQ,expr(home,cardinality(y)));
2025  }
2026 
2029  inline void
2030  range(Home home, const IntVarArgs& x, SetVar y, SetVar z) {
2031  element(home,SOT_UNION,x,y,z);
2032  }
2033 
2039  inline void
2040  roots(Home home, const IntVarArgs& x, SetVar y, SetVar z) {
2041  SetVarArgs xiv(home,z.lubMax()+1,IntSet::empty,0,x.size()-1);
2042  channel(home,x,xiv);
2043  element(home,SOT_UNION,xiv,z,y);
2044  }
2045 
2047 #endif
2048 }
2049 
2050 namespace Gecode {
2051 
2052  template<class> class Matrix;
2053 
2061  template<class A>
2062  class Slice {
2063  public:
2066  private:
2067  ArgsType _r;
2068  int _fc,
2069  _tc,
2070  _fr,
2071  _tr;
2072  public:
2074  Slice(const Matrix<A>& a, int fc, int tc, int fr, int tr);
2078  Slice& reverse(void);
2080  operator ArgsType(void);
2082  operator Matrix<ArgsType>(void);
2083 
2085  operator const ArgsType(void) const;
2087  operator const Matrix<ArgsType>(void) const;
2088  };
2089 
2091  template<class A>
2092  typename Slice<A>::ArgsType
2093  operator+(const Slice<A>& x, const Slice<A>& y);
2094 
2096  template<class A>
2097  typename Slice<A>::ArgsType
2098  operator+(const Slice<A>& x, const typename ArrayTraits<A>::ArgsType& y);
2099 
2101  template<class A>
2102  typename Slice<A>::ArgsType
2103  operator+(const typename ArrayTraits<A>::ArgsType& x, const Slice<A>& y);
2104 
2106  template<class A>
2107  typename Slice<A>::ArgsType
2108  operator+(const Slice<A>& x, const typename ArrayTraits<A>::ValueType& y);
2109 
2111  template<class A>
2112  typename Slice<A>::ArgsType
2113  operator+(const typename ArrayTraits<A>::ValueType& x, const Slice<A>& y);
2114 
2125  template<class A>
2126  class Matrix {
2127  public:
2132 
2133  private:
2135  typedef typename ArrayTraits<A>::StorageType StorageType;
2136  StorageType _a;
2137  int _w;
2138  int _h;
2139 
2140  public:
2153  Matrix(A a, int w, int h);
2154 
2167  Matrix(A a, int n);
2168 
2170  int width(void) const;
2172  int height(void) const;
2174  ArgsType const get_array(void) const;
2175 
2181  ValueType& operator ()(int c, int r);
2182 
2188  const ValueType& operator ()(int c, int r) const;
2189 
2199  Slice<A> slice(int fc, int tc, int fr, int tr) const;
2200 
2202  Slice<A> row(int r) const;
2203 
2205  Slice<A> col(int c) const;
2206  };
2207 
2211  template<class Char, class Traits, class A>
2212  std::basic_ostream<Char,Traits>&
2213  operator <<(std::basic_ostream<Char,Traits>& os, const Matrix<A>& m);
2214 
2218  template<class Char, class Traits, class A>
2219  std::basic_ostream<Char,Traits>&
2220  operator <<(std::basic_ostream<Char,Traits>& os, const Slice<A>& s);
2221 
2228  void element(Home home, const Matrix<IntArgs>& m, IntVar x, IntVar y,
2229  IntVar z, IntPropLevel ipl=IPL_DEF);
2236  void element(Home home, const Matrix<IntArgs>& m, IntVar x, IntVar y,
2237  BoolVar z, IntPropLevel ipl=IPL_DEF);
2244  void element(Home home, const Matrix<IntVarArgs>& m, IntVar x, IntVar y,
2245  IntVar z, IntPropLevel ipl=IPL_DEF);
2252  void element(Home home, const Matrix<BoolVarArgs>& m, IntVar x, IntVar y,
2253  BoolVar z, IntPropLevel ipl=IPL_DEF);
2254 #ifdef GECODE_HAS_SET_VARS
2255 
2261  void element(Home home, const Matrix<IntSetArgs>& m, IntVar x, IntVar y,
2262  SetVar z);
2269  void element(Home home, const Matrix<SetVarArgs>& m, IntVar x, IntVar y,
2270  SetVar z);
2271 #endif
2272 
2276  template<class A>
2281  template<class A>
2286  template<class A>
2291  template<class A>
2298  template<class A>
2300 }
2301 
2302 #include <gecode/minimodel/matrix.hpp>
2303 #include <gecode/minimodel/ldsb.hpp>
2304 
2309 namespace Gecode {
2310 
2313  sum(const Slice<IntArgs>& slice);
2316  sum(const Matrix<IntArgs>& matrix);
2317 
2318 }
2321 namespace Gecode {
2322 
2337  public:
2339  IntMinimizeSpace(void);
2344  virtual void constrain(const Space& best);
2346  virtual IntVar cost(void) const = 0;
2347  };
2348 
2354  public:
2356  IntMaximizeSpace(void);
2361  virtual void constrain(const Space& best);
2363  virtual IntVar cost(void) const = 0;
2364  };
2365 
2371  public:
2373  IntLexMinimizeSpace(void);
2378  virtual void constrain(const Space& best);
2380  virtual IntVarArgs cost(void) const = 0;
2381  };
2382 
2388  public:
2390  IntLexMaximizeSpace(void);
2395  virtual void constrain(const Space& best);
2397  virtual IntVarArgs cost(void) const = 0;
2398  };
2399 
2400 #ifdef GECODE_HAS_FLOAT_VARS
2401 
2412  protected:
2415  public:
2422  virtual void constrain(const Space& best);
2424  virtual FloatVar cost(void) const = 0;
2425  };
2426 
2437  protected:
2440  public:
2447  virtual void constrain(const Space& best);
2449  virtual FloatVar cost(void) const = 0;
2450  };
2451 
2452 #endif
2453 
2454 }
2455 
2457 
2458 #endif
2459 
2460 // IFDEF: GECODE_HAS_INT_VARS
2461 // STATISTICS: minimodel-any
2462 
FloatVal operator-(const FloatVal &x)
Definition: val.hpp:172
SetExpr singleton(const LinIntExpr &e)
Singleton expression.
Definition: set-expr.cpp:694
Passing float arguments.
Definition: float.hh:954
Class for minimizing integer cost.
Definition: minimodel.hh:2336
SetRelType srt
Which relation.
Definition: minimodel.hh:1128
NodeType t
Type of node.
Definition: bool-expr.cpp:234
SetRelType
Common relation types for sets.
Definition: set.hh:645
void lex(Home home, const IntVarArgs &x, IntRelType r, const IntVarArgs &y, IntPropLevel ipl=IPL_DEF)
Post lexical order between x and y.
Definition: minimodel.hh:1983
NNF * l
Left subtree.
Definition: bool-expr.cpp:244
Class for lexicographically maximizing integer costs.
Definition: minimodel.hh:2387
int size(void) const
Return size of array (number of elements)
Definition: array.hpp:1657
virtual ~NonLinFloatExpr(void)
Destructor.
Definition: minimodel.hh:702
const int min
Smallest allowed integer in integer set.
Definition: set.hh:103
SetExpr operator&(const SetExpr &l, const SetExpr &r)
Intersection of set expressions.
Definition: set-expr.cpp:674
void log(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
void channel(Home home, FloatVar x0, IntVar x1)
Post propagator for channeling a float and an integer variable .
Definition: channel.cpp:45
const FloatNum max
Largest allowed float value.
Definition: float.hh:848
virtual ~NonLinIntExpr(void)
Destructor.
Definition: minimodel.hh:124
Set relations
Definition: minimodel.hh:1134
void count(Home home, const IntVarArgs &x, int n, IntRelType irt, int m, IntPropLevel)
Post propagator for .
Definition: count.cpp:44
FloatVal operator/(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:217
void rfree(void *p)
Free memory block starting at p.
Definition: heap.hpp:375
FloatNum max(void) const
Return maximum of domain.
Definition: float.hpp:71
Regular expressions over integer values.
Definition: minimodel.hh:1522
Reified linear relation.
Definition: minimodel.hh:1239
Linear term with Boolean variable.
Definition: minimodel.hh:157
void max(Home home, FloatVar x0, FloatVar x1, FloatVar x2)
Post propagator for .
Definition: arithmetic.cpp:53
FloatNum step
Step by which a next solution has to have lower cost.
Definition: minimodel.hh:2439
void abs(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition: arithmetic.cpp:45
Passing float variables.
Definition: float.hh:981
Node for Boolean expression
Definition: bool-expr.cpp:47
Less or equal ( )
Definition: int.hh:907
void nroot(Home home, FloatVar x0, int n, FloatVar x1)
Post propagator for for $n 0$.
Definition: arithmetic.cpp:122
Linear relations over integer variables.
Definition: minimodel.hh:234
void atmost(Home home, const IntVarArgs &x, int n, int m, IntPropLevel ipl=IPL_DEF)
Post constraint .
Definition: minimodel.hh:1803
void pow(Home home, FloatVar x0, int n, FloatVar x1)
Post propagator for for $n 0$.
Definition: arithmetic.cpp:113
void dom(Home home, FloatVar x, FloatVal n)
Propagates .
Definition: dom.cpp:44
Base class for non-linear expressions over integer variables.
Definition: minimodel.hh:113
void * ralloc(size_t s)
Allocate s bytes from heap.
Definition: heap.hpp:361
Addition of linear terms.
Definition: minimodel.hh:161
void roots(Home home, const IntVarArgs &x, SetVar y, SetVar z)
Post constraint .
Definition: minimodel.hh:2040
SymmetryHandle columns_interchange(const Matrix< A > &m)
Interchangeable columns symmetry specification.
Definition: ldsb.hpp:55
Expression information.
Definition: reg.cpp:537
Linear term with variable.
Definition: minimodel.hh:728
Comparison relation (for two-sided comparisons)
Definition: minimodel.hh:1121
const int max
Largest allowed integer in integer set.
Definition: set.hh:101
Linear expression.
Definition: minimodel.hh:1070
Linear term with integer variable.
Definition: minimodel.hh:156
Class for maximizing float cost.
Definition: minimodel.hh:2436
const int max
Largest allowed integer value.
Definition: int.hh:116
Computation spaces.
Definition: core.hpp:1668
Greater or equal ( )
Definition: int.hh:909
Set expressions
Definition: minimodel.hh:1064
const int min
Smallest allowed integer value.
Definition: int.hh:118
BoolExpr operator^(const BoolExpr &l, const BoolExpr &r)
Exclusive-or of Boolean expressions.
Definition: bool-expr.cpp:600
void atleast(Home home, const IntVarArgs &x, int n, int m, IntPropLevel ipl=IPL_DEF)
Post constraint .
Definition: minimodel.hh:1864
ArrayTraits< A >::ValueType ValueType
The type of elements of this array.
Definition: minimodel.hh:2129
Nodes for linear expressions.
Definition: float-expr.cpp:47
Reified linear relation.
Definition: minimodel.hh:1238
SetExpr setdunion(const SetVarArgs &x)
Disjoint union of set variables.
Definition: set-expr.cpp:717
static IntVar result(Home home, IntVar *x)
Return fresh variable if x is NULL, x otherwise.
Definition: minimodel.hh:126
FloatNum min(void) const
Return minimum of domain.
Definition: float.hpp:63
int lubMax(void) const
Return maximum element of least upper bound.
Definition: set.hpp:91
Gecode::FloatVal c(-8, 8)
Single _a(2, 3)
BoolExpr operator&&(const BoolExpr &l, const BoolExpr &r)
Conjunction of Boolean expressions.
Definition: bool-expr.cpp:592
Miscealloneous Boolean expressions.
Definition: minimodel.hh:1244
static FloatVar result(Home home, FloatVar *x)
Return fresh variable if x is NULL, x otherwise.
Definition: minimodel.hh:704
Deterministic finite automaton (DFA)
Definition: int.hh:2027
int p
Number of positive literals for node type.
Definition: bool-expr.cpp:236
const FloatNum min
Smallest allowed float value.
Definition: float.hh:850
A slice of a matrix.
Definition: minimodel.hh:2062
Gecode::IntArgs i(4, 1, 2, 3, 4)
IntRelType neg(IntRelType irt)
Return negated relation type of irt.
Definition: irt.hpp:56
int n
Number of negative literals for node type.
Definition: bool-expr.cpp:238
Equality ( )
Definition: int.hh:905
Base class for non-linear float expressions.
Definition: minimodel.hh:692
A reference-counted pointer to a SymmetryObject.
Definition: int.hh:4985
void nvalues(Home home, const IntVarArgs &x, IntRelType irt, int y, IntPropLevel)
Post propagator for .
Definition: nvalues.cpp:44
Nodes for linear expressions.
Definition: int-expr.cpp:44
IntRelType
Relation types for integers.
Definition: int.hh:904
FloatVal operator+(const FloatVal &x)
Definition: val.hpp:168
static IntVar result(Home home, IntVar *x, IntVar y)
Constrain x to be equal to y if x is not NULL.
Definition: minimodel.hh:132
void sqr(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition: arithmetic.cpp:99
FloatRelType
Relation types for floats.
Definition: float.hh:1069
Linear relations.
Definition: minimodel.hh:796
bool operator!=(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:321
Simple propagation levels.
Definition: int.hh:955
unsigned int size(void) const
Return size (cardinality) of set.
Definition: int-set-1.hpp:161
SetExpr r
Right side of relation.
Definition: minimodel.hh:1126
void sqrt(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition: arithmetic.cpp:106
unsigned int size(I &i)
Size of all ranges of range iterator i.
static FloatVar result(Home home, FloatVar *x, FloatVar y)
Constrain x to be equal to y if x is not NULL.
Definition: minimodel.hh:710
void range(Home home, const IntVarArgs &x, SetVar y, SetVar z)
Post constraint .
Definition: minimodel.hh:2030
Class for lexicographically minimizing integer costs.
Definition: minimodel.hh:2370
Reified set relation.
Definition: minimodel.hh:1240
ArrayTraits< A >::ArgsType ArgsType
The type of the Args-array type for ValueType values.
Definition: minimodel.hh:2131
union Gecode::@585::NNF::@62 u
Union depending on nodetype t.
Subtraction of linear terms.
Definition: minimodel.hh:732
Float expressions
Definition: minimodel.hh:722
NodeType
Type of set expression.
Definition: minimodel.hh:1067
Integer sets.
Definition: int.hh:174
NodeType
Type of linear expression.
Definition: minimodel.hh:154
Post propagator for SetVar SetOpType SetVar SetRelType SetVar z
Definition: set.hh:769
SetExpr setunion(const SetVarArgs &x)
Union of set variables.
Definition: set-expr.cpp:708
Boolean expressions.
Definition: minimodel.hh:1229
void asin(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
SetExpr l
Left side of relation.
Definition: minimodel.hh:1124
Passing integer variables.
Definition: int.hh:637
Passing integer arguments.
Definition: int.hh:608
NodeType
Type of linear expression.
Definition: minimodel.hh:726
Passing Boolean variables.
Definition: int.hh:691
Equality ( )
Definition: float.hh:1070
Non-linear expression.
Definition: minimodel.hh:158
static const IntSet empty
Empty set.
Definition: int.hh:263
BoolVar expr(Home home, const BoolExpr &e, IntPropLevel ipl)
Post Boolean expression and return its value.
Definition: bool-expr.cpp:632
SymmetryHandle columns_reflect(const Matrix< A > &m)
Reflect columns symmetry specification.
Definition: ldsb.hpp:89
Boolean integer variables.
Definition: int.hh:492
LinIntExpr cardinality(const SetExpr &e)
Cardinality of set expression.
Definition: set-expr.cpp:818
Post propagator for SetVar SetOpType SetVar SetRelType r
Definition: set.hh:769
SetExpr inter(const SetVarArgs &x)
Intersection of set variables.
Definition: set-expr.cpp:699
void min(Home home, FloatVar x0, FloatVar x1, FloatVar x2)
Post propagator for .
Definition: arithmetic.cpp:71
Archive & operator>>(Archive &e, FloatNumBranch &nl)
Definition: val-sel.hpp:48
ArrayTraits< A >::ArgsType ArgsType
The type of the Args-array type for ValueType values.
Definition: minimodel.hh:2065
void cos(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
IntPropLevel
Propagation levels for integer propagators.
Definition: int.hh:953
Union.
Definition: set.hh:663
void print(std::basic_ostream< Char, Traits > &s, bool assigned, IL &lb, IU &ub, unsigned int cardMin, unsigned int cardMax)
Print set view.
Definition: print.hpp:67
struct Gecode::@585::NNF::@62::@63 b
For binary nodes (and, or, eqv)
Passing set variables.
Definition: set.hh:492
Post propagator for f(x \diamond_{\mathit{op}} y) \sim_r z \f$ void rel(Home home
Sum of float variables.
Definition: minimodel.hh:730
Post propagator for SetVar SetOpType SetVar y
Definition: set.hh:769
Class for maximizing integer cost.
Definition: minimodel.hh:2353
Non-linear expression.
Definition: minimodel.hh:729
NodeType
Type of Boolean expression.
Definition: minimodel.hh:1232
Float value type.
Definition: float.hh:338
FloatVal operator*(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:204
SymmetryHandle diagonal_reflect(const Matrix< A > &m)
Reflect around main diagonal symmetry specification.
Definition: ldsb.hpp:112
Set variables
Definition: set.hh:131
Node for set expression
Definition: set-expr.cpp:55
struct Gecode::@585::NNF::@62::@64 a
For atomic nodes.
Sum of integer variables.
Definition: minimodel.hh:159
Linear expressions over integer variables.
Definition: minimodel.hh:144
void tan(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
bool operator>=(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:281
Integer variables.
Definition: int.hh:351
Heap heap
The single global heap.
Definition: heap.cpp:48
void rel(Home home, FloatVar x0, FloatRelType frt, FloatVal n)
Propagates .
Definition: rel.cpp:47
Sum of Boolean variables.
Definition: minimodel.hh:160
SymmetryHandle rows_interchange(const Matrix< A > &m)
Interchangeable rows symmetry specification.
Definition: ldsb.hpp:44
Subtraction of linear terms.
Definition: minimodel.hh:162
BoolExpr operator!(const BoolExpr &e)
Negated Boolean expression.
Definition: bool-expr.cpp:605
void values(Home home, const IntVarArgs &x, IntSet y, IntPropLevel ipl=IPL_DEF)
Post constraint .
Definition: minimodel.hh:1997
Post propagator for SetVar x
Definition: set.hh:769
LinIntExpr operator%(const LinIntExpr &e0, const LinIntExpr &e1)
Return expression for .
Definition: int-arith.cpp:456
Archive & operator<<(Archive &e, FloatNumBranch nl)
Definition: val-sel.hpp:43
Implementation of the actual expression tree.
Definition: reg.cpp:56
#define GECODE_MINIMODEL_EXPORT
Definition: minimodel.hh:82
Matrix-interface for arrays.
Definition: minimodel.hh:2052
Float variables.
Definition: float.hh:874
bool operator>(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:264
SetExpr operator|(const SetExpr &l, const SetExpr &r)
Union of set expressions.
Definition: set-expr.cpp:678
Integer constant.
Definition: minimodel.hh:155
bool operator<(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:230
bool operator==(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:298
Addition of linear terms.
Definition: minimodel.hh:731
Traits of arrays in Gecode.
Definition: array.hpp:68
bool operator<=(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:247
Float value constant.
Definition: minimodel.hh:727
Class for minimizing float cost.
Definition: minimodel.hh:2411
Gecode toplevel namespace
LinFloatExpr sum(const FloatVarArgs &x)
Construct linear float expression as sum of float variables.
Definition: float-expr.cpp:548
void sin(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
#define GECODE_VTABLE_EXPORT
Definition: support.hh:76
void acos(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
void exp(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Home class for posting propagators
Definition: core.hpp:846
Base class for heap allocated objects.
Definition: heap.hpp:344
double FloatNum
Floating point number base type.
Definition: float.hh:110
void exactly(Home home, const IntVarArgs &x, int n, int m, IntPropLevel ipl=IPL_DEF)
Post constraint .
Definition: minimodel.hh:1925
const unsigned int slice
Size of a slice in a portfolio and scale factor for restarts(in number of failures) ...
Definition: search.hh:130
FloatNum step
Step by which a next solution has to have lower cost.
Definition: minimodel.hh:2414
void ite(Home home, BoolVar b, FloatVar x, FloatVar y, FloatVar z)
Post propagator for if-then-else constraint.
Definition: bool.cpp:43
void element(Home home, IntSharedArray c, IntVar x0, IntVar x1, IntPropLevel)
Post domain consistent propagator for .
Definition: element.cpp:43
void atan(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
BoolExpr operator||(const BoolExpr &l, const BoolExpr &r)
Disjunction of Boolean expressions.
Definition: bool-expr.cpp:596
TFE post(PropagatorGroup g)
Only post functions (but not propagators) from g are considered.
Definition: filter.cpp:142
SymmetryHandle rows_reflect(const Matrix< A > &m)
Reflect rows symmetry specification.
Definition: ldsb.hpp:66