Generated on Thu Jan 31 2019 20:56:40 for Gecode by doxygen 1.8.15
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  * Mikael Lagerkvist <lagerkvist@gecode.org>
7  * Vincent Barichard <Vincent.Barichard@univ-angers.fr>
8  *
9  * Copyright:
10  * Christian Schulte, 2004
11  * Guido Tack, 2004
12  * Mikael Lagerkvist, 2005
13  * Vincent Barichard, 2012
14  *
15  * Last modified:
16  * $Date: 2016-09-27 11:32:06 +0200 (Tue, 27 Sep 2016) $ by $Author: schulte $
17  * $Revision: 15172 $
18  *
19  * This file is part of Gecode, the generic constraint
20  * development environment:
21  * http://www.gecode.org
22  *
23  * Permission is hereby granted, free of charge, to any person obtaining
24  * a copy of this software and associated documentation files (the
25  * "Software"), to deal in the Software without restriction, including
26  * without limitation the rights to use, copy, modify, merge, publish,
27  * distribute, sublicense, and/or sell copies of the Software, and to
28  * permit persons to whom the Software is furnished to do so, subject to
29  * the following conditions:
30  *
31  * The above copyright notice and this permission notice shall be
32  * included in all copies or substantial portions of the Software.
33  *
34  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
35  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
36  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
37  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
38  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
39  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
40  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
41  *
42  */
43 
44 #ifndef __GECODE_MINIMODEL_HH__
45 #define __GECODE_MINIMODEL_HH__
46 
47 #include <gecode/kernel.hh>
48 #include <gecode/int.hh>
49 #ifdef GECODE_HAS_SET_VARS
50 #include <gecode/set.hh>
51 #endif
52 #ifdef GECODE_HAS_FLOAT_VARS
53 #include <gecode/float.hh>
54 #endif
55 
56 #include <iostream>
57 
58 /*
59  * Support for DLLs under Windows
60  *
61  */
62 
63 #if !defined(GECODE_STATIC_LIBS) && \
64  (defined(__CYGWIN__) || defined(__MINGW32__) || defined(_MSC_VER))
65 
66 #ifdef GECODE_BUILD_MINIMODEL
67 #define GECODE_MINIMODEL_EXPORT __declspec( dllexport )
68 #else
69 #define GECODE_MINIMODEL_EXPORT __declspec( dllimport )
70 #endif
71 
72 #else
73 
74 #ifdef GECODE_GCC_HAS_CLASS_VISIBILITY
75 
76 #define GECODE_MINIMODEL_EXPORT __attribute__ ((visibility("default")))
77 
78 #else
79 
80 #define GECODE_MINIMODEL_EXPORT
81 
82 #endif
83 #endif
84 
85 // Configure auto-linking
86 #ifndef GECODE_BUILD_MINIMODEL
87 #define GECODE_LIBRARY_NAME "MiniModel"
89 #endif
90 
91 namespace Gecode {
92 
94  namespace MiniModel {}
95 
96 }
97 
99 
100 namespace Gecode {
101 
102  class LinIntRel;
103 #ifdef GECODE_HAS_SET_VARS
104  class SetExpr;
105 #endif
106 #ifdef GECODE_HAS_FLOAT_VARS
107  class LinFloatExpr;
108 #endif
109 
112  public:
114  virtual IntVar post(Home home, IntVar* ret, IntPropLevel ipl) const = 0;
116  virtual void post(Home home, IntRelType irt, int c,
117  IntPropLevel ipl) const = 0;
119  virtual void post(Home home, IntRelType irt, int c,
120  BoolVar b, IntPropLevel ipl) const = 0;
122  virtual ~NonLinIntExpr(void) {}
124  static IntVar result(Home home, IntVar* x) {
125  if (x==NULL)
127  return *x;
128  }
130  static IntVar result(Home home, IntVar* x, IntVar y) {
131  if (x!=NULL)
132  rel(home,*x,IRT_EQ,y);
133  return y;
134  }
136  void* operator new(size_t size) { return heap.ralloc(size); }
138  void operator delete(void* p, size_t) { heap.rfree(p); }
139  };
140 
142  class LinIntExpr {
143  friend class LinIntRel;
144 #ifdef GECODE_HAS_SET_VARS
145  friend class SetExpr;
146 #endif
147 #ifdef GECODE_HAS_FLOAT_VARS
148  friend class LinFloatExpr;
149 #endif
150  public:
152  enum NodeType {
162  };
163  private:
165  class Node;
167  Node* n;
168  public:
171  LinIntExpr(void);
174  LinIntExpr(int c);
177  LinIntExpr(const IntVar& x, int a=1);
180  LinIntExpr(const BoolVar& x, int a=1);
183  explicit LinIntExpr(const IntVarArgs& x);
186  LinIntExpr(const IntArgs& a, const IntVarArgs& x);
189  explicit LinIntExpr(const BoolVarArgs& x);
192  LinIntExpr(const IntArgs& a, const BoolVarArgs& x);
195  LinIntExpr(const LinIntExpr& e);
198  LinIntExpr(const LinIntExpr& e0, NodeType t, const LinIntExpr& e1);
201  LinIntExpr(const LinIntExpr& e0, NodeType t, int c);
204  LinIntExpr(int a, const LinIntExpr& e);
207  explicit LinIntExpr(NonLinIntExpr* e);
210  const LinIntExpr& operator =(const LinIntExpr& e);
213  void post(Home home, IntRelType irt, IntPropLevel ipl) const;
216  void post(Home home, IntRelType irt, const BoolVar& b,
217  IntPropLevel ipl) const;
220  IntVar post(Home home, IntPropLevel ipl) const;
223  NonLinIntExpr* nle(void) const;
226  ~LinIntExpr(void);
227  };
228 
229  class BoolExpr;
230 
232  class LinIntRel {
233  friend class BoolExpr;
234  private:
236  LinIntExpr e;
238  IntRelType irt;
240  static IntRelType neg(IntRelType irt);
242  LinIntRel(void);
243  public:
245  LinIntRel(const LinIntExpr& l, IntRelType irt, const LinIntExpr& r);
247  LinIntRel(const LinIntExpr& l, IntRelType irt, int r);
249  LinIntRel(int l, IntRelType irt, const LinIntExpr& r);
251  void post(Home home, bool t, IntPropLevel ipl) const;
253  void post(Home home, const BoolVar& b, bool t, IntPropLevel ipl) const;
254  };
255 
276  operator +(int, const IntVar&);
279  operator +(int, const BoolVar&);
282  operator +(int, const LinIntExpr&);
285  operator +(const IntVar&, int);
288  operator +(const BoolVar&, int);
291  operator +(const LinIntExpr&, int);
294  operator +(const IntVar&, const IntVar&);
297  operator +(const IntVar&, const BoolVar&);
300  operator +(const BoolVar&, const IntVar&);
303  operator +(const BoolVar&, const BoolVar&);
306  operator +(const IntVar&, const LinIntExpr&);
309  operator +(const BoolVar&, const LinIntExpr&);
312  operator +(const LinIntExpr&, const IntVar&);
315  operator +(const LinIntExpr&, const BoolVar&);
318  operator +(const LinIntExpr&, const LinIntExpr&);
319 
322  operator -(int, const IntVar&);
325  operator -(int, const BoolVar&);
328  operator -(int, const LinIntExpr&);
331  operator -(const IntVar&, int);
334  operator -(const BoolVar&, int);
337  operator -(const LinIntExpr&, int);
340  operator -(const IntVar&, const IntVar&);
343  operator -(const IntVar&, const BoolVar&);
346  operator -(const BoolVar&, const IntVar&);
349  operator -(const BoolVar&, const BoolVar&);
352  operator -(const IntVar&, const LinIntExpr&);
355  operator -(const BoolVar&, const LinIntExpr&);
358  operator -(const LinIntExpr&, const IntVar&);
361  operator -(const LinIntExpr&, const BoolVar&);
364  operator -(const LinIntExpr&, const LinIntExpr&);
365 
368  operator -(const IntVar&);
371  operator -(const BoolVar&);
374  operator -(const LinIntExpr&);
375 
378  operator *(int, const IntVar&);
381  operator *(int, const BoolVar&);
384  operator *(const IntVar&, int);
387  operator *(const BoolVar&, int);
390  operator *(const LinIntExpr&, int);
393  operator *(int, const LinIntExpr&);
394 
397  sum(const IntVarArgs& x);
400  sum(const IntArgs& a, const IntVarArgs& x);
403  sum(const BoolVarArgs& x);
406  sum(const IntArgs& a, const BoolVarArgs& x);
409  sum(const IntArgs& args);
410 
413  operator ==(int l, const IntVar& r);
416  operator ==(int l, const BoolVar& r);
419  operator ==(int l, const LinIntExpr& r);
422  operator ==(const IntVar& l, int r);
425  operator ==(const BoolVar& l, int r);
428  operator ==(const LinIntExpr& l, int r);
431  operator ==(const IntVar& l, const IntVar& r);
434  operator ==(const IntVar& l, const BoolVar& r);
437  operator ==(const BoolVar& l, const IntVar& r);
440  operator ==(const BoolVar& l, const BoolVar& r);
443  operator ==(const IntVar& l, const LinIntExpr& r);
446  operator ==(const BoolVar& l, const LinIntExpr& r);
449  operator ==(const LinIntExpr& l, const IntVar& r);
452  operator ==(const LinIntExpr& l, const BoolVar& r);
455  operator ==(const LinIntExpr& l, const LinIntExpr& r);
456 
459  operator !=(int l, const IntVar& r);
462  operator !=(int l, const BoolVar& r);
465  operator !=(int l, const LinIntExpr& r);
468  operator !=(const IntVar& l, int r);
471  operator !=(const BoolVar& l, int r);
474  operator !=(const LinIntExpr& l, int r);
477  operator !=(const IntVar& l, const IntVar& r);
480  operator !=(const IntVar& l, const BoolVar& r);
483  operator !=(const BoolVar& l, const IntVar& r);
486  operator !=(const BoolVar& l, const BoolVar& r);
489  operator !=(const IntVar& l, const LinIntExpr& r);
492  operator !=(const BoolVar& l, const LinIntExpr& r);
495  operator !=(const LinIntExpr& l, const IntVar& r);
498  operator !=(const LinIntExpr& l, const BoolVar& r);
501  operator !=(const LinIntExpr& l, const LinIntExpr& r);
502 
505  operator <(int l, const IntVar& r);
508  operator <(int l, const BoolVar& r);
511  operator <(int l, const LinIntExpr& r);
514  operator <(const IntVar& l, int r);
517  operator <(const BoolVar& l, int r);
520  operator <(const LinIntExpr& l, int r);
523  operator <(const IntVar& l, const IntVar& r);
526  operator <(const IntVar& l, const BoolVar& r);
529  operator <(const BoolVar& l, const IntVar& r);
532  operator <(const BoolVar& l, const BoolVar& r);
535  operator <(const IntVar& l, const LinIntExpr& r);
538  operator <(const BoolVar& l, const LinIntExpr& r);
541  operator <(const LinIntExpr& l, const IntVar& r);
544  operator <(const LinIntExpr& l, const BoolVar& r);
547  operator <(const LinIntExpr& l, const LinIntExpr& r);
548 
551  operator <=(int l, const IntVar& r);
554  operator <=(int l, const BoolVar& r);
557  operator <=(int l, const LinIntExpr& r);
560  operator <=(const IntVar& l, int r);
563  operator <=(const BoolVar& l, int r);
566  operator <=(const LinIntExpr& l, int r);
569  operator <=(const IntVar& l, const IntVar& r);
572  operator <=(const IntVar& l, const BoolVar& r);
575  operator <=(const BoolVar& l, const IntVar& r);
578  operator <=(const BoolVar& l, const BoolVar& r);
581  operator <=(const IntVar& l, const LinIntExpr& r);
584  operator <=(const BoolVar& l, const LinIntExpr& r);
587  operator <=(const LinIntExpr& l, const IntVar& r);
590  operator <=(const LinIntExpr& l, const BoolVar& r);
593  operator <=(const LinIntExpr& l, const LinIntExpr& r);
594 
597  operator >(int l, const IntVar& r);
600  operator >(int l, const BoolVar& r);
603  operator >(int l, const LinIntExpr& r);
606  operator >(const IntVar& l, int r);
609  operator >(const BoolVar& l, int r);
612  operator >(const LinIntExpr& l, int r);
615  operator >(const IntVar& l, const IntVar& r);
618  operator >(const IntVar& l, const BoolVar& r);
621  operator >(const BoolVar& l, const IntVar& r);
624  operator >(const BoolVar& l, const BoolVar& r);
627  operator >(const IntVar& l, const LinIntExpr& r);
630  operator >(const BoolVar& l, const LinIntExpr& r);
633  operator >(const LinIntExpr& l, const IntVar& r);
636  operator >(const LinIntExpr& l, const BoolVar& r);
639  operator >(const LinIntExpr& l, const LinIntExpr& r);
640 
643  operator >=(int l, const IntVar& r);
646  operator >=(int l, const BoolVar& r);
649  operator >=(int l, const LinIntExpr& r);
652  operator >=(const IntVar& l, int r);
655  operator >=(const BoolVar& l, int r);
658  operator >=(const LinIntExpr& l, int r);
661  operator >=(const IntVar& l, const IntVar& r);
664  operator >=(const IntVar& l, const BoolVar& r);
667  operator >=(const BoolVar& l, const IntVar& r);
670  operator >=(const BoolVar& l, const BoolVar& r);
673  operator >=(const IntVar& l, const LinIntExpr& r);
676  operator >=(const BoolVar& l, const LinIntExpr& r);
679  operator >=(const LinIntExpr& l, const IntVar& r);
682  operator >=(const LinIntExpr& l, const BoolVar& r);
685  operator >=(const LinIntExpr& l, const LinIntExpr& r);
687 
688 #ifdef GECODE_HAS_FLOAT_VARS
689  class NonLinFloatExpr {
691  public:
693  virtual FloatVar post(Home home, FloatVar* ret) const = 0;
695  virtual void post(Home home, FloatRelType frt, FloatVal c) const = 0;
697  virtual void post(Home home, FloatRelType frt, FloatVal c,
698  BoolVar b) const = 0;
700  virtual ~NonLinFloatExpr(void) {}
702  static FloatVar result(Home home, FloatVar* x) {
703  if (x == NULL)
705  return *x;
706  }
708  static FloatVar result(Home home, FloatVar* x, FloatVar y) {
709  if (x!=NULL)
710  rel(home,*x,FRT_EQ,y);
711  return y;
712  }
714  void* operator new(size_t size) { return heap.ralloc(size); }
716  void operator delete(void* p, size_t) { heap.rfree(p); }
717  };
718 
720  class LinFloatExpr {
721  friend class LinFloatRel;
722  public:
724  enum NodeType {
732  };
733  private:
735  class Node;
736  Node* n;
737  public:
740  LinFloatExpr(void);
743  LinFloatExpr(const FloatVal& c);
746  LinFloatExpr(const FloatVar& x);
749  LinFloatExpr(const FloatVar& x, FloatVal a);
752  explicit LinFloatExpr(const FloatVarArgs& x);
755  LinFloatExpr(const FloatValArgs& a, const FloatVarArgs& x);
758  LinFloatExpr(const LinFloatExpr& e);
761  LinFloatExpr(const LinFloatExpr& e0, NodeType t, const LinFloatExpr& e1);
764  LinFloatExpr(const LinFloatExpr& e0, NodeType t, const FloatVal& c);
767  LinFloatExpr(FloatVal a, const LinFloatExpr& e);
770  explicit LinFloatExpr(NonLinFloatExpr* e);
773  const LinFloatExpr& operator =(const LinFloatExpr& e);
776  void post(Home home, FloatRelType frt) const;
779  void post(Home home, FloatRelType frt, const BoolVar& b) const;
782  FloatVar post(Home home) const;
785  NonLinFloatExpr* nlfe(void) const;
788  ~LinFloatExpr(void);
789  };
790 
791  class BoolExpr;
792 
794  class LinFloatRel {
795  friend class BoolExpr;
796  private:
798  LinFloatExpr e;
800  FloatRelType frt;
802  static FloatRelType neg(FloatRelType frt);
804  LinFloatRel(void);
805  public:
807  LinFloatRel(const LinFloatExpr& l, FloatRelType frt, const LinFloatExpr& r);
813  void post(Home home, bool t) const;
815  void post(Home home, const BoolVar& b, bool t) const;
816  };
817 
833  operator +(const FloatVal&, const FloatVar&);
836  operator +(const FloatVal&, const LinFloatExpr&);
839  operator +(const FloatVar&, const FloatVal&);
842  operator +(const LinFloatExpr&, const FloatVal&);
845  operator +(const FloatVar&, const FloatVar&);
848  operator +(const FloatVar&, const LinFloatExpr&);
851  operator +(const LinFloatExpr&, const FloatVar&);
854  operator +(const LinFloatExpr&, const LinFloatExpr&);
855 
858  operator -(const FloatVal&, const FloatVar&);
861  operator -(const FloatVal&, const LinFloatExpr&);
864  operator -(const FloatVar&, const FloatVal&);
867  operator -(const LinFloatExpr&, const FloatVal&);
870  operator -(const FloatVar&, const FloatVar&);
873  operator -(const FloatVar&, const LinFloatExpr&);
876  operator -(const LinFloatExpr&, const FloatVar&);
879  operator -(const LinFloatExpr&, const LinFloatExpr&);
880 
883  operator -(const FloatVar&);
886  operator -(const LinFloatExpr&);
887 
890  operator *(const FloatVal&, const FloatVar&);
893  operator *(const FloatVar&, const FloatVal&);
896  operator *(const LinFloatExpr&, const FloatVal&);
899  operator *(const FloatVal&, const LinFloatExpr&);
900 
903  sum(const FloatVarArgs& x);
906  sum(const FloatValArgs& a, const FloatVarArgs& x);
907 
910  operator ==(const FloatVal& l, const FloatVar& r);
913  operator ==(const FloatVal& l, const LinFloatExpr& r);
916  operator ==(const FloatVar& l, const FloatVal& r);
919  operator ==(const LinFloatExpr& l, const FloatVal& r);
922  operator ==(const FloatVar& l, const FloatVar& r);
925  operator ==(const FloatVar& l, const LinFloatExpr& r);
928  operator ==(const LinFloatExpr& l, const FloatVar& r);
931  operator ==(const LinFloatExpr& l, const LinFloatExpr& r);
932 
935  operator !=(const FloatVal& l, const FloatVar& r);
938  operator !=(const FloatVal& l, const LinFloatExpr& r);
941  operator !=(const FloatVar& l, const FloatVal& r);
944  operator !=(const LinFloatExpr& l, const FloatVal& r);
947  operator !=(const FloatVar& l, const FloatVar& r);
950  operator !=(const FloatVar& l, const LinFloatExpr& r);
953  operator !=(const LinFloatExpr& l, const FloatVar& r);
956  operator !=(const LinFloatExpr& l, const LinFloatExpr& r);
957 
960  operator <(const FloatVal& l, const FloatVar& r);
963  operator <(const FloatVal& l, const LinFloatExpr& r);
966  operator <(const FloatVar& l, const FloatVal& r);
969  operator <(const LinFloatExpr& l, const FloatVal& r);
972  operator <(const FloatVar& l, const FloatVar& r);
975  operator <(const FloatVar& l, const LinFloatExpr& r);
978  operator <(const LinFloatExpr& l, const FloatVar& r);
981  operator <(const LinFloatExpr& l, const LinFloatExpr& r);
982 
985  operator <=(const FloatVal& l, const FloatVar& r);
988  operator <=(const FloatVal& l, const LinFloatExpr& r);
991  operator <=(const FloatVar& l, const FloatVal& r);
994  operator <=(const LinFloatExpr& l, const FloatVal& r);
997  operator <=(const FloatVar& l, const FloatVar& r);
1000  operator <=(const FloatVar& l, const LinFloatExpr& r);
1003  operator <=(const LinFloatExpr& l, const FloatVar& r);
1006  operator <=(const LinFloatExpr& l, const LinFloatExpr& r);
1007 
1010  operator >(const FloatVal& l, const FloatVar& r);
1013  operator >(const FloatVal& l, const LinFloatExpr& r);
1016  operator >(const FloatVar& l, const FloatVal& r);
1019  operator >(const LinFloatExpr& l, const FloatVal& r);
1022  operator >(const FloatVar& l, const FloatVar& r);
1025  operator >(const FloatVar& l, const LinFloatExpr& r);
1028  operator >(const LinFloatExpr& l, const FloatVar& r);
1031  operator >(const LinFloatExpr& l, const LinFloatExpr& r);
1032 
1035  operator >=(const FloatVal& l, const FloatVar& r);
1038  operator >=(const FloatVal& l, const LinFloatExpr& r);
1041  operator >=(const FloatVar& l, const FloatVal& r);
1044  operator >=(const LinFloatExpr& l, const FloatVal& r);
1047  operator >=(const FloatVar& l, const FloatVar& r);
1050  operator >=(const FloatVar& l, const LinFloatExpr& r);
1053  operator >=(const LinFloatExpr& l, const FloatVar& r);
1056  operator >=(const LinFloatExpr& l, const LinFloatExpr& r);
1058 #endif
1059 
1060 #ifdef GECODE_HAS_SET_VARS
1061  class SetExpr {
1063  public:
1065  enum NodeType {
1073  };
1075  class Node;
1076  private:
1078  Node* n;
1079  public:
1081  SetExpr(void);
1084  SetExpr(const SetExpr& e);
1087  SetExpr(const SetExpr& l, NodeType t, const SetExpr& r);
1090  SetExpr(const SetVar& x);
1093  explicit SetExpr(const LinIntExpr& x);
1096  SetExpr(const IntSet& s);
1099  SetExpr(const SetExpr& e, NodeType t);
1102  SetVar post(Home home) const;
1105  void post(Home home, SetRelType srt, const SetExpr& e) const;
1108  void post(Home home, BoolVar b, bool t,
1109  SetRelType srt, const SetExpr& e) const;
1112  const SetExpr& operator =(const SetExpr& e);
1115  ~SetExpr(void);
1116  };
1117 
1119  class SetCmpRel {
1120  public:
1128  SetCmpRel(const SetExpr& l, SetRelType srt, const SetExpr& r);
1129  };
1130 
1132  class SetRel {
1133  private:
1135  SetExpr _e0;
1137  SetRelType _srt;
1139  SetExpr _e1;
1140  public:
1142  SetRel(void);
1144  SetRel(const SetExpr& e0, SetRelType srt, const SetExpr& e1);
1146  SetRel(const SetCmpRel& r);
1148  void post(Home home, bool t) const;
1150  void post(Home home, BoolVar b, bool t) const;
1151  };
1152 
1165  singleton(const LinIntExpr&);
1168  operator -(const SetExpr&);
1171  operator &(const SetExpr&, const SetExpr&);
1174  operator |(const SetExpr&, const SetExpr&);
1177  operator +(const SetExpr&, const SetExpr&);
1180  operator -(const SetExpr&, const SetExpr&);
1181 
1184  inter(const SetVarArgs&);
1187  setunion(const SetVarArgs&);
1190  setdunion(const SetVarArgs&);
1191 
1194  cardinality(const SetExpr&);
1197  min(const SetExpr&);
1200  max(const SetExpr&);
1201 
1204  operator ==(const SetExpr&, const SetExpr&);
1207  operator !=(const SetExpr&, const SetExpr&);
1210  operator <=(const SetExpr&, const SetExpr&);
1213  operator <=(const SetCmpRel&, const SetExpr&);
1216  operator >=(const SetExpr&, const SetExpr&);
1219  operator >=(const SetCmpRel&, const SetExpr&);
1222  operator ||(const SetExpr&, const SetExpr&);
1224 #endif
1225 
1227  class BoolExpr {
1228  public:
1230  enum NodeType {
1240  };
1243  public:
1245  Misc(void);
1250  virtual void post(Home home, BoolVar b, bool neg,
1251  IntPropLevel ipl) = 0;
1253  virtual GECODE_MINIMODEL_EXPORT ~Misc(void);
1254  };
1256  class Node;
1257  private:
1259  Node* n;
1260  public:
1263  BoolExpr(void);
1266  BoolExpr(const BoolExpr& e);
1269  BoolExpr(const BoolExpr& l, NodeType t, const BoolExpr& r);
1272  BoolExpr(const BoolVar& x);
1275  BoolExpr(const BoolExpr& e, NodeType t);
1278  BoolExpr(const LinIntRel& rl);
1279 #ifdef GECODE_HAS_FLOAT_VARS
1282  BoolExpr(const LinFloatRel& rfl);
1283 #endif
1284 #ifdef GECODE_HAS_SET_VARS
1287  BoolExpr(const SetRel& rs);
1290  BoolExpr(const SetCmpRel& rs);
1291 #endif
1294  explicit BoolExpr(Misc* m);
1297  BoolVar expr(Home home, IntPropLevel ipl) const;
1300  void rel(Home home, IntPropLevel ipl) const;
1303  const BoolExpr& operator =(const BoolExpr& e);
1306  ~BoolExpr(void);
1307  };
1308 
1321  operator !(const BoolExpr&);
1324  operator &&(const BoolExpr&, const BoolExpr&);
1327  operator ||(const BoolExpr&, const BoolExpr&);
1330  operator ^(const BoolExpr&, const BoolExpr&);
1331 
1334  operator !=(const BoolExpr&, const BoolExpr&);
1337  operator ==(const BoolExpr&, const BoolExpr&);
1340  operator >>(const BoolExpr&, const BoolExpr&);
1343  operator <<(const BoolExpr&, const BoolExpr&);
1344 
1346 
1355  expr(Home home, const LinIntExpr& e, IntPropLevel ipl=IPL_DEF);
1356 #ifdef GECODE_HAS_FLOAT_VARS
1359  expr(Home home, const LinFloatExpr& e);
1360 #endif
1361 #ifdef GECODE_HAS_SET_VARS
1364  expr(Home home, const SetExpr& e);
1365 #endif
1368  expr(Home home, const BoolExpr& e, IntPropLevel ipl=IPL_DEF);
1371  rel(Home home, const BoolExpr& e, IntPropLevel ipl=IPL_DEF);
1373 
1374 }
1375 
1381 
1382 namespace Gecode {
1383 
1384  namespace MiniModel {
1385  class ExpInfo;
1386  }
1387 
1394  friend class MiniModel::ExpInfo;
1395  private:
1397  class Exp;
1399  Exp* e;
1401  REG(Exp* e);
1403  std::string toString(void) const;
1404  public:
1406  REG(void);
1408  REG(int s);
1415  REG(const IntArgs& x);
1416 
1418  REG(const REG& r);
1420  const REG& operator =(const REG& r);
1421 
1423  REG operator +(const REG& r);
1425  REG& operator +=(const REG& r);
1427  REG operator |(const REG& r);
1429  REG& operator |=(const REG& r);
1431  REG operator *(void);
1433  REG operator +(void);
1435  REG operator ()(unsigned int n, unsigned int m);
1437  REG operator ()(unsigned int n);
1439  template<class Char, class Traits>
1440  std::basic_ostream<Char,Traits>&
1441  print(std::basic_ostream<Char,Traits>& os) const;
1443  operator DFA(void);
1445  ~REG(void);
1446  };
1447 
1451  template<class Char, class Traits>
1452  std::basic_ostream<Char,Traits>&
1453  operator <<(std::basic_ostream<Char,Traits>& os, const REG& r);
1454 
1455 }
1456 
1457 #include <gecode/minimodel/reg.hpp>
1458 
1459 namespace Gecode {
1460 
1467  GECODE_MINIMODEL_EXPORT LinIntExpr
1469  abs(const LinIntExpr& e);
1471  GECODE_MINIMODEL_EXPORT LinIntExpr
1472  min(const LinIntExpr& x, const LinIntExpr& y);
1474  GECODE_MINIMODEL_EXPORT LinIntExpr
1475  min(const IntVarArgs& x);
1477  GECODE_MINIMODEL_EXPORT LinIntExpr
1478  max(const LinIntExpr& x, const LinIntExpr& y);
1480  GECODE_MINIMODEL_EXPORT LinIntExpr
1481  max(const IntVarArgs& x);
1482 #ifdef GECODE_HAS_FLOAT_VARS
1483  GECODE_MINIMODEL_EXPORT LinFloatExpr
1485  operator *(const FloatVar&, const FloatVar&);
1487  GECODE_MINIMODEL_EXPORT LinFloatExpr
1488  operator *(const FloatVar&, const LinFloatExpr&);
1490  GECODE_MINIMODEL_EXPORT LinFloatExpr
1491  operator *(const LinFloatExpr&, const FloatVar&);
1492 #endif
1493  GECODE_MINIMODEL_EXPORT LinIntExpr
1495  operator *(const LinIntExpr& x, const LinIntExpr& y);
1497  GECODE_MINIMODEL_EXPORT LinIntExpr
1498  operator /(const LinIntExpr& x, const LinIntExpr& y);
1500  GECODE_MINIMODEL_EXPORT LinIntExpr
1501  operator %(const LinIntExpr& x, const LinIntExpr& y);
1503  GECODE_MINIMODEL_EXPORT LinIntExpr
1504  sqr(const LinIntExpr& x);
1506  GECODE_MINIMODEL_EXPORT LinIntExpr
1507  sqrt(const LinIntExpr& x);
1509  GECODE_MINIMODEL_EXPORT LinIntExpr
1510  pow(const LinIntExpr& x, int n);
1512  GECODE_MINIMODEL_EXPORT LinIntExpr
1513  nroot(const LinIntExpr& x, int n);
1515  GECODE_MINIMODEL_EXPORT LinIntExpr
1516  element(const IntVarArgs& x, const LinIntExpr& y);
1518  GECODE_MINIMODEL_EXPORT BoolExpr
1519  element(const BoolVarArgs& x, const LinIntExpr& y);
1521  GECODE_MINIMODEL_EXPORT LinIntExpr
1522  element(const IntArgs& x, const LinIntExpr& y);
1524  GECODE_MINIMODEL_EXPORT LinIntExpr
1525  ite(const BoolExpr& b, const LinIntExpr& x, const LinIntExpr& y);
1527 
1528 #ifdef GECODE_HAS_FLOAT_VARS
1529  GECODE_MINIMODEL_EXPORT LinFloatExpr
1531  abs(const LinFloatExpr& e);
1533  GECODE_MINIMODEL_EXPORT LinFloatExpr
1534  min(const LinFloatExpr& x, const LinFloatExpr& y);
1536  GECODE_MINIMODEL_EXPORT LinFloatExpr
1537  min(const FloatVarArgs& x);
1539  GECODE_MINIMODEL_EXPORT LinFloatExpr
1540  max(const LinFloatExpr& x, const LinFloatExpr& y);
1542  GECODE_MINIMODEL_EXPORT LinFloatExpr
1543  max(const FloatVarArgs& x);
1545  GECODE_MINIMODEL_EXPORT LinFloatExpr
1546  operator *(const LinFloatExpr& x, const LinFloatExpr& y);
1548  GECODE_MINIMODEL_EXPORT LinFloatExpr
1549  operator /(const LinFloatExpr& x, const LinFloatExpr& y);
1551  GECODE_MINIMODEL_EXPORT LinFloatExpr
1552  sqr(const LinFloatExpr& x);
1554  GECODE_MINIMODEL_EXPORT LinFloatExpr
1555  sqrt(const LinFloatExpr& x);
1557  GECODE_MINIMODEL_EXPORT LinFloatExpr
1558  pow(const LinFloatExpr& x, int n);
1560  GECODE_MINIMODEL_EXPORT LinFloatExpr
1561  nroot(const LinFloatExpr& x, int n);
1563 
1564 #ifdef GECODE_HAS_MPFR
1565 
1571  GECODE_MINIMODEL_EXPORT LinFloatExpr
1573  exp(const LinFloatExpr& x);
1575  GECODE_MINIMODEL_EXPORT LinFloatExpr
1576  log(const LinFloatExpr& x);
1578 
1585  GECODE_MINIMODEL_EXPORT LinFloatExpr
1587  asin(const LinFloatExpr& x);
1589  GECODE_MINIMODEL_EXPORT LinFloatExpr
1590  sin(const LinFloatExpr& x);
1592  GECODE_MINIMODEL_EXPORT LinFloatExpr
1593  acos(const LinFloatExpr& x);
1595  GECODE_MINIMODEL_EXPORT LinFloatExpr
1596  cos(const LinFloatExpr& x);
1598  GECODE_MINIMODEL_EXPORT LinFloatExpr
1599  atan(const LinFloatExpr& x);
1601  GECODE_MINIMODEL_EXPORT LinFloatExpr
1602  tan(const LinFloatExpr& x);
1604 #endif
1605 #endif
1606 
1613  inline BoolVar
1616  IntPropLevel ipl=IPL_DEF) {
1617  (void) ipl;
1618  BoolVar b(home,0,1); channel(home,b,x);
1619  return b;
1620  }
1622  inline IntVar
1624  IntPropLevel ipl=IPL_DEF) {
1625  (void) ipl;
1626  IntVar x(home,0,1); channel(home,b,x);
1627  return x;
1628  }
1629 #ifdef GECODE_HAS_FLOAT_VARS
1630  inline IntVar
1633  int min = static_cast<int>(std::max(static_cast<double>(Int::Limits::min),
1634  std::ceil(f.min())));
1635  int max = static_cast<int>(std::min(static_cast<double>(Int::Limits::max),
1636  std::floor(f.max())));
1637  IntVar x(home,min,max);
1638  channel(home,f,x);
1639  return x;
1640  }
1641 #endif
1642 #ifdef GECODE_HAS_SET_VARS
1643  inline SetVar
1646  (void) ipl;
1648  rel(home,SOT_UNION,x,s);
1649  nvalues(home,x,IRT_EQ,expr(home,cardinality(s)));
1650  return s;
1651  }
1652 #endif
1653 
1654 
1655 }
1656 
1657 namespace Gecode {
1658 
1673  inline void
1674  atmost(Home home, const IntVarArgs& x, int n, int m,
1675  IntPropLevel ipl=IPL_DEF) {
1676  count(home,x,n,IRT_LQ,m,ipl);
1677  }
1682  inline void
1683  atmost(Home home, const IntVarArgs& x, IntVar y, int m,
1684  IntPropLevel ipl=IPL_DEF) {
1685  count(home,x,y,IRT_LQ,m,ipl);
1686  }
1694  inline void
1695  atmost(Home home, const IntVarArgs& x, const IntArgs& y, int m,
1696  IntPropLevel ipl=IPL_DEF) {
1697  count(home,x,y,IRT_LQ,m,ipl);
1698  }
1703  inline void
1704  atmost(Home home, const IntVarArgs& x, int n, IntVar z,
1705  IntPropLevel ipl=IPL_DEF) {
1706  count(home,x,n,IRT_LQ,z,ipl);
1707  }
1712  inline void
1714  IntPropLevel ipl=IPL_DEF) {
1715  count(home,x,y,IRT_LQ,z,ipl);
1716  }
1724  inline void
1725  atmost(Home home, const IntVarArgs& x, const IntArgs& y, IntVar z,
1726  IntPropLevel ipl=IPL_DEF) {
1727  count(home,x,y,IRT_LQ,z,ipl);
1728  }
1729 
1734  inline void
1735  atleast(Home home, const IntVarArgs& x, int n, int m,
1736  IntPropLevel ipl=IPL_DEF) {
1737  count(home,x,n,IRT_GQ,m,ipl);
1738  }
1743  inline void
1744  atleast(Home home, const IntVarArgs& x, IntVar y, int m,
1745  IntPropLevel ipl=IPL_DEF) {
1746  count(home,x,y,IRT_GQ,m,ipl);
1747  }
1755  inline void
1756  atleast(Home home, const IntVarArgs& x, const IntArgs& y, int m,
1757  IntPropLevel ipl=IPL_DEF) {
1758  count(home,x,y,IRT_GQ,m,ipl);
1759  }
1764  inline void
1765  atleast(Home home, const IntVarArgs& x, int n, IntVar z,
1766  IntPropLevel ipl=IPL_DEF) {
1767  count(home,x,n,IRT_GQ,z,ipl);
1768  }
1773  inline void
1775  IntPropLevel ipl=IPL_DEF) {
1776  count(home,x,y,IRT_GQ,z,ipl);
1777  }
1785  inline void
1786  atleast(Home home, const IntVarArgs& x, const IntArgs& y, IntVar z,
1787  IntPropLevel ipl=IPL_DEF) {
1788  count(home,x,y,IRT_GQ,z,ipl);
1789  }
1790 
1795  inline void
1796  exactly(Home home, const IntVarArgs& x, int n, int m,
1797  IntPropLevel ipl=IPL_DEF) {
1798  count(home,x,n,IRT_EQ,m,ipl);
1799  }
1804  inline void
1805  exactly(Home home, const IntVarArgs& x, IntVar y, int m,
1806  IntPropLevel ipl=IPL_DEF) {
1807  count(home,x,y,IRT_EQ,m,ipl);
1808  }
1816  inline void
1817  exactly(Home home, const IntVarArgs& x, const IntArgs& y, int m,
1818  IntPropLevel ipl=IPL_DEF) {
1819  count(home,x,y,IRT_EQ,m,ipl);
1820  }
1825  inline void
1826  exactly(Home home, const IntVarArgs& x, int n, IntVar z,
1827  IntPropLevel ipl=IPL_DEF) {
1828  count(home,x,n,IRT_EQ,z,ipl);
1829  }
1834  inline void
1836  IntPropLevel ipl=IPL_DEF) {
1837  count(home,x,y,IRT_EQ,z,ipl);
1838  }
1846  inline void
1847  exactly(Home home, const IntVarArgs& x, const IntArgs& y, IntVar z,
1848  IntPropLevel ipl=IPL_DEF) {
1849  count(home,x,y,IRT_EQ,z,ipl);
1850  }
1853  inline void
1854  lex(Home home, const IntVarArgs& x, IntRelType r, const IntVarArgs& y,
1855  IntPropLevel ipl=IPL_DEF) {
1856  rel(home,x,r,y,ipl);
1857  }
1860  inline void
1861  lex(Home home, const BoolVarArgs& x, IntRelType r, const BoolVarArgs& y,
1862  IntPropLevel ipl=IPL_DEF) {
1863  rel(home,x,r,y,ipl);
1864  }
1867  inline void
1868  values(Home home, const IntVarArgs& x, IntSet y,
1869  IntPropLevel ipl=IPL_DEF) {
1870  dom(home,x,y,ipl);
1871  nvalues(home,x,IRT_EQ,static_cast<int>(y.size()),ipl);
1872  }
1873 
1875 
1876 #ifdef GECODE_HAS_SET_VARS
1877 
1892  inline void
1893  channel(Home home, const IntVarArgs& x, SetVar y) {
1894  rel(home,SOT_UNION,x,y);
1895  nvalues(home,x,IRT_EQ,expr(home,cardinality(y)));
1896  }
1897 
1900  inline void
1901  range(Home home, const IntVarArgs& x, SetVar y, SetVar z) {
1902  element(home,SOT_UNION,x,y,z);
1903  }
1904 
1910  inline void
1911  roots(Home home, const IntVarArgs& x, SetVar y, SetVar z) {
1912  SetVarArgs xiv(home,z.lubMax()+1,IntSet::empty,0,x.size()-1);
1913  channel(home,x,xiv);
1914  element(home,SOT_UNION,xiv,z,y);
1915  }
1916 
1918 #endif
1919 }
1920 
1921 namespace Gecode {
1922 
1923  template<class> class Matrix;
1924 
1932  template<class A>
1933  class Slice {
1934  public:
1937  private:
1938  ArgsType _r;
1939  int _fc,
1940  _tc,
1941  _fr,
1942  _tr;
1943  public:
1945  Slice(const Matrix<A>& a, int fc, int tc, int fr, int tr);
1949  Slice& reverse(void);
1951  operator ArgsType(void);
1953  operator Matrix<ArgsType>(void);
1954 
1956  operator const ArgsType(void) const;
1958  operator const Matrix<ArgsType>(void) const;
1959  };
1960 
1962  template<class A>
1963  typename Slice<A>::ArgsType
1964  operator+(const Slice<A>& x, const Slice<A>& y);
1965 
1967  template<class A>
1968  typename Slice<A>::ArgsType
1969  operator+(const Slice<A>& x, const typename ArrayTraits<A>::ArgsType& y);
1970 
1972  template<class A>
1973  typename Slice<A>::ArgsType
1974  operator+(const typename ArrayTraits<A>::ArgsType& x, const Slice<A>& y);
1975 
1977  template<class A>
1978  typename Slice<A>::ArgsType
1979  operator+(const Slice<A>& x, const typename ArrayTraits<A>::ValueType& y);
1980 
1982  template<class A>
1983  typename Slice<A>::ArgsType
1984  operator+(const typename ArrayTraits<A>::ValueType& x, const Slice<A>& y);
1985 
1996  template<class A>
1997  class Matrix {
1998  public:
2003 
2004  private:
2006  typedef typename ArrayTraits<A>::StorageType StorageType;
2007  StorageType _a;
2008  int _w;
2009  int _h;
2010 
2011  public:
2024  Matrix(A a, int w, int h);
2025 
2038  Matrix(A a, int n);
2039 
2041  int width(void) const;
2043  int height(void) const;
2045  ArgsType const get_array(void) const;
2046 
2052  ValueType& operator ()(int c, int r);
2053 
2059  const ValueType& operator ()(int c, int r) const;
2060 
2070  Slice<A> slice(int fc, int tc, int fr, int tr) const;
2071 
2073  Slice<A> row(int r) const;
2074 
2076  Slice<A> col(int c) const;
2077  };
2078 
2082  template<class Char, class Traits, class A>
2083  std::basic_ostream<Char,Traits>&
2084  operator <<(std::basic_ostream<Char,Traits>& os, const Matrix<A>& m);
2085 
2089  template<class Char, class Traits, class A>
2090  std::basic_ostream<Char,Traits>&
2091  operator <<(std::basic_ostream<Char,Traits>& os, const Slice<A>& s);
2092 
2099  void element(Home home, const Matrix<IntArgs>& m, IntVar x, IntVar y,
2100  IntVar z, IntPropLevel ipl=IPL_DEF);
2107  void element(Home home, const Matrix<IntArgs>& m, IntVar x, IntVar y,
2108  BoolVar z, IntPropLevel ipl=IPL_DEF);
2115  void element(Home home, const Matrix<IntVarArgs>& m, IntVar x, IntVar y,
2116  IntVar z, IntPropLevel ipl=IPL_DEF);
2123  void element(Home home, const Matrix<BoolVarArgs>& m, IntVar x, IntVar y,
2124  BoolVar z, IntPropLevel ipl=IPL_DEF);
2125 #ifdef GECODE_HAS_SET_VARS
2126 
2132  void element(Home home, const Matrix<IntSetArgs>& m, IntVar x, IntVar y,
2133  SetVar z);
2140  void element(Home home, const Matrix<SetVarArgs>& m, IntVar x, IntVar y,
2141  SetVar z);
2142 #endif
2143 
2147  template<class A>
2152  template<class A>
2157  template<class A>
2162  template<class A>
2169  template<class A>
2171 }
2172 
2173 #include <gecode/minimodel/matrix.hpp>
2174 #include <gecode/minimodel/ldsb.hpp>
2175 
2180 namespace Gecode {
2181 
2183  GECODE_MINIMODEL_EXPORT LinIntExpr
2184  sum(const Slice<IntArgs>& slice);
2186  GECODE_MINIMODEL_EXPORT LinIntExpr
2187  sum(const Matrix<IntArgs>& matrix);
2188 
2189 }
2192 namespace Gecode {
2193 
2208  public:
2210  IntMinimizeSpace(void);
2212  IntMinimizeSpace(bool share, IntMinimizeSpace& s);
2215  virtual void constrain(const Space& best);
2217  virtual IntVar cost(void) const = 0;
2218  };
2219 
2225  public:
2227  IntMaximizeSpace(void);
2229  IntMaximizeSpace(bool share, IntMaximizeSpace& s);
2232  virtual void constrain(const Space& best);
2234  virtual IntVar cost(void) const = 0;
2235  };
2236 
2247 
2248 
2249 #ifdef GECODE_HAS_FLOAT_VARS
2250 
2261  protected:
2264  public:
2268  FloatMinimizeSpace(bool share, FloatMinimizeSpace& s);
2271  virtual void constrain(const Space& best);
2273  virtual FloatVar cost(void) const = 0;
2274  };
2275 
2286  protected:
2289  public:
2293  FloatMaximizeSpace(bool share, FloatMaximizeSpace& s);
2296  virtual void constrain(const Space& best);
2298  virtual FloatVar cost(void) const = 0;
2299  };
2300 
2301 #endif
2302 
2303 }
2304 
2306 
2307 #endif
2308 
2309 // IFDEF: GECODE_HAS_INT_VARS
2310 // STATISTICS: minimodel-any
2311 
SetExpr singleton(const LinIntExpr &e)
Singleton expression.
Definition: set-expr.cpp:694
Passing float arguments.
Definition: float.hh:954
FloatVal operator -(const FloatVal &x)
Definition: val.hpp:172
const BoolExpr & operator=(const BoolExpr &e)
Assignment operator.
Definition: bool-expr.cpp:210
Class for minimizing integer cost.
Definition: minimodel.hh:2207
BoolExpr operator &&(const BoolExpr &l, const BoolExpr &r)
Conjunction of Boolean expressions.
Definition: bool-expr.cpp:592
SetRelType srt
Which relation.
Definition: minimodel.hh:1126
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:1854
Slice< A > col(int c) const
Access column c.
Definition: matrix.hpp:187
const SetExpr & operator=(const SetExpr &e)
Assignment operator.
Definition: set-expr.cpp:632
NNF * l
Left subtree.
Definition: bool-expr.cpp:244
virtual ~NonLinFloatExpr(void)
Destructor.
Definition: minimodel.hh:700
const int min
Smallest allowed integer in integer set.
Definition: set.hh:103
void log(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
FloatVal operator *(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:204
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:122
Set relations
Definition: minimodel.hh:1132
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
bool operator >=(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:281
Regular expressions over integer values.
Definition: minimodel.hh:1393
Reified linear relation.
Definition: minimodel.hh:1237
Linear term with Boolean variable.
Definition: minimodel.hh:155
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:2288
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:909
void nroot(Home home, FloatVar x0, int n, FloatVar x1)
Post propagator for for $n\geq 0$.
Definition: arithmetic.cpp:122
Linear relations over integer variables.
Definition: minimodel.hh:232
void atmost(Home home, const IntVarArgs &x, int n, int m, IntPropLevel ipl=IPL_DEF)
Post constraint .
Definition: minimodel.hh:1674
void pow(Home home, FloatVar x0, int n, FloatVar x1)
Post propagator for for $n\geq 0$.
Definition: arithmetic.cpp:113
BoolExpr operator ^(const BoolExpr &l, const BoolExpr &r)
Exclusive-or of Boolean expressions.
Definition: bool-expr.cpp:600
void dom(Home home, FloatVar x, FloatVal n)
Propagates .
Definition: dom.cpp:44
int height(void) const
Return the height of the matrix.
Definition: matrix.hpp:150
Base class for non-linear expressions over integer variables.
Definition: minimodel.hh:111
void * ralloc(size_t s)
Allocate s bytes from heap.
Definition: heap.hpp:361
Slice< A > slice(int fc, int tc, int fr, int tr) const
Access slice of the matrix.
Definition: matrix.hpp:175
Addition of linear terms.
Definition: minimodel.hh:159
void roots(Home home, const IntVarArgs &x, SetVar y, SetVar z)
Post constraint .
Definition: minimodel.hh:1911
SymmetryHandle columns_interchange(const Matrix< A > &m)
Interchangeable columns symmetry specification.
Definition: ldsb.hpp:55
Expression information.
Definition: reg.cpp:537
~BoolExpr(void)
Destructor.
Definition: bool-expr.cpp:222
Multiplication by coefficient.
Definition: minimodel.hh:161
Linear term with variable.
Definition: minimodel.hh:726
void post(Home home, bool t) const
Post propagator for relation (if t is false for negated relation)
Definition: float-rel.hpp:76
Comparison relation (for two-sided comparisons)
Definition: minimodel.hh:1119
const int max
Largest allowed integer in integer set.
Definition: set.hh:101
virtual FloatVar post(Home home, FloatVar *ret) const =0
Return variable constrained to be equal to the expression.
IntMinimizeSpace MinimizeSpace
Class for minimizing integer cost.
Definition: minimodel.hh:2241
Linear expression.
Definition: minimodel.hh:1068
Linear term with integer variable.
Definition: minimodel.hh:154
Class for maximizing float cost.
Definition: minimodel.hh:2285
const int max
Largest allowed integer value.
Definition: int.hh:116
Computation spaces.
Definition: core.hpp:1748
Greater or equal ( )
Definition: int.hh:911
Set expressions
Definition: minimodel.hh:1062
const int min
Smallest allowed integer value.
Definition: int.hh:118
void atleast(Home home, const IntVarArgs &x, int n, int m, IntPropLevel ipl=IPL_DEF)
Post constraint .
Definition: minimodel.hh:1735
ArrayTraits< A >::ValueType ValueType
The type of elements of this array.
Definition: minimodel.hh:2000
Reified linear relation.
Definition: minimodel.hh:1236
SetRel(void)
Default constructor.
Definition: set-rel.hpp:51
const LinIntExpr & operator=(const LinIntExpr &e)
Assignment operator.
Definition: int-expr.cpp:495
void rel(Home home, IntPropLevel ipl) const
Post propagators for relation.
Definition: bool-expr.cpp:585
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:124
IntMaximizeSpace MaximizeSpace
Class for maximizing integer cost.
Definition: minimodel.hh:2246
int lubMax(void) const
Return maximum element of least upper bound.
Definition: set.hpp:91
struct Gecode::@579::NNF::@61::@63 a
For atomic nodes.
Gecode::FloatVal c(-8, 8)
Miscealloneous Boolean expressions.
Definition: minimodel.hh:1242
static FloatVar result(Home home, FloatVar *x)
Return fresh variable if x is NULL, x otherwise.
Definition: minimodel.hh:702
Deterministic finite automaton (DFA)
Definition: int.hh:2034
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:1933
SetExpr operator &(const SetExpr &l, const SetExpr &r)
Intersection of set expressions.
Definition: set-expr.cpp:674
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:907
Slice & reverse(void)
Reverses the contents of the slice, and returns a reference to it.
Definition: matrix.hpp:66
Base class for non-linear float expressions.
Definition: minimodel.hh:690
Matrix(A a, int w, int h)
Basic constructor.
Definition: matrix.hpp:131
A reference-counted pointer to a SymmetryObject.
Definition: int.hh:4837
void nvalues(Home home, const IntVarArgs &x, IntRelType irt, int y, IntPropLevel)
Post propagator for .
Definition: nvalues.cpp:44
IntRelType
Relation types for integers.
Definition: int.hh:906
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:130
void sqr(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition: arithmetic.cpp:99
FloatRelType
Relation types for floats.
Definition: float.hh:1069
void post(Home home, bool t) const
Post propagators for relation (or negated relation if t is false)
Definition: set-rel.hpp:62
Linear relations.
Definition: minimodel.hh:794
Simple propagation levels.
Definition: int.hh:957
SetExpr(void)
Default constructor.
Definition: set-expr.hpp:48
SetExpr r
Right side of relation.
Definition: minimodel.hh:1124
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.
struct Gecode::@579::NNF::@61::@62 b
For binary nodes (and, or, eqv)
static FloatVar result(Home home, FloatVar *x, FloatVar y)
Constrain x to be equal to y if x is not NULL.
Definition: minimodel.hh:708
void range(Home home, const IntVarArgs &x, SetVar y, SetVar z)
Post constraint .
Definition: minimodel.hh:1901
LinIntExpr(void)
Default constructor.
Definition: int-expr.cpp:353
Reified set relation.
Definition: minimodel.hh:1238
ArrayTraits< A >::ArgsType ArgsType
The type of the Args-array type for ValueType values.
Definition: minimodel.hh:2002
Subtraction of linear terms.
Definition: minimodel.hh:730
void post(Home home, IntRelType irt, IntPropLevel ipl) const
Post propagator.
Definition: int-expr.cpp:160
Float expressions
Definition: minimodel.hh:720
NodeType
Type of set expression.
Definition: minimodel.hh:1065
Integer sets.
Definition: int.hh:174
NodeType
Type of linear expression.
Definition: minimodel.hh:152
LinFloatExpr(void)
Default constructor.
Definition: float-expr.cpp:228
Post propagator for SetVar SetOpType SetVar SetRelType SetVar z
Definition: set.hh:784
~LinFloatExpr(void)
Destructor.
Definition: float-expr.cpp:339
SetExpr setunion(const SetVarArgs &x)
Union of set variables.
Definition: set-expr.cpp:708
Boolean expressions.
Definition: minimodel.hh:1227
void asin(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
SetExpr l
Left side of relation.
Definition: minimodel.hh:1122
Passing integer variables.
Definition: int.hh:639
bool operator >(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:264
Passing integer arguments.
Definition: int.hh:610
NodeType
Type of linear expression.
Definition: minimodel.hh:724
Passing Boolean variables.
Definition: int.hh:693
int width(void) const
Return the width of the matrix.
Definition: matrix.hpp:147
Equality ( )
Definition: float.hh:1070
Non-linear expression.
Definition: minimodel.hh:156
static const IntSet empty
Empty set.
Definition: int.hh:265
Multiplication by coefficient.
Definition: minimodel.hh:731
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
Other Boolean expression.
Definition: minimodel.hh:1239
Boolean integer variables.
Definition: int.hh:494
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:784
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
ArrayTraits< A >::ArgsType ArgsType
The type of the Args-array type for ValueType values.
Definition: minimodel.hh:1936
void cos(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
IntPropLevel
Propagation levels for integer propagators.
Definition: int.hh:955
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
Passing set variables.
Definition: set.hh:492
virtual IntVar post(Home home, IntVar *ret, IntPropLevel ipl) const =0
Return variable constrained to be equal to the expression.
Post propagator for f(x \diamond_{\mathit{op}} y) \sim_r z \f$ void rel(Home home
const LinFloatExpr & operator=(const LinFloatExpr &e)
Assignment operator.
Definition: float-expr.cpp:330
Sum of float variables.
Definition: minimodel.hh:728
Post propagator for SetVar SetOpType SetVar y
Definition: set.hh:784
Class for maximizing integer cost.
Definition: minimodel.hh:2224
Non-linear expression.
Definition: minimodel.hh:727
NodeType
Type of Boolean expression.
Definition: minimodel.hh:1230
Float value type.
Definition: float.hh:338
~LinIntExpr(void)
Destructor.
Definition: int-expr.cpp:504
SymmetryHandle diagonal_reflect(const Matrix< A > &m)
Reflect around main diagonal symmetry specification.
Definition: ldsb.hpp:112
Set variables
Definition: set.hh:131
Sum of integer variables.
Definition: minimodel.hh:157
Linear expressions over integer variables.
Definition: minimodel.hh:142
void tan(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Slice< A > row(int r) const
Access row r.
Definition: matrix.hpp:181
SetCmpRel(const SetExpr &l, SetRelType srt, const SetExpr &r)
Constructor.
Definition: set-rel.hpp:47
Integer variables.
Definition: int.hh:353
Heap heap
The single global heap.
Definition: heap.cpp:48
BoolExpr operator !(const BoolExpr &e)
Negated Boolean expression.
Definition: bool-expr.cpp:605
void rel(Home home, FloatVar x0, FloatRelType frt, FloatVal n)
Propagates .
Definition: rel.cpp:47
NonLinIntExpr * nle(void) const
Return non-linear expression inside, or NULL if not non-linear.
Definition: int-expr.cpp:349
Sum of Boolean variables.
Definition: minimodel.hh:158
SymmetryHandle rows_interchange(const Matrix< A > &m)
Interchangeable rows symmetry specification.
Definition: ldsb.hpp:44
ValueType & operator()(int c, int r)
Access element (c, r) of the matrix.
Definition: matrix.hpp:159
Subtraction of linear terms.
Definition: minimodel.hh:160
void values(Home home, const IntVarArgs &x, IntSet y, IntPropLevel ipl=IPL_DEF)
Post constraint .
Definition: minimodel.hh:1868
Post propagator for SetVar x
Definition: set.hh:784
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:80
Matrix-interface for arrays.
Definition: minimodel.hh:1923
Float variables.
Definition: float.hh:874
SetExpr operator|(const SetExpr &l, const SetExpr &r)
Union of set expressions.
Definition: set-expr.cpp:678
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:729
Traits of arrays in Gecode.
Definition: array.hpp:68
bool operator<=(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:247
void post(Home home, bool t, IntPropLevel ipl) const
Post propagator for relation (if t is false for negated relation)
Definition: int-rel.hpp:74
Float value constant.
Definition: minimodel.hh:725
Class for minimizing float cost.
Definition: minimodel.hh:2260
LinIntExpr operator %(const LinIntExpr &e0, const LinIntExpr &e1)
Return expression for .
Definition: int-arith.cpp:456
Gecode toplevel namespace
Slice(const Matrix< A > &a, int fc, int tc, int fr, int tr)
Construct slice.
Definition: matrix.hpp:47
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 .
ArgsType const get_array(void) const
Return an Args-array of the contents of the matrix.
Definition: matrix.hpp:153
#define GECODE_VTABLE_EXPORT
Definition: support.hh:76
BoolVar expr(Home home, IntPropLevel ipl) const
Post propagators for expression.
Definition: bool-expr.cpp:579
NonLinFloatExpr * nlfe(void) const
Return non-linear expression inside, or NULL if not non-linear.
Definition: float-expr.cpp:142
bool operator !=(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:321
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:922
Base class for heap allocated objects.
Definition: heap.hpp:344
~SetExpr(void)
Destructor.
Definition: set-expr.cpp:642
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:1796
const unsigned int slice
Size of a slice in a portfolio and scale factor for restarts(in number of failures)
Definition: search.hh:124
FloatNum step
Step by which a next solution has to have lower cost.
Definition: minimodel.hh:2263
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 .
SetVar post(Home home) const
Post propagators for expression.
Definition: set-expr.cpp:652
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.
SymmetryHandle rows_reflect(const Matrix< A > &m)
Reflect rows symmetry specification.
Definition: ldsb.hpp:66
bool neg
Is atomic formula negative.
Definition: bool-expr.cpp:251
void post(Home home, FloatRelType frt) const
Post propagator.
Definition: float-expr.cpp:156
BoolExpr(void)
Default constructor.
Definition: bool-expr.cpp:118
Archive & operator >>(Archive &e, FloatNumBranch &nl)
Definition: val-sel.hpp:48