Generated on Fri Jan 28 2022 04:43:06 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  * 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_MINIMODEL_HH__
43 #define __GECODE_MINIMODEL_HH__
44 
45 #include <gecode/kernel.hh>
46 #include <gecode/int.hh>
47 #ifdef GECODE_HAS_SET_VARS
48 #include <gecode/set.hh>
49 #endif
50 #ifdef GECODE_HAS_FLOAT_VARS
51 #include <gecode/float.hh>
52 #endif
53 
54 #include <iostream>
55 
56 /*
57  * Support for DLLs under Windows
58  *
59  */
60 
61 #if !defined(GECODE_STATIC_LIBS) && \
62  (defined(__CYGWIN__) || defined(__MINGW32__) || defined(_MSC_VER))
63 
64 #ifdef GECODE_BUILD_MINIMODEL
65 #define GECODE_MINIMODEL_EXPORT __declspec( dllexport )
66 #else
67 #define GECODE_MINIMODEL_EXPORT __declspec( dllimport )
68 #endif
69 
70 #else
71 
72 #ifdef GECODE_GCC_HAS_CLASS_VISIBILITY
73 
74 #define GECODE_MINIMODEL_EXPORT __attribute__ ((visibility("default")))
75 
76 #else
77 
78 #define GECODE_MINIMODEL_EXPORT
79 
80 #endif
81 #endif
82 
83 // Configure auto-linking
84 #ifndef GECODE_BUILD_MINIMODEL
85 #define GECODE_LIBRARY_NAME "MiniModel"
87 #endif
88 
89 namespace Gecode {
90 
92  namespace MiniModel {}
93 
94 }
95 
97 
98 namespace Gecode {
99 
100  class LinIntRel;
101 #ifdef GECODE_HAS_SET_VARS
102  class SetExpr;
103 #endif
104 #ifdef GECODE_HAS_FLOAT_VARS
105  class LinFloatExpr;
106 #endif
107 
110  public:
112  virtual IntVar post(Home home, IntVar* ret, IntPropLevel ipl) const = 0;
114  virtual void post(Home home, IntRelType irt, int c,
115  IntPropLevel ipl) const = 0;
117  virtual void post(Home home, IntRelType irt, int c,
118  BoolVar b, IntPropLevel ipl) const = 0;
120  virtual ~NonLinIntExpr(void) {}
122  static IntVar result(Home home, IntVar* x) {
123  if (x==NULL)
125  return *x;
126  }
128  static IntVar result(Home home, IntVar* x, IntVar y) {
129  if (x!=NULL)
130  rel(home,*x,IRT_EQ,y);
131  return y;
132  }
134  void* operator new(size_t size) { return heap.ralloc(size); }
136  void operator delete(void* p, size_t) { heap.rfree(p); }
137  };
138 
140  class LinIntExpr {
141  friend class LinIntRel;
142 #ifdef GECODE_HAS_SET_VARS
143  friend class SetExpr;
144 #endif
145 #ifdef GECODE_HAS_FLOAT_VARS
146  friend class LinFloatExpr;
147 #endif
148  public:
150  enum NodeType {
159  NT_MUL
160  };
161  private:
163  class Node;
165  Node* n;
166  public:
169  LinIntExpr(void);
172  LinIntExpr(int c);
175  LinIntExpr(const IntVar& x, int a=1);
178  LinIntExpr(const BoolVar& x, int a=1);
181  explicit LinIntExpr(const IntVarArgs& x);
184  LinIntExpr(const IntArgs& a, const IntVarArgs& x);
187  explicit LinIntExpr(const BoolVarArgs& x);
190  LinIntExpr(const IntArgs& a, const BoolVarArgs& x);
193  LinIntExpr(const LinIntExpr& e);
196  LinIntExpr(const LinIntExpr& e0, NodeType t, const LinIntExpr& e1);
199  LinIntExpr(const LinIntExpr& e0, NodeType t, int c);
202  LinIntExpr(int a, const LinIntExpr& e);
205  explicit LinIntExpr(NonLinIntExpr* e);
208  const LinIntExpr& operator =(const LinIntExpr& e);
211  void post(Home home, IntRelType irt, IntPropLevel ipl) const;
214  void post(Home home, IntRelType irt, const BoolVar& b,
215  IntPropLevel ipl) const;
218  IntVar post(Home home, IntPropLevel ipl) const;
221  NonLinIntExpr* nle(void) const;
224  ~LinIntExpr(void);
225  };
226 
227  class BoolExpr;
228 
230  class LinIntRel {
231  friend class BoolExpr;
232  private:
234  LinIntExpr e;
236  IntRelType irt;
238  static IntRelType neg(IntRelType irt);
240  LinIntRel(void);
241  public:
243  LinIntRel(const LinIntExpr& l, IntRelType irt, const LinIntExpr& r);
245  LinIntRel(const LinIntExpr& l, IntRelType irt, int r);
247  LinIntRel(int l, IntRelType irt, const LinIntExpr& r);
249  void post(Home home, bool t, IntPropLevel ipl) const;
251  void post(Home home, const BoolVar& b, bool t, IntPropLevel ipl) const;
252  };
253 
274  operator +(int, const IntVar&);
277  operator +(int, const BoolVar&);
280  operator +(int, const LinIntExpr&);
283  operator +(const IntVar&, int);
286  operator +(const BoolVar&, int);
289  operator +(const LinIntExpr&, int);
292  operator +(const IntVar&, const IntVar&);
295  operator +(const IntVar&, const BoolVar&);
298  operator +(const BoolVar&, const IntVar&);
301  operator +(const BoolVar&, const BoolVar&);
304  operator +(const IntVar&, const LinIntExpr&);
307  operator +(const BoolVar&, const LinIntExpr&);
310  operator +(const LinIntExpr&, const IntVar&);
313  operator +(const LinIntExpr&, const BoolVar&);
316  operator +(const LinIntExpr&, const LinIntExpr&);
317 
320  operator -(int, const IntVar&);
323  operator -(int, const BoolVar&);
326  operator -(int, const LinIntExpr&);
329  operator -(const IntVar&, int);
332  operator -(const BoolVar&, int);
335  operator -(const LinIntExpr&, int);
338  operator -(const IntVar&, const IntVar&);
341  operator -(const IntVar&, const BoolVar&);
344  operator -(const BoolVar&, const IntVar&);
347  operator -(const BoolVar&, const BoolVar&);
350  operator -(const IntVar&, const LinIntExpr&);
353  operator -(const BoolVar&, const LinIntExpr&);
356  operator -(const LinIntExpr&, const IntVar&);
359  operator -(const LinIntExpr&, const BoolVar&);
362  operator -(const LinIntExpr&, const LinIntExpr&);
363 
366  operator -(const IntVar&);
369  operator -(const BoolVar&);
372  operator -(const LinIntExpr&);
373 
376  operator *(int, const IntVar&);
379  operator *(int, const BoolVar&);
382  operator *(const IntVar&, int);
385  operator *(const BoolVar&, int);
388  operator *(const LinIntExpr&, int);
391  operator *(int, const LinIntExpr&);
392 
395  sum(const IntVarArgs& x);
398  sum(const IntArgs& a, const IntVarArgs& x);
401  sum(const BoolVarArgs& x);
404  sum(const IntArgs& a, const BoolVarArgs& x);
407  sum(const IntArgs& args);
408 
411  operator ==(int l, const IntVar& r);
414  operator ==(int l, const BoolVar& r);
417  operator ==(int l, const LinIntExpr& r);
420  operator ==(const IntVar& l, int r);
423  operator ==(const BoolVar& l, int r);
426  operator ==(const LinIntExpr& l, int r);
429  operator ==(const IntVar& l, const IntVar& r);
432  operator ==(const IntVar& l, const BoolVar& r);
435  operator ==(const BoolVar& l, const IntVar& r);
438  operator ==(const BoolVar& l, const BoolVar& r);
441  operator ==(const IntVar& l, const LinIntExpr& r);
444  operator ==(const BoolVar& l, const LinIntExpr& r);
447  operator ==(const LinIntExpr& l, const IntVar& r);
450  operator ==(const LinIntExpr& l, const BoolVar& r);
453  operator ==(const LinIntExpr& l, const LinIntExpr& r);
454 
457  operator !=(int l, const IntVar& r);
460  operator !=(int l, const BoolVar& r);
463  operator !=(int l, const LinIntExpr& r);
466  operator !=(const IntVar& l, int r);
469  operator !=(const BoolVar& l, int r);
472  operator !=(const LinIntExpr& l, int r);
475  operator !=(const IntVar& l, const IntVar& r);
478  operator !=(const IntVar& l, const BoolVar& r);
481  operator !=(const BoolVar& l, const IntVar& r);
484  operator !=(const BoolVar& l, const BoolVar& r);
487  operator !=(const IntVar& l, const LinIntExpr& r);
490  operator !=(const BoolVar& l, const LinIntExpr& r);
493  operator !=(const LinIntExpr& l, const IntVar& r);
496  operator !=(const LinIntExpr& l, const BoolVar& r);
499  operator !=(const LinIntExpr& l, const LinIntExpr& r);
500 
503  operator <(int l, const IntVar& r);
506  operator <(int l, const BoolVar& r);
509  operator <(int l, const LinIntExpr& r);
512  operator <(const IntVar& l, int r);
515  operator <(const BoolVar& l, int r);
518  operator <(const LinIntExpr& l, int r);
521  operator <(const IntVar& l, const IntVar& r);
524  operator <(const IntVar& l, const BoolVar& r);
527  operator <(const BoolVar& l, const IntVar& r);
530  operator <(const BoolVar& l, const BoolVar& r);
533  operator <(const IntVar& l, const LinIntExpr& r);
536  operator <(const BoolVar& l, const LinIntExpr& r);
539  operator <(const LinIntExpr& l, const IntVar& r);
542  operator <(const LinIntExpr& l, const BoolVar& r);
545  operator <(const LinIntExpr& l, const LinIntExpr& r);
546 
549  operator <=(int l, const IntVar& r);
552  operator <=(int l, const BoolVar& r);
555  operator <=(int l, const LinIntExpr& r);
558  operator <=(const IntVar& l, int r);
561  operator <=(const BoolVar& l, int r);
564  operator <=(const LinIntExpr& l, int r);
567  operator <=(const IntVar& l, const IntVar& r);
570  operator <=(const IntVar& l, const BoolVar& r);
573  operator <=(const BoolVar& l, const IntVar& r);
576  operator <=(const BoolVar& l, const BoolVar& r);
579  operator <=(const IntVar& l, const LinIntExpr& r);
582  operator <=(const BoolVar& l, const LinIntExpr& r);
585  operator <=(const LinIntExpr& l, const IntVar& r);
588  operator <=(const LinIntExpr& l, const BoolVar& r);
591  operator <=(const LinIntExpr& l, const LinIntExpr& r);
592 
595  operator >(int l, const IntVar& r);
598  operator >(int l, const BoolVar& r);
601  operator >(int l, const LinIntExpr& r);
604  operator >(const IntVar& l, int r);
607  operator >(const BoolVar& l, int r);
610  operator >(const LinIntExpr& l, int r);
613  operator >(const IntVar& l, const IntVar& r);
616  operator >(const IntVar& l, const BoolVar& r);
619  operator >(const BoolVar& l, const IntVar& r);
622  operator >(const BoolVar& l, const BoolVar& r);
625  operator >(const IntVar& l, const LinIntExpr& r);
628  operator >(const BoolVar& l, const LinIntExpr& r);
631  operator >(const LinIntExpr& l, const IntVar& r);
634  operator >(const LinIntExpr& l, const BoolVar& r);
637  operator >(const LinIntExpr& l, const LinIntExpr& r);
638 
641  operator >=(int l, const IntVar& r);
644  operator >=(int l, const BoolVar& r);
647  operator >=(int l, const LinIntExpr& r);
650  operator >=(const IntVar& l, int r);
653  operator >=(const BoolVar& l, int r);
656  operator >=(const LinIntExpr& l, int r);
659  operator >=(const IntVar& l, const IntVar& r);
662  operator >=(const IntVar& l, const BoolVar& r);
665  operator >=(const BoolVar& l, const IntVar& r);
668  operator >=(const BoolVar& l, const BoolVar& r);
671  operator >=(const IntVar& l, const LinIntExpr& r);
674  operator >=(const BoolVar& l, const LinIntExpr& r);
677  operator >=(const LinIntExpr& l, const IntVar& r);
680  operator >=(const LinIntExpr& l, const BoolVar& r);
683  operator >=(const LinIntExpr& l, const LinIntExpr& r);
685 
686 #ifdef GECODE_HAS_FLOAT_VARS
687  class NonLinFloatExpr {
689  public:
691  virtual FloatVar post(Home home, FloatVar* ret) const = 0;
693  virtual void post(Home home, FloatRelType frt, FloatVal c) const = 0;
695  virtual void post(Home home, FloatRelType frt, FloatVal c,
696  BoolVar b) const = 0;
698  virtual ~NonLinFloatExpr(void) {}
700  static FloatVar result(Home home, FloatVar* x) {
701  if (x == NULL)
703  return *x;
704  }
706  static FloatVar result(Home home, FloatVar* x, FloatVar y) {
707  if (x!=NULL)
708  rel(home,*x,FRT_EQ,y);
709  return y;
710  }
712  void* operator new(size_t size) { return heap.ralloc(size); }
714  void operator delete(void* p, size_t) { heap.rfree(p); }
715  };
716 
718  class LinFloatExpr {
719  friend class LinFloatRel;
720  public:
722  enum NodeType {
729  NT_MUL
730  };
731  private:
733  class Node;
734  Node* n;
735  public:
738  LinFloatExpr(void);
741  LinFloatExpr(const FloatVal& c);
744  LinFloatExpr(const FloatVar& x);
747  LinFloatExpr(const FloatVar& x, FloatVal a);
750  explicit LinFloatExpr(const FloatVarArgs& x);
753  LinFloatExpr(const FloatValArgs& a, const FloatVarArgs& x);
756  LinFloatExpr(const LinFloatExpr& e);
759  LinFloatExpr(const LinFloatExpr& e0, NodeType t, const LinFloatExpr& e1);
762  LinFloatExpr(const LinFloatExpr& e0, NodeType t, const FloatVal& c);
765  LinFloatExpr(FloatVal a, const LinFloatExpr& e);
768  explicit LinFloatExpr(NonLinFloatExpr* e);
771  const LinFloatExpr& operator =(const LinFloatExpr& e);
774  void post(Home home, FloatRelType frt) const;
777  void post(Home home, FloatRelType frt, const BoolVar& b) const;
780  FloatVar post(Home home) const;
783  NonLinFloatExpr* nlfe(void) const;
786  ~LinFloatExpr(void);
787  };
788 
789  class BoolExpr;
790 
792  class LinFloatRel {
793  friend class BoolExpr;
794  private:
796  LinFloatExpr e;
798  FloatRelType frt;
800  static FloatRelType neg(FloatRelType frt);
802  LinFloatRel(void);
803  public:
805  LinFloatRel(const LinFloatExpr& l, FloatRelType frt, const LinFloatExpr& r);
811  void post(Home home, bool t) const;
813  void post(Home home, const BoolVar& b, bool t) const;
814  };
815 
831  operator +(const FloatVal&, const FloatVar&);
834  operator +(const FloatVal&, const LinFloatExpr&);
837  operator +(const FloatVar&, const FloatVal&);
840  operator +(const LinFloatExpr&, const FloatVal&);
843  operator +(const FloatVar&, const FloatVar&);
846  operator +(const FloatVar&, const LinFloatExpr&);
849  operator +(const LinFloatExpr&, const FloatVar&);
852  operator +(const LinFloatExpr&, const LinFloatExpr&);
853 
856  operator -(const FloatVal&, const FloatVar&);
859  operator -(const FloatVal&, const LinFloatExpr&);
862  operator -(const FloatVar&, const FloatVal&);
865  operator -(const LinFloatExpr&, const FloatVal&);
868  operator -(const FloatVar&, const FloatVar&);
871  operator -(const FloatVar&, const LinFloatExpr&);
874  operator -(const LinFloatExpr&, const FloatVar&);
877  operator -(const LinFloatExpr&, const LinFloatExpr&);
878 
881  operator -(const FloatVar&);
884  operator -(const LinFloatExpr&);
885 
888  operator *(const FloatVal&, const FloatVar&);
891  operator *(const FloatVar&, const FloatVal&);
894  operator *(const LinFloatExpr&, const FloatVal&);
897  operator *(const FloatVal&, const LinFloatExpr&);
898 
901  sum(const FloatVarArgs& x);
904  sum(const FloatValArgs& a, const FloatVarArgs& x);
905 
908  operator ==(const FloatVal& l, const FloatVar& r);
911  operator ==(const FloatVal& l, const LinFloatExpr& r);
914  operator ==(const FloatVar& l, const FloatVal& r);
917  operator ==(const LinFloatExpr& l, const FloatVal& r);
920  operator ==(const FloatVar& l, const FloatVar& r);
923  operator ==(const FloatVar& l, const LinFloatExpr& r);
926  operator ==(const LinFloatExpr& l, const FloatVar& r);
929  operator ==(const LinFloatExpr& l, const LinFloatExpr& r);
930 
933  operator !=(const FloatVal& l, const FloatVar& r);
936  operator !=(const FloatVal& l, const LinFloatExpr& r);
939  operator !=(const FloatVar& l, const FloatVal& r);
942  operator !=(const LinFloatExpr& l, const FloatVal& r);
945  operator !=(const FloatVar& l, const FloatVar& r);
948  operator !=(const FloatVar& l, const LinFloatExpr& r);
951  operator !=(const LinFloatExpr& l, const FloatVar& r);
954  operator !=(const LinFloatExpr& l, const LinFloatExpr& r);
955 
958  operator <(const FloatVal& l, const FloatVar& r);
961  operator <(const FloatVal& l, const LinFloatExpr& r);
964  operator <(const FloatVar& l, const FloatVal& r);
967  operator <(const LinFloatExpr& l, const FloatVal& r);
970  operator <(const FloatVar& l, const FloatVar& r);
973  operator <(const FloatVar& l, const LinFloatExpr& r);
976  operator <(const LinFloatExpr& l, const FloatVar& r);
979  operator <(const LinFloatExpr& l, const LinFloatExpr& r);
980 
983  operator <=(const FloatVal& l, const FloatVar& r);
986  operator <=(const FloatVal& l, const LinFloatExpr& r);
989  operator <=(const FloatVar& l, const FloatVal& r);
992  operator <=(const LinFloatExpr& l, const FloatVal& r);
995  operator <=(const FloatVar& l, const FloatVar& r);
998  operator <=(const FloatVar& l, const LinFloatExpr& r);
1001  operator <=(const LinFloatExpr& l, const FloatVar& r);
1004  operator <=(const LinFloatExpr& l, const LinFloatExpr& r);
1005 
1008  operator >(const FloatVal& l, const FloatVar& r);
1011  operator >(const FloatVal& l, const LinFloatExpr& r);
1014  operator >(const FloatVar& l, const FloatVal& r);
1017  operator >(const LinFloatExpr& l, const FloatVal& r);
1020  operator >(const FloatVar& l, const FloatVar& r);
1023  operator >(const FloatVar& l, const LinFloatExpr& r);
1026  operator >(const LinFloatExpr& l, const FloatVar& r);
1029  operator >(const LinFloatExpr& l, const LinFloatExpr& r);
1030 
1033  operator >=(const FloatVal& l, const FloatVar& r);
1036  operator >=(const FloatVal& l, const LinFloatExpr& r);
1039  operator >=(const FloatVar& l, const FloatVal& r);
1042  operator >=(const LinFloatExpr& l, const FloatVal& r);
1045  operator >=(const FloatVar& l, const FloatVar& r);
1048  operator >=(const FloatVar& l, const LinFloatExpr& r);
1051  operator >=(const LinFloatExpr& l, const FloatVar& r);
1054  operator >=(const LinFloatExpr& l, const LinFloatExpr& r);
1056 #endif
1057 
1058 #ifdef GECODE_HAS_SET_VARS
1059  class SetExpr {
1061  public:
1063  enum NodeType {
1070  NT_DUNION
1071  };
1073  class Node;
1074  private:
1076  Node* n;
1077  public:
1079  SetExpr(void);
1082  SetExpr(const SetExpr& e);
1085  SetExpr(const SetExpr& l, NodeType t, const SetExpr& r);
1088  SetExpr(const SetVar& x);
1091  explicit SetExpr(const LinIntExpr& x);
1094  SetExpr(const IntSet& s);
1097  SetExpr(const SetExpr& e, NodeType t);
1100  SetVar post(Home home) const;
1103  void post(Home home, SetRelType srt, const SetExpr& e) const;
1106  void post(Home home, BoolVar b, bool t,
1107  SetRelType srt, const SetExpr& e) const;
1110  const SetExpr& operator =(const SetExpr& e);
1113  ~SetExpr(void);
1114  };
1115 
1117  class SetCmpRel {
1118  public:
1126  SetCmpRel(const SetExpr& l, SetRelType srt, const SetExpr& r);
1127  };
1128 
1130  class SetRel {
1131  private:
1133  SetExpr _e0;
1135  SetRelType _srt;
1137  SetExpr _e1;
1138  public:
1140  SetRel(void);
1142  SetRel(const SetExpr& e0, SetRelType srt, const SetExpr& e1);
1144  SetRel(const SetCmpRel& r);
1146  void post(Home home, bool t) const;
1148  void post(Home home, BoolVar b, bool t) const;
1149  };
1150 
1163  singleton(const LinIntExpr&);
1166  operator -(const SetExpr&);
1169  operator &(const SetExpr&, const SetExpr&);
1172  operator |(const SetExpr&, const SetExpr&);
1175  operator +(const SetExpr&, const SetExpr&);
1178  operator -(const SetExpr&, const SetExpr&);
1179 
1182  inter(const SetVarArgs&);
1185  setunion(const SetVarArgs&);
1188  setdunion(const SetVarArgs&);
1189 
1192  cardinality(const SetExpr&);
1195  min(const SetExpr&);
1198  max(const SetExpr&);
1199 
1202  operator ==(const SetExpr&, const SetExpr&);
1205  operator !=(const SetExpr&, const SetExpr&);
1208  operator <=(const SetExpr&, const SetExpr&);
1211  operator <=(const SetCmpRel&, const SetExpr&);
1214  operator >=(const SetExpr&, const SetExpr&);
1217  operator >=(const SetCmpRel&, const SetExpr&);
1220  operator ||(const SetExpr&, const SetExpr&);
1222 #endif
1223 
1225  class BoolExpr {
1226  public:
1228  enum NodeType {
1237  NT_MISC
1238  };
1241  public:
1243  Misc(void);
1248  virtual void post(Home home, BoolVar b, bool neg,
1249  IntPropLevel ipl) = 0;
1251  virtual GECODE_MINIMODEL_EXPORT ~Misc(void);
1252  };
1254  class Node;
1255  private:
1257  Node* n;
1258  public:
1261  BoolExpr(void);
1264  BoolExpr(const BoolExpr& e);
1267  BoolExpr(const BoolExpr& l, NodeType t, const BoolExpr& r);
1270  BoolExpr(const BoolVar& x);
1273  BoolExpr(const BoolExpr& e, NodeType t);
1276  BoolExpr(const LinIntRel& rl);
1277 #ifdef GECODE_HAS_FLOAT_VARS
1280  BoolExpr(const LinFloatRel& rfl);
1281 #endif
1282 #ifdef GECODE_HAS_SET_VARS
1285  BoolExpr(const SetRel& rs);
1288  BoolExpr(const SetCmpRel& rs);
1289 #endif
1292  explicit BoolExpr(Misc* m);
1295  BoolVar expr(Home home, IntPropLevel ipl) const;
1298  void rel(Home home, IntPropLevel ipl) const;
1301  const BoolExpr& operator =(const BoolExpr& e);
1304  ~BoolExpr(void);
1305  };
1306 
1319  operator !(const BoolExpr&);
1322  operator &&(const BoolExpr&, const BoolExpr&);
1325  operator ||(const BoolExpr&, const BoolExpr&);
1328  operator ^(const BoolExpr&, const BoolExpr&);
1329 
1332  operator !=(const BoolExpr&, const BoolExpr&);
1335  operator ==(const BoolExpr&, const BoolExpr&);
1338  operator >>(const BoolExpr&, const BoolExpr&);
1341  operator <<(const BoolExpr&, const BoolExpr&);
1342 
1344 
1354  dom(const IntVar& x, int n);
1357  dom(const IntVar& x, int l, int m);
1360  dom(const IntVar& x, const IntSet& s);
1361 
1362 #ifdef GECODE_HAS_SET_VARS
1365  dom(const SetVar& x, SetRelType rt, int i);
1368  dom(const SetVar& x, SetRelType rt, int i, int j);
1371  dom(const SetVar& x, SetRelType rt, const IntSet& s);
1372 #endif
1373 
1374 #ifdef GECODE_HAS_FLOAT_VARS
1377  dom(const FloatVar& x, const FloatVal& n);
1380  dom(const FloatVar& x, FloatNum l, FloatNum u);
1381 #endif
1382 
1383 
1391 #ifdef GECODE_HAS_SET_VARS
1394  operator ==(const SetExpr& s, const LinIntExpr& x);
1397  operator ==(const LinIntExpr& x, const SetExpr& s);
1399  BoolExpr
1400  operator ==(const LinIntExpr&, IntSet) = delete;
1402  BoolExpr
1403  operator ==(IntSet, const LinIntExpr&) = delete;
1404 
1407  operator !=(const SetExpr& s, const LinIntExpr& x);
1410  operator !=(const LinIntExpr& x, const SetExpr& s);
1412  BoolExpr
1413  operator !=(const LinIntExpr&, IntSet) = delete;
1415  BoolExpr
1416  operator !=(IntSet, const LinIntExpr&) = delete;
1417 
1420  operator <=(const SetExpr& s, const LinIntExpr& x);
1423  operator <=(const LinIntExpr& x, const SetExpr& s);
1425  BoolExpr
1426  operator <=(const LinIntExpr&, IntSet) = delete;
1428  BoolExpr
1429  operator <=(IntSet, const LinIntExpr&) = delete;
1430 
1433  operator <(const SetExpr& s, const LinIntExpr& x);
1436  operator <(const LinIntExpr& x, const SetExpr& s);
1438  BoolExpr
1439  operator <(const LinIntExpr&, IntSet) = delete;
1441  BoolExpr
1442  operator <(IntSet, const LinIntExpr&) = delete;
1443 
1446  operator >=(const SetExpr& s, const LinIntExpr& x);
1449  operator >=(const LinIntExpr& x, const SetExpr& s);
1451  BoolExpr
1452  operator >=(const LinIntExpr&, IntSet) = delete;
1454  BoolExpr
1455  operator >=(IntSet, const LinIntExpr&) = delete;
1456 
1459  operator >(const SetExpr& s, const LinIntExpr& x);
1462  operator >(const LinIntExpr& x, const SetExpr& s);
1464  BoolExpr
1465  operator >(const LinIntExpr&, IntSet) = delete;
1467  BoolExpr
1468  operator >(IntSet, const LinIntExpr&) = delete;
1469 #endif
1470 
1471 
1480  expr(Home home, const LinIntExpr& e, IntPropLevel ipl=IPL_DEF);
1481 #ifdef GECODE_HAS_FLOAT_VARS
1484  expr(Home home, const LinFloatExpr& e);
1485 #endif
1486 #ifdef GECODE_HAS_SET_VARS
1489  expr(Home home, const SetExpr& e);
1490 #endif
1493  expr(Home home, const BoolExpr& e, IntPropLevel ipl=IPL_DEF);
1496  rel(Home home, const BoolExpr& e, IntPropLevel ipl=IPL_DEF);
1498 
1499 }
1500 
1506 
1507 namespace Gecode {
1508 
1509  namespace MiniModel {
1510  class ExpInfo;
1511  }
1512 
1519  friend class MiniModel::ExpInfo;
1520  private:
1522  class Exp;
1524  Exp* e;
1526  REG(Exp* e);
1528  std::string toString(void) const;
1529  public:
1531  REG(void);
1533  REG(int s);
1540  REG(const IntArgs& x);
1541 
1543  REG(const REG& r);
1545  const REG& operator =(const REG& r);
1546 
1548  REG operator +(const REG& r);
1550  REG& operator +=(const REG& r);
1552  REG operator |(const REG& r);
1554  REG& operator |=(const REG& r);
1556  REG operator *(void);
1558  REG operator +(void);
1560  REG operator ()(unsigned int n, unsigned int m);
1562  REG operator ()(unsigned int n);
1564  template<class Char, class Traits>
1565  std::basic_ostream<Char,Traits>&
1566  print(std::basic_ostream<Char,Traits>& os) const;
1568  operator DFA(void);
1570  ~REG(void);
1571  };
1572 
1576  template<class Char, class Traits>
1577  std::basic_ostream<Char,Traits>&
1578  operator <<(std::basic_ostream<Char,Traits>& os, const REG& r);
1579 
1580 }
1581 
1582 #include <gecode/minimodel/reg.hpp>
1583 
1584 namespace Gecode {
1585 
1594  abs(const LinIntExpr& e);
1597  min(const LinIntExpr& x, const LinIntExpr& y);
1600  min(const IntVarArgs& x);
1603  max(const LinIntExpr& x, const LinIntExpr& y);
1606  max(const IntVarArgs& x);
1607 #ifdef GECODE_HAS_FLOAT_VARS
1610  operator *(const FloatVar&, const FloatVar&);
1613  operator *(const FloatVar&, const LinFloatExpr&);
1616  operator *(const LinFloatExpr&, const FloatVar&);
1617 #endif
1620  operator *(const LinIntExpr& x, const LinIntExpr& y);
1623  operator /(const LinIntExpr& x, const LinIntExpr& y);
1626  operator %(const LinIntExpr& x, const LinIntExpr& y);
1629  sqr(const LinIntExpr& x);
1632  sqrt(const LinIntExpr& x);
1635  pow(const LinIntExpr& x, int n);
1638  nroot(const LinIntExpr& x, int n);
1641  element(const IntVarArgs& x, const LinIntExpr& y);
1644  element(const BoolVarArgs& x, const LinIntExpr& y);
1647  element(const IntArgs& x, const LinIntExpr& y);
1650  ite(const BoolExpr& b, const LinIntExpr& x, const LinIntExpr& y);
1652 
1653 #ifdef GECODE_HAS_FLOAT_VARS
1656  abs(const LinFloatExpr& e);
1659  min(const LinFloatExpr& x, const LinFloatExpr& y);
1662  min(const FloatVarArgs& x);
1665  max(const LinFloatExpr& x, const LinFloatExpr& y);
1668  max(const FloatVarArgs& x);
1671  operator *(const LinFloatExpr& x, const LinFloatExpr& y);
1674  operator /(const LinFloatExpr& x, const LinFloatExpr& y);
1677  sqr(const LinFloatExpr& x);
1680  sqrt(const LinFloatExpr& x);
1683  pow(const LinFloatExpr& x, int n);
1686  nroot(const LinFloatExpr& x, int n);
1688 
1689 #ifdef GECODE_HAS_MPFR
1690 
1698  exp(const LinFloatExpr& x);
1701  log(const LinFloatExpr& x);
1703 
1712  asin(const LinFloatExpr& x);
1715  sin(const LinFloatExpr& x);
1718  acos(const LinFloatExpr& x);
1721  cos(const LinFloatExpr& x);
1724  atan(const LinFloatExpr& x);
1727  tan(const LinFloatExpr& x);
1729 #endif
1730 #endif
1731 
1738  inline BoolVar
1741  IntPropLevel ipl=IPL_DEF) {
1742  (void) ipl;
1743  BoolVar b(home,0,1); channel(home,b,x);
1744  return b;
1745  }
1747  inline IntVar
1749  IntPropLevel ipl=IPL_DEF) {
1750  (void) ipl;
1751  IntVar x(home,0,1); channel(home,b,x);
1752  return x;
1753  }
1754 #ifdef GECODE_HAS_FLOAT_VARS
1755  inline IntVar
1758  int min = static_cast<int>(std::max(static_cast<double>(Int::Limits::min),
1759  std::ceil(f.min())));
1760  int max = static_cast<int>(std::min(static_cast<double>(Int::Limits::max),
1761  std::floor(f.max())));
1762  IntVar x(home,min,max);
1763  channel(home,f,x);
1764  return x;
1765  }
1766 #endif
1767 #ifdef GECODE_HAS_SET_VARS
1768  inline SetVar
1771  (void) ipl;
1773  rel(home,SOT_UNION,x,s);
1774  nvalues(home,x,IRT_EQ,expr(home,cardinality(s)));
1775  return s;
1776  }
1777 #endif
1778 
1779 
1780 }
1781 
1782 namespace Gecode {
1783 
1798  inline void
1799  atmost(Home home, const IntVarArgs& x, int n, int m,
1800  IntPropLevel ipl=IPL_DEF) {
1801  count(home,x,n,IRT_LQ,m,ipl);
1802  }
1807  inline void
1808  atmost(Home home, const IntVarArgs& x, IntVar y, int m,
1809  IntPropLevel ipl=IPL_DEF) {
1810  count(home,x,y,IRT_LQ,m,ipl);
1811  }
1819  inline void
1820  atmost(Home home, const IntVarArgs& x, const IntArgs& y, int m,
1821  IntPropLevel ipl=IPL_DEF) {
1822  count(home,x,y,IRT_LQ,m,ipl);
1823  }
1828  inline void
1829  atmost(Home home, const IntVarArgs& x, int n, IntVar z,
1830  IntPropLevel ipl=IPL_DEF) {
1831  count(home,x,n,IRT_LQ,z,ipl);
1832  }
1837  inline void
1839  IntPropLevel ipl=IPL_DEF) {
1840  count(home,x,y,IRT_LQ,z,ipl);
1841  }
1849  inline void
1850  atmost(Home home, const IntVarArgs& x, const IntArgs& y, IntVar z,
1851  IntPropLevel ipl=IPL_DEF) {
1852  count(home,x,y,IRT_LQ,z,ipl);
1853  }
1854 
1859  inline void
1860  atleast(Home home, const IntVarArgs& x, int n, int m,
1861  IntPropLevel ipl=IPL_DEF) {
1862  count(home,x,n,IRT_GQ,m,ipl);
1863  }
1868  inline void
1869  atleast(Home home, const IntVarArgs& x, IntVar y, int m,
1870  IntPropLevel ipl=IPL_DEF) {
1871  count(home,x,y,IRT_GQ,m,ipl);
1872  }
1880  inline void
1881  atleast(Home home, const IntVarArgs& x, const IntArgs& y, int m,
1882  IntPropLevel ipl=IPL_DEF) {
1883  count(home,x,y,IRT_GQ,m,ipl);
1884  }
1889  inline void
1890  atleast(Home home, const IntVarArgs& x, int n, IntVar z,
1891  IntPropLevel ipl=IPL_DEF) {
1892  count(home,x,n,IRT_GQ,z,ipl);
1893  }
1898  inline void
1900  IntPropLevel ipl=IPL_DEF) {
1901  count(home,x,y,IRT_GQ,z,ipl);
1902  }
1910  inline void
1911  atleast(Home home, const IntVarArgs& x, const IntArgs& y, IntVar z,
1912  IntPropLevel ipl=IPL_DEF) {
1913  count(home,x,y,IRT_GQ,z,ipl);
1914  }
1915 
1920  inline void
1921  exactly(Home home, const IntVarArgs& x, int n, int m,
1922  IntPropLevel ipl=IPL_DEF) {
1923  count(home,x,n,IRT_EQ,m,ipl);
1924  }
1929  inline void
1930  exactly(Home home, const IntVarArgs& x, IntVar y, int m,
1931  IntPropLevel ipl=IPL_DEF) {
1932  count(home,x,y,IRT_EQ,m,ipl);
1933  }
1941  inline void
1942  exactly(Home home, const IntVarArgs& x, const IntArgs& y, int m,
1943  IntPropLevel ipl=IPL_DEF) {
1944  count(home,x,y,IRT_EQ,m,ipl);
1945  }
1950  inline void
1951  exactly(Home home, const IntVarArgs& x, int n, IntVar z,
1952  IntPropLevel ipl=IPL_DEF) {
1953  count(home,x,n,IRT_EQ,z,ipl);
1954  }
1959  inline void
1961  IntPropLevel ipl=IPL_DEF) {
1962  count(home,x,y,IRT_EQ,z,ipl);
1963  }
1971  inline void
1972  exactly(Home home, const IntVarArgs& x, const IntArgs& y, IntVar z,
1973  IntPropLevel ipl=IPL_DEF) {
1974  count(home,x,y,IRT_EQ,z,ipl);
1975  }
1978  inline void
1979  lex(Home home, const IntVarArgs& x, IntRelType r, const IntVarArgs& y,
1980  IntPropLevel ipl=IPL_DEF) {
1981  rel(home,x,r,y,ipl);
1982  }
1985  inline void
1986  lex(Home home, const BoolVarArgs& x, IntRelType r, const BoolVarArgs& y,
1987  IntPropLevel ipl=IPL_DEF) {
1988  rel(home,x,r,y,ipl);
1989  }
1992  inline void
1993  values(Home home, const IntVarArgs& x, IntSet y,
1994  IntPropLevel ipl=IPL_DEF) {
1995  dom(home,x,y,ipl);
1996  nvalues(home,x,IRT_EQ,static_cast<int>(y.size()),ipl);
1997  }
1998 
2000 
2001 #ifdef GECODE_HAS_SET_VARS
2002 
2017  inline void
2018  channel(Home home, const IntVarArgs& x, SetVar y) {
2019  rel(home,SOT_UNION,x,y);
2020  nvalues(home,x,IRT_EQ,expr(home,cardinality(y)));
2021  }
2022 
2025  inline void
2026  range(Home home, const IntVarArgs& x, SetVar y, SetVar z) {
2027  element(home,SOT_UNION,x,y,z);
2028  }
2029 
2035  inline void
2036  roots(Home home, const IntVarArgs& x, SetVar y, SetVar z) {
2037  SetVarArgs xiv(home,z.lubMax()+1,IntSet::empty,0,x.size()-1);
2038  channel(home,x,xiv);
2039  element(home,SOT_UNION,xiv,z,y);
2040  }
2041 
2043 #endif
2044 }
2045 
2046 namespace Gecode {
2047 
2048  template<class> class Matrix;
2049 
2057  template<class A>
2058  class Slice {
2059  public:
2062  private:
2063  ArgsType _r;
2064  int _fc,
2065  _tc,
2066  _fr,
2067  _tr;
2068  public:
2070  Slice(const Matrix<A>& a, int fc, int tc, int fr, int tr);
2074  Slice& reverse(void);
2076  operator ArgsType(void);
2078  operator Matrix<ArgsType>(void);
2079 
2081  operator const ArgsType(void) const;
2083  operator const Matrix<ArgsType>(void) const;
2084  };
2085 
2087  template<class A>
2088  typename Slice<A>::ArgsType
2089  operator+(const Slice<A>& x, const Slice<A>& y);
2090 
2092  template<class A>
2093  typename Slice<A>::ArgsType
2094  operator+(const Slice<A>& x, const typename ArrayTraits<A>::ArgsType& y);
2095 
2097  template<class A>
2098  typename Slice<A>::ArgsType
2099  operator+(const typename ArrayTraits<A>::ArgsType& x, const Slice<A>& y);
2100 
2102  template<class A>
2103  typename Slice<A>::ArgsType
2104  operator+(const Slice<A>& x, const typename ArrayTraits<A>::ValueType& y);
2105 
2107  template<class A>
2108  typename Slice<A>::ArgsType
2109  operator+(const typename ArrayTraits<A>::ValueType& x, const Slice<A>& y);
2110 
2121  template<class A>
2122  class Matrix {
2123  public:
2128 
2129  private:
2131  typedef typename ArrayTraits<A>::StorageType StorageType;
2132  StorageType _a;
2133  int _w;
2134  int _h;
2135 
2136  public:
2149  Matrix(A a, int w, int h);
2150 
2163  Matrix(A a, int n);
2164 
2166  int width(void) const;
2168  int height(void) const;
2170  ArgsType const get_array(void) const;
2171 
2177  ValueType& operator ()(int c, int r);
2178 
2184  const ValueType& operator ()(int c, int r) const;
2185 
2195  Slice<A> slice(int fc, int tc, int fr, int tr) const;
2196 
2198  Slice<A> row(int r) const;
2199 
2201  Slice<A> col(int c) const;
2202  };
2203 
2207  template<class Char, class Traits, class A>
2208  std::basic_ostream<Char,Traits>&
2209  operator <<(std::basic_ostream<Char,Traits>& os, const Matrix<A>& m);
2210 
2214  template<class Char, class Traits, class A>
2215  std::basic_ostream<Char,Traits>&
2216  operator <<(std::basic_ostream<Char,Traits>& os, const Slice<A>& s);
2217 
2224  void element(Home home, const Matrix<IntArgs>& m, IntVar x, IntVar y,
2225  IntVar z, IntPropLevel ipl=IPL_DEF);
2232  void element(Home home, const Matrix<IntArgs>& m, IntVar x, IntVar y,
2233  BoolVar z, IntPropLevel ipl=IPL_DEF);
2240  void element(Home home, const Matrix<IntVarArgs>& m, IntVar x, IntVar y,
2241  IntVar z, IntPropLevel ipl=IPL_DEF);
2248  void element(Home home, const Matrix<BoolVarArgs>& m, IntVar x, IntVar y,
2249  BoolVar z, IntPropLevel ipl=IPL_DEF);
2250 #ifdef GECODE_HAS_SET_VARS
2251 
2257  void element(Home home, const Matrix<IntSetArgs>& m, IntVar x, IntVar y,
2258  SetVar z);
2265  void element(Home home, const Matrix<SetVarArgs>& m, IntVar x, IntVar y,
2266  SetVar z);
2267 #endif
2268 
2272  template<class A>
2277  template<class A>
2282  template<class A>
2287  template<class A>
2294  template<class A>
2296 }
2297 
2298 #include <gecode/minimodel/matrix.hpp>
2299 #include <gecode/minimodel/ldsb.hpp>
2300 
2305 namespace Gecode {
2306 
2309  sum(const Slice<IntArgs>& slice);
2312  sum(const Matrix<IntArgs>& matrix);
2313 
2314 }
2317 namespace Gecode {
2318 
2333  public:
2335  IntMinimizeSpace(void);
2340  virtual void constrain(const Space& best);
2342  virtual IntVar cost(void) const = 0;
2343  };
2344 
2350  public:
2352  IntMaximizeSpace(void);
2357  virtual void constrain(const Space& best);
2359  virtual IntVar cost(void) const = 0;
2360  };
2361 
2367  public:
2369  IntLexMinimizeSpace(void);
2374  virtual void constrain(const Space& best);
2376  virtual IntVarArgs cost(void) const = 0;
2377  };
2378 
2384  public:
2386  IntLexMaximizeSpace(void);
2391  virtual void constrain(const Space& best);
2393  virtual IntVarArgs cost(void) const = 0;
2394  };
2395 
2396 #ifdef GECODE_HAS_FLOAT_VARS
2397 
2408  protected:
2411  public:
2418  virtual void constrain(const Space& best);
2420  virtual FloatVar cost(void) const = 0;
2421  };
2422 
2433  protected:
2436  public:
2443  virtual void constrain(const Space& best);
2445  virtual FloatVar cost(void) const = 0;
2446  };
2447 
2448 #endif
2449 
2450 }
2451 
2453 
2454 #endif
2455 
2456 // IFDEF: GECODE_HAS_INT_VARS
2457 // STATISTICS: minimodel-any
2458 
FloatVal operator-(const FloatVal &x)
Definition: val.hpp:168
SetExpr singleton(const LinIntExpr &e)
Singleton expression.
Definition: set-expr.cpp:691
Passing float arguments.
Definition: float.hh:950
Class for minimizing integer cost.
Definition: minimodel.hh:2332
SetRelType srt
Which relation.
Definition: minimodel.hh:1124
NodeType t
Type of node.
Definition: bool-expr.cpp:230
SetRelType
Common relation types for sets.
Definition: set.hh:643
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:1979
NNF * l
Left subtree.
Definition: bool-expr.cpp:240
Class for lexicographically maximizing integer costs.
Definition: minimodel.hh:2383
int size(void) const
Return size of array (number of elements)
Definition: array.hpp:1569
virtual ~NonLinFloatExpr(void)
Destructor.
Definition: minimodel.hh:698
const int min
Smallest allowed integer in integer set.
Definition: set.hh:99
SetExpr operator&(const SetExpr &l, const SetExpr &r)
Intersection of set expressions.
Definition: set-expr.cpp:671
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:41
const FloatNum max
Largest allowed float value.
Definition: float.hh:844
virtual ~NonLinIntExpr(void)
Destructor.
Definition: minimodel.hh:120
Set relations
Definition: minimodel.hh:1130
void count(Home home, const IntVarArgs &x, int n, IntRelType irt, int m, IntPropLevel)
Post propagator for .
Definition: count.cpp:40
FloatVal operator/(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:213
void rfree(void *p)
Free memory block starting at p.
Definition: heap.hpp:371
FloatNum max(void) const
Return maximum of domain.
Definition: float.hpp:67
Regular expressions over integer values.
Definition: minimodel.hh:1518
Reified linear relation.
Definition: minimodel.hh:1235
Linear term with Boolean variable.
Definition: minimodel.hh:153
void max(Home home, FloatVar x0, FloatVar x1, FloatVar x2)
Post propagator for .
Definition: arithmetic.cpp:49
FloatNum step
Step by which a next solution has to have lower cost.
Definition: minimodel.hh:2435
void abs(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition: arithmetic.cpp:41
Passing float variables.
Definition: float.hh:979
Node for Boolean expression
Definition: bool-expr.cpp:43
Less or equal ( )
Definition: int.hh:928
void nroot(Home home, FloatVar x0, int n, FloatVar x1)
Post propagator for for $n 0$.
Definition: arithmetic.cpp:118
Linear relations over integer variables.
Definition: minimodel.hh:230
void atmost(Home home, const IntVarArgs &x, int n, int m, IntPropLevel ipl=IPL_DEF)
Post constraint .
Definition: minimodel.hh:1799
void pow(Home home, FloatVar x0, int n, FloatVar x1)
Post propagator for for $n 0$.
Definition: arithmetic.cpp:109
void dom(Home home, FloatVar x, FloatVal n)
Propagates .
Definition: dom.cpp:40
Base class for non-linear expressions over integer variables.
Definition: minimodel.hh:109
void * ralloc(size_t s)
Allocate s bytes from heap.
Definition: heap.hpp:357
Addition of linear terms.
Definition: minimodel.hh:157
void roots(Home home, const IntVarArgs &x, SetVar y, SetVar z)
Post constraint .
Definition: minimodel.hh:2036
SymmetryHandle columns_interchange(const Matrix< A > &m)
Interchangeable columns symmetry specification.
Definition: ldsb.hpp:51
Expression information.
Definition: reg.cpp:534
Linear term with variable.
Definition: minimodel.hh:724
Comparison relation (for two-sided comparisons)
Definition: minimodel.hh:1117
const int max
Largest allowed integer in integer set.
Definition: set.hh:97
Linear expression.
Definition: minimodel.hh:1066
Linear term with integer variable.
Definition: minimodel.hh:152
Class for maximizing float cost.
Definition: minimodel.hh:2432
const int max
Largest allowed integer value.
Definition: int.hh:116
Computation spaces.
Definition: core.hpp:1701
Greater or equal ( )
Definition: int.hh:930
Set expressions
Definition: minimodel.hh:1060
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:595
void atleast(Home home, const IntVarArgs &x, int n, int m, IntPropLevel ipl=IPL_DEF)
Post constraint .
Definition: minimodel.hh:1860
ArrayTraits< A >::ValueType ValueType
The type of elements of this array.
Definition: minimodel.hh:2125
Nodes for linear expressions.
Definition: float-expr.cpp:43
Reified linear relation.
Definition: minimodel.hh:1234
SetExpr setdunion(const SetVarArgs &x)
Disjoint union of set variables.
Definition: set-expr.cpp:714
static IntVar result(Home home, IntVar *x)
Return fresh variable if x is NULL, x otherwise.
Definition: minimodel.hh:122
FloatNum min(void) const
Return minimum of domain.
Definition: float.hpp:59
int lubMax(void) const
Return maximum element of least upper bound.
Definition: set.hpp:87
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:587
Miscealloneous Boolean expressions.
Definition: minimodel.hh:1240
static FloatVar result(Home home, FloatVar *x)
Return fresh variable if x is NULL, x otherwise.
Definition: minimodel.hh:700
Deterministic finite automaton (DFA)
Definition: int.hh:2048
int p
Number of positive literals for node type.
Definition: bool-expr.cpp:232
const FloatNum min
Smallest allowed float value.
Definition: float.hh:846
A slice of a matrix.
Definition: minimodel.hh:2058
IntRelType neg(IntRelType irt)
Return negated relation type of irt.
Definition: irt.hpp:52
int n
Number of negative literals for node type.
Definition: bool-expr.cpp:234
Equality ( )
Definition: int.hh:926
Base class for non-linear float expressions.
Definition: minimodel.hh:688
Gecode::IntArgs i({1, 2, 3, 4})
A reference-counted pointer to a SymmetryObject.
Definition: int.hh:5125
void nvalues(Home home, const IntVarArgs &x, IntRelType irt, int y, IntPropLevel)
Post propagator for .
Definition: nvalues.cpp:40
Nodes for linear expressions.
Definition: int-expr.cpp:40
IntRelType
Relation types for integers.
Definition: int.hh:925
FloatVal operator+(const FloatVal &x)
Definition: val.hpp:164
static IntVar result(Home home, IntVar *x, IntVar y)
Constrain x to be equal to y if x is not NULL.
Definition: minimodel.hh:128
void sqr(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition: arithmetic.cpp:95
FloatRelType
Relation types for floats.
Definition: float.hh:1068
Linear relations.
Definition: minimodel.hh:792
bool operator!=(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:317
Simple propagation levels.
Definition: int.hh:976
unsigned int size(void) const
Return size (cardinality) of set.
Definition: int-set-1.hpp:195
SetExpr r
Right side of relation.
Definition: minimodel.hh:1122
void sqrt(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition: arithmetic.cpp:102
struct Gecode::@593::NNF::@62::@63 b
For binary nodes (and, or, eqv)
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:706
void range(Home home, const IntVarArgs &x, SetVar y, SetVar z)
Post constraint .
Definition: minimodel.hh:2026
Class for lexicographically minimizing integer costs.
Definition: minimodel.hh:2366
Reified set relation.
Definition: minimodel.hh:1236
ArrayTraits< A >::ArgsType ArgsType
The type of the Args-array type for ValueType values.
Definition: minimodel.hh:2127
Subtraction of linear terms.
Definition: minimodel.hh:728
Float expressions
Definition: minimodel.hh:718
NodeType
Type of set expression.
Definition: minimodel.hh:1063
Integer sets.
Definition: int.hh:174
NodeType
Type of linear expression.
Definition: minimodel.hh:150
Post propagator for SetVar SetOpType SetVar SetRelType SetVar z
Definition: set.hh:767
SetExpr setunion(const SetVarArgs &x)
Union of set variables.
Definition: set-expr.cpp:705
Boolean expressions.
Definition: minimodel.hh:1225
void asin(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
SetExpr l
Left side of relation.
Definition: minimodel.hh:1120
Passing integer variables.
Definition: int.hh:656
Passing integer arguments.
Definition: int.hh:628
NodeType
Type of linear expression.
Definition: minimodel.hh:722
Passing Boolean variables.
Definition: int.hh:712
Equality ( )
Definition: float.hh:1069
Non-linear expression.
Definition: minimodel.hh:154
static const IntSet empty
Empty set.
Definition: int.hh:283
BoolVar expr(Home home, const BoolExpr &e, IntPropLevel ipl)
Post Boolean expression and return its value.
Definition: bool-expr.cpp:627
SymmetryHandle columns_reflect(const Matrix< A > &m)
Reflect columns symmetry specification.
Definition: ldsb.hpp:85
union Gecode::@593::NNF::@62 u
Union depending on nodetype t.
Boolean integer variables.
Definition: int.hh:512
LinIntExpr cardinality(const SetExpr &e)
Cardinality of set expression.
Definition: set-expr.cpp:815
Post propagator for SetVar SetOpType SetVar SetRelType r
Definition: set.hh:767
SetExpr inter(const SetVarArgs &x)
Intersection of set variables.
Definition: set-expr.cpp:696
void min(Home home, FloatVar x0, FloatVar x1, FloatVar x2)
Post propagator for .
Definition: arithmetic.cpp:67
Archive & operator>>(Archive &e, FloatNumBranch &nl)
Definition: val-sel.hpp:44
ArrayTraits< A >::ArgsType ArgsType
The type of the Args-array type for ValueType values.
Definition: minimodel.hh:2061
void cos(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
IntPropLevel
Propagation levels for integer propagators.
Definition: int.hh:974
Union.
Definition: set.hh:661
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:63
Passing set variables.
Definition: set.hh:488
Post propagator for f(x \diamond_{\mathit{op}} y) \sim_r z \f$ void rel(Home home
Sum of float variables.
Definition: minimodel.hh:726
Post propagator for SetVar SetOpType SetVar y
Definition: set.hh:767
Class for maximizing integer cost.
Definition: minimodel.hh:2349
Non-linear expression.
Definition: minimodel.hh:725
NodeType
Type of Boolean expression.
Definition: minimodel.hh:1228
Float value type.
Definition: float.hh:334
FloatVal operator*(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:200
SymmetryHandle diagonal_reflect(const Matrix< A > &m)
Reflect around main diagonal symmetry specification.
Definition: ldsb.hpp:108
Set variables
Definition: set.hh:127
Node for set expression
Definition: set-expr.cpp:51
Sum of integer variables.
Definition: minimodel.hh:155
Linear expressions over integer variables.
Definition: minimodel.hh:140
void tan(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
bool operator>=(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:277
Integer variables.
Definition: int.hh:371
Heap heap
The single global heap.
Definition: heap.cpp:44
void rel(Home home, FloatVar x0, FloatRelType frt, FloatVal n)
Propagates .
Definition: rel.cpp:43
Sum of Boolean variables.
Definition: minimodel.hh:156
SymmetryHandle rows_interchange(const Matrix< A > &m)
Interchangeable rows symmetry specification.
Definition: ldsb.hpp:40
Subtraction of linear terms.
Definition: minimodel.hh:158
BoolExpr operator!(const BoolExpr &e)
Negated Boolean expression.
Definition: bool-expr.cpp:600
void values(Home home, const IntVarArgs &x, IntSet y, IntPropLevel ipl=IPL_DEF)
Post constraint .
Definition: minimodel.hh:1993
Post propagator for SetVar x
Definition: set.hh:767
LinIntExpr operator%(const LinIntExpr &e0, const LinIntExpr &e1)
Return expression for .
Definition: int-arith.cpp:452
Archive & operator<<(Archive &e, FloatNumBranch nl)
Definition: val-sel.hpp:39
Implementation of the actual expression tree.
Definition: reg.cpp:52
#define GECODE_MINIMODEL_EXPORT
Definition: minimodel.hh:78
Matrix-interface for arrays.
Definition: minimodel.hh:2048
Float variables.
Definition: float.hh:870
bool operator>(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:260
SetExpr operator|(const SetExpr &l, const SetExpr &r)
Union of set expressions.
Definition: set-expr.cpp:675
Integer constant.
Definition: minimodel.hh:151
bool operator<(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:226
bool operator==(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:294
Addition of linear terms.
Definition: minimodel.hh:727
Traits of arrays in Gecode.
Definition: array.hpp:76
bool operator<=(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:243
Float value constant.
Definition: minimodel.hh:723
Class for minimizing float cost.
Definition: minimodel.hh:2407
Gecode toplevel namespace
LinFloatExpr sum(const FloatVarArgs &x)
Construct linear float expression as sum of float variables.
Definition: float-expr.cpp:546
void sin(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
#define GECODE_VTABLE_EXPORT
Definition: support.hh:72
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:853
Base class for heap allocated objects.
Definition: heap.hpp:340
double FloatNum
Floating point number base type.
Definition: float.hh:106
void exactly(Home home, const IntVarArgs &x, int n, int m, IntPropLevel ipl=IPL_DEF)
Post constraint .
Definition: minimodel.hh:1921
const unsigned int slice
Size of a slice in a portfolio and scale factor for restarts(in number of failures) ...
Definition: search.hh:128
struct Gecode::@593::NNF::@62::@64 a
For atomic nodes.
FloatNum step
Step by which a next solution has to have lower cost.
Definition: minimodel.hh:2410
void ite(Home home, BoolVar b, FloatVar x, FloatVar y, FloatVar z)
Post propagator for if-then-else constraint.
Definition: bool.cpp:39
void element(Home home, IntSharedArray c, IntVar x0, IntVar x1, IntPropLevel)
Post domain consistent propagator for .
Definition: element.cpp:39
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:591
TFE post(PropagatorGroup g)
Only post functions (but not propagators) from g are considered.
Definition: filter.cpp:138
SymmetryHandle rows_reflect(const Matrix< A > &m)
Reflect rows symmetry specification.
Definition: ldsb.hpp:62