Generated on Sat Feb 7 2015 02:01:28 for Gecode by doxygen 1.8.9.1
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: 2013-08-19 14:00:39 +0200 (Mon, 19 Aug 2013) $ by $Author: schulte $
17  * $Revision: 13982 $
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 
57 
58 #include <iostream>
59 
60 /*
61  * Support for DLLs under Windows
62  *
63  */
64 
65 #if !defined(GECODE_STATIC_LIBS) && \
66  (defined(__CYGWIN__) || defined(__MINGW32__) || defined(_MSC_VER))
67 
68 #ifdef GECODE_BUILD_MINIMODEL
69 #define GECODE_MINIMODEL_EXPORT __declspec( dllexport )
70 #else
71 #define GECODE_MINIMODEL_EXPORT __declspec( dllimport )
72 #endif
73 
74 #else
75 
76 #ifdef GECODE_GCC_HAS_CLASS_VISIBILITY
77 
78 #define GECODE_MINIMODEL_EXPORT __attribute__ ((visibility("default")))
79 
80 #else
81 
82 #define GECODE_MINIMODEL_EXPORT
83 
84 #endif
85 #endif
86 
87 // Configure auto-linking
88 #ifndef GECODE_BUILD_MINIMODEL
89 #define GECODE_LIBRARY_NAME "MiniModel"
91 #endif
92 
93 namespace Gecode {
94 
96  namespace MiniModel {}
97 
98  class LinIntRel;
99 #ifdef GECODE_HAS_SET_VARS
100  class SetExpr;
101 #endif
102 #ifdef GECODE_HAS_FLOAT_VARS
103  class LinFloatExpr;
104 #endif
105 
108  public:
110  virtual IntVar post(Home home, IntVar* ret, IntConLevel icl) const = 0;
112  virtual void post(Home home, IntRelType irt, int c,
113  IntConLevel icl) const = 0;
115  virtual void post(Home home, IntRelType irt, int c,
116  BoolVar b, IntConLevel icl) const = 0;
118  virtual ~NonLinIntExpr(void) {}
120  static IntVar result(Home home, IntVar* x) {
121  if (x==NULL)
123  return *x;
124  }
126  static IntVar result(Home home, IntVar* x, IntVar y) {
127  if (x!=NULL)
128  rel(home,*x,IRT_EQ,y);
129  return y;
130  }
132  void* operator new(size_t size) { return heap.ralloc(size); }
134  void operator delete(void* p, size_t) { heap.rfree(p); }
135  };
136 
138  class LinIntExpr {
139  friend class LinIntRel;
140 #ifdef GECODE_HAS_SET_VARS
141  friend class SetExpr;
142 #endif
143 #ifdef GECODE_HAS_FLOAT_VARS
144  friend class LinFloatExpr;
145 #endif
146  public:
148  enum NodeType {
158  };
159  private:
161  class Node;
162  Node* n;
163  public:
166  LinIntExpr(void);
169  LinIntExpr(int c);
172  LinIntExpr(const IntVar& x, int a=1);
175  LinIntExpr(const BoolVar& x, int a=1);
178  explicit LinIntExpr(const IntVarArgs& x);
181  LinIntExpr(const IntArgs& a, const IntVarArgs& x);
184  explicit LinIntExpr(const BoolVarArgs& x);
187  LinIntExpr(const IntArgs& a, const BoolVarArgs& x);
190  LinIntExpr(const LinIntExpr& e);
193  LinIntExpr(const LinIntExpr& e0, NodeType t, const LinIntExpr& e1);
196  LinIntExpr(const LinIntExpr& e0, NodeType t, int c);
199  LinIntExpr(int a, const LinIntExpr& e);
202  explicit LinIntExpr(NonLinIntExpr* e);
205  const LinIntExpr& operator =(const LinIntExpr& e);
208  void post(Home home, IntRelType irt, IntConLevel icl) const;
211  void post(Home home, IntRelType irt, const BoolVar& b,
212  IntConLevel icl) const;
215  IntVar post(Home home, IntConLevel icl) const;
218  NonLinIntExpr* nle(void) const;
221  ~LinIntExpr(void);
222  };
223 
224  class BoolExpr;
225 
227  class LinIntRel {
228  friend class BoolExpr;
229  private:
231  LinIntExpr e;
233  IntRelType irt;
235  static IntRelType neg(IntRelType irt);
237  LinIntRel(void);
238  public:
240  LinIntRel(const LinIntExpr& l, IntRelType irt, const LinIntExpr& r);
242  LinIntRel(const LinIntExpr& l, IntRelType irt, int r);
244  LinIntRel(int l, IntRelType irt, const LinIntExpr& r);
246  void post(Home home, bool t, IntConLevel icl) const;
248  void post(Home home, const BoolVar& b, bool t, IntConLevel icl) const;
249  };
250 
271  operator +(int, const IntVar&);
274  operator +(int, const BoolVar&);
277  operator +(int, const LinIntExpr&);
280  operator +(const IntVar&, int);
283  operator +(const BoolVar&, int);
286  operator +(const LinIntExpr&, int);
289  operator +(const IntVar&, const IntVar&);
292  operator +(const IntVar&, const BoolVar&);
295  operator +(const BoolVar&, const IntVar&);
298  operator +(const BoolVar&, const BoolVar&);
301  operator +(const IntVar&, const LinIntExpr&);
304  operator +(const BoolVar&, const LinIntExpr&);
307  operator +(const LinIntExpr&, const IntVar&);
310  operator +(const LinIntExpr&, const BoolVar&);
313  operator +(const LinIntExpr&, const LinIntExpr&);
314 
317  operator -(int, const IntVar&);
320  operator -(int, const BoolVar&);
323  operator -(int, const LinIntExpr&);
326  operator -(const IntVar&, int);
329  operator -(const BoolVar&, int);
332  operator -(const LinIntExpr&, int);
335  operator -(const IntVar&, const IntVar&);
338  operator -(const IntVar&, const BoolVar&);
341  operator -(const BoolVar&, const IntVar&);
344  operator -(const BoolVar&, const BoolVar&);
347  operator -(const IntVar&, const LinIntExpr&);
350  operator -(const BoolVar&, const LinIntExpr&);
353  operator -(const LinIntExpr&, const IntVar&);
356  operator -(const LinIntExpr&, const BoolVar&);
359  operator -(const LinIntExpr&, const LinIntExpr&);
360 
363  operator -(const IntVar&);
366  operator -(const BoolVar&);
369  operator -(const LinIntExpr&);
370 
373  operator *(int, const IntVar&);
376  operator *(int, const BoolVar&);
379  operator *(const IntVar&, int);
382  operator *(const BoolVar&, int);
385  operator *(const LinIntExpr&, int);
388  operator *(int, const LinIntExpr&);
389 
392  sum(const IntVarArgs& x);
395  sum(const IntArgs& a, const IntVarArgs& x);
398  sum(const BoolVarArgs& x);
401  sum(const IntArgs& a, const BoolVarArgs& x);
404  sum(const IntArgs& args);
405 
408  operator ==(int l, const IntVar& r);
411  operator ==(int l, const BoolVar& r);
414  operator ==(int l, const LinIntExpr& r);
417  operator ==(const IntVar& l, int r);
420  operator ==(const BoolVar& l, int r);
423  operator ==(const LinIntExpr& l, int r);
426  operator ==(const IntVar& l, const IntVar& r);
429  operator ==(const IntVar& l, const BoolVar& r);
432  operator ==(const BoolVar& l, const IntVar& r);
435  operator ==(const BoolVar& l, const BoolVar& r);
438  operator ==(const IntVar& l, const LinIntExpr& r);
441  operator ==(const BoolVar& l, const LinIntExpr& r);
444  operator ==(const LinIntExpr& l, const IntVar& r);
447  operator ==(const LinIntExpr& l, const BoolVar& r);
450  operator ==(const LinIntExpr& l, const LinIntExpr& r);
451 
454  operator !=(int l, const IntVar& r);
457  operator !=(int l, const BoolVar& r);
460  operator !=(int l, const LinIntExpr& r);
463  operator !=(const IntVar& l, int r);
466  operator !=(const BoolVar& l, int r);
469  operator !=(const LinIntExpr& l, int r);
472  operator !=(const IntVar& l, const IntVar& r);
475  operator !=(const IntVar& l, const BoolVar& r);
478  operator !=(const BoolVar& l, const IntVar& r);
481  operator !=(const BoolVar& l, const BoolVar& r);
484  operator !=(const IntVar& l, const LinIntExpr& r);
487  operator !=(const BoolVar& l, const LinIntExpr& r);
490  operator !=(const LinIntExpr& l, const IntVar& r);
493  operator !=(const LinIntExpr& l, const BoolVar& r);
496  operator !=(const LinIntExpr& l, const LinIntExpr& r);
497 
500  operator <(int l, const IntVar& r);
503  operator <(int l, const BoolVar& r);
506  operator <(int l, const LinIntExpr& r);
509  operator <(const IntVar& l, int r);
512  operator <(const BoolVar& l, int r);
515  operator <(const LinIntExpr& l, int r);
518  operator <(const IntVar& l, const IntVar& r);
521  operator <(const IntVar& l, const BoolVar& r);
524  operator <(const BoolVar& l, const IntVar& r);
527  operator <(const BoolVar& l, const BoolVar& r);
530  operator <(const IntVar& l, const LinIntExpr& r);
533  operator <(const BoolVar& l, const LinIntExpr& r);
536  operator <(const LinIntExpr& l, const IntVar& r);
539  operator <(const LinIntExpr& l, const BoolVar& r);
542  operator <(const LinIntExpr& l, const LinIntExpr& r);
543 
546  operator <=(int l, const IntVar& r);
549  operator <=(int l, const BoolVar& r);
552  operator <=(int l, const LinIntExpr& r);
555  operator <=(const IntVar& l, int r);
558  operator <=(const BoolVar& l, int r);
561  operator <=(const LinIntExpr& l, int r);
564  operator <=(const IntVar& l, const IntVar& r);
567  operator <=(const IntVar& l, const BoolVar& r);
570  operator <=(const BoolVar& l, const IntVar& r);
573  operator <=(const BoolVar& l, const BoolVar& r);
576  operator <=(const IntVar& l, const LinIntExpr& r);
579  operator <=(const BoolVar& l, const LinIntExpr& r);
582  operator <=(const LinIntExpr& l, const IntVar& r);
585  operator <=(const LinIntExpr& l, const BoolVar& r);
588  operator <=(const LinIntExpr& l, const LinIntExpr& r);
589 
592  operator >(int l, const IntVar& r);
595  operator >(int l, const BoolVar& r);
598  operator >(int l, const LinIntExpr& r);
601  operator >(const IntVar& l, int r);
604  operator >(const BoolVar& l, int r);
607  operator >(const LinIntExpr& l, int r);
610  operator >(const IntVar& l, const IntVar& r);
613  operator >(const IntVar& l, const BoolVar& r);
616  operator >(const BoolVar& l, const IntVar& r);
619  operator >(const BoolVar& l, const BoolVar& r);
622  operator >(const IntVar& l, const LinIntExpr& r);
625  operator >(const BoolVar& l, const LinIntExpr& r);
628  operator >(const LinIntExpr& l, const IntVar& r);
631  operator >(const LinIntExpr& l, const BoolVar& r);
634  operator >(const LinIntExpr& l, const LinIntExpr& r);
635 
638  operator >=(int l, const IntVar& r);
641  operator >=(int l, const BoolVar& r);
644  operator >=(int l, const LinIntExpr& r);
647  operator >=(const IntVar& l, int r);
650  operator >=(const BoolVar& l, int r);
653  operator >=(const LinIntExpr& l, int r);
656  operator >=(const IntVar& l, const IntVar& r);
659  operator >=(const IntVar& l, const BoolVar& r);
662  operator >=(const BoolVar& l, const IntVar& r);
665  operator >=(const BoolVar& l, const BoolVar& r);
668  operator >=(const IntVar& l, const LinIntExpr& r);
671  operator >=(const BoolVar& l, const LinIntExpr& r);
674  operator >=(const LinIntExpr& l, const IntVar& r);
677  operator >=(const LinIntExpr& l, const BoolVar& r);
680  operator >=(const LinIntExpr& l, const LinIntExpr& r);
682 
683 #ifdef GECODE_HAS_FLOAT_VARS
684  class NonLinFloatExpr {
686  public:
688  virtual FloatVar post(Home home, FloatVar* ret) const = 0;
690  virtual void post(Home home, FloatRelType frt, FloatVal c) const = 0;
692  virtual void post(Home home, FloatRelType frt, FloatVal c,
693  BoolVar b) const = 0;
695  virtual ~NonLinFloatExpr(void) {}
697  static FloatVar result(Home home, FloatVar* x) {
698  if (x == NULL)
700  return *x;
701  }
703  static FloatVar result(Home home, FloatVar* x, FloatVar y) {
704  if (x!=NULL)
705  rel(home,*x,FRT_EQ,y);
706  return y;
707  }
709  void* operator new(size_t size) { return heap.ralloc(size); }
711  void operator delete(void* p, size_t) { heap.rfree(p); }
712  };
713 
715  class LinFloatExpr {
716  friend class LinFloatRel;
717  public:
719  enum NodeType {
727  };
728  private:
730  class Node;
731  Node* n;
732  public:
735  LinFloatExpr(void);
738  LinFloatExpr(const FloatVal& c);
741  LinFloatExpr(const FloatVar& x);
744  LinFloatExpr(const FloatVar& x, FloatVal a);
747  explicit LinFloatExpr(const FloatVarArgs& x);
750  LinFloatExpr(const FloatValArgs& a, const FloatVarArgs& x);
753  LinFloatExpr(const LinFloatExpr& e);
756  LinFloatExpr(const LinFloatExpr& e0, NodeType t, const LinFloatExpr& e1);
759  LinFloatExpr(const LinFloatExpr& e0, NodeType t, const FloatVal& c);
762  LinFloatExpr(FloatVal a, const LinFloatExpr& e);
765  explicit LinFloatExpr(NonLinFloatExpr* e);
768  const LinFloatExpr& operator =(const LinFloatExpr& e);
771  void post(Home home, FloatRelType frt) const;
774  void post(Home home, FloatRelType frt, const BoolVar& b) const;
777  FloatVar post(Home home) const;
780  NonLinFloatExpr* nlfe(void) const;
783  ~LinFloatExpr(void);
784  };
785 
786  class BoolExpr;
787 
789  class LinFloatRel {
790  friend class BoolExpr;
791  private:
793  LinFloatExpr e;
795  FloatRelType frt;
797  static FloatRelType neg(FloatRelType frt);
799  LinFloatRel(void);
800  public:
802  LinFloatRel(const LinFloatExpr& l, FloatRelType frt, const LinFloatExpr& r);
808  void post(Home home, bool t) const;
810  void post(Home home, const BoolVar& b, bool t) const;
811  };
812 
828  operator +(const FloatVal&, const FloatVar&);
831  operator +(const FloatVal&, const LinFloatExpr&);
834  operator +(const FloatVar&, const FloatVal&);
837  operator +(const LinFloatExpr&, const FloatVal&);
840  operator +(const FloatVar&, const FloatVar&);
843  operator +(const FloatVar&, const LinFloatExpr&);
846  operator +(const LinFloatExpr&, const FloatVar&);
849  operator +(const LinFloatExpr&, const LinFloatExpr&);
850 
853  operator -(const FloatVal&, const FloatVar&);
856  operator -(const FloatVal&, const LinFloatExpr&);
859  operator -(const FloatVar&, const FloatVal&);
862  operator -(const LinFloatExpr&, const FloatVal&);
865  operator -(const FloatVar&, const FloatVar&);
868  operator -(const FloatVar&, const LinFloatExpr&);
871  operator -(const LinFloatExpr&, const FloatVar&);
874  operator -(const LinFloatExpr&, const LinFloatExpr&);
875 
878  operator -(const FloatVar&);
881  operator -(const LinFloatExpr&);
882 
885  operator *(const FloatVal&, const FloatVar&);
888  operator *(const FloatVar&, const FloatVal&);
891  operator *(const LinFloatExpr&, const FloatVal&);
894  operator *(const FloatVal&, const LinFloatExpr&);
895 
898  sum(const FloatVarArgs& x);
901  sum(const FloatValArgs& a, const FloatVarArgs& x);
902 
905  operator ==(const FloatVal& l, const FloatVar& r);
908  operator ==(const FloatVal& l, const LinFloatExpr& r);
911  operator ==(const FloatVar& l, const FloatVal& r);
914  operator ==(const LinFloatExpr& l, const FloatVal& r);
917  operator ==(const FloatVar& l, const FloatVar& r);
920  operator ==(const FloatVar& l, const BoolVar& r);
923  operator ==(const FloatVar& l, const LinFloatExpr& r);
926  operator ==(const LinFloatExpr& l, const FloatVar& r);
929  operator ==(const LinFloatExpr& l, const BoolVar& r);
932  operator ==(const LinFloatExpr& l, const LinFloatExpr& r);
933 
936  operator !=(const FloatVal& l, const FloatVar& r);
939  operator !=(const FloatVal& l, const LinFloatExpr& r);
942  operator !=(const FloatVar& l, const FloatVal& r);
945  operator !=(const LinFloatExpr& l, const FloatVal& r);
948  operator !=(const FloatVar& l, const FloatVar& r);
951  operator !=(const FloatVar& l, const BoolVar& r);
954  operator !=(const FloatVar& l, const LinFloatExpr& r);
957  operator !=(const LinFloatExpr& l, const FloatVar& r);
960  operator !=(const LinFloatExpr& l, const BoolVar& r);
963  operator !=(const LinFloatExpr& l, const LinFloatExpr& r);
964 
967  operator <(const FloatVal& l, const FloatVar& r);
970  operator <(const FloatVal& l, const LinFloatExpr& r);
973  operator <(const FloatVar& l, const FloatVal& r);
976  operator <(const LinFloatExpr& l, const FloatVal& r);
979  operator <(const FloatVar& l, const FloatVar& r);
982  operator <(const FloatVar& l, const LinFloatExpr& r);
985  operator <(const LinFloatExpr& l, const FloatVar& r);
988  operator <(const LinFloatExpr& l, const LinFloatExpr& r);
989 
992  operator <=(const FloatVal& l, const FloatVar& r);
995  operator <=(const FloatVal& l, const LinFloatExpr& r);
998  operator <=(const FloatVar& l, const FloatVal& r);
1001  operator <=(const LinFloatExpr& l, const FloatVal& r);
1004  operator <=(const FloatVar& l, const FloatVar& r);
1007  operator <=(const FloatVar& l, const LinFloatExpr& r);
1010  operator <=(const LinFloatExpr& l, const FloatVar& r);
1013  operator <=(const LinFloatExpr& l, const LinFloatExpr& r);
1014 
1017  operator >(const FloatVal& l, const FloatVar& r);
1020  operator >(const FloatVal& l, const LinFloatExpr& r);
1023  operator >(const FloatVar& l, const FloatVal& r);
1026  operator >(const LinFloatExpr& l, const FloatVal& r);
1029  operator >(const FloatVar& l, const FloatVar& r);
1032  operator >(const FloatVar& l, const LinFloatExpr& r);
1035  operator >(const LinFloatExpr& l, const FloatVar& r);
1038  operator >(const LinFloatExpr& l, const LinFloatExpr& r);
1039 
1042  operator >=(const FloatVal& l, const FloatVar& r);
1045  operator >=(const FloatVal& l, const LinFloatExpr& r);
1048  operator >=(const FloatVar& l, const FloatVal& r);
1051  operator >=(const LinFloatExpr& l, const FloatVal& r);
1054  operator >=(const FloatVar& l, const FloatVar& r);
1057  operator >=(const FloatVar& l, const LinFloatExpr& r);
1060  operator >=(const LinFloatExpr& l, const FloatVar& r);
1063  operator >=(const LinFloatExpr& l, const LinFloatExpr& r);
1065 #endif
1066 
1067 #ifdef GECODE_HAS_SET_VARS
1068  class SetExpr {
1070  public:
1072  enum NodeType {
1080  };
1082  class Node;
1083  private:
1085  Node* n;
1086  public:
1088  SetExpr(void);
1091  SetExpr(const SetExpr& e);
1094  SetExpr(const SetExpr& l, NodeType t, const SetExpr& r);
1097  SetExpr(const SetVar& x);
1100  explicit SetExpr(const LinIntExpr& x);
1103  SetExpr(const IntSet& s);
1106  SetExpr(const SetExpr& e, NodeType t);
1109  SetVar post(Home home) const;
1112  void post(Home home, SetRelType srt, const SetExpr& e) const;
1115  void post(Home home, BoolVar b, bool t,
1116  SetRelType srt, const SetExpr& e) const;
1119  const SetExpr& operator =(const SetExpr& e);
1122  ~SetExpr(void);
1123  };
1124 
1126  class SetCmpRel {
1127  public:
1135  SetCmpRel(const SetExpr& l, SetRelType srt, const SetExpr& r);
1136  };
1137 
1139  class SetRel {
1140  private:
1142  SetExpr _e0;
1144  SetRelType _srt;
1146  SetExpr _e1;
1147  public:
1149  SetRel(void);
1151  SetRel(const SetExpr& e0, SetRelType srt, const SetExpr& e1);
1153  SetRel(const SetCmpRel& r);
1155  void post(Home home, bool t) const;
1157  void post(Home home, BoolVar b, bool t) const;
1158  };
1159 
1172  singleton(const LinIntExpr&);
1175  operator -(const SetExpr&);
1178  operator &(const SetExpr&, const SetExpr&);
1181  operator |(const SetExpr&, const SetExpr&);
1184  operator +(const SetExpr&, const SetExpr&);
1187  operator -(const SetExpr&, const SetExpr&);
1188 
1191  inter(const SetVarArgs&);
1194  setunion(const SetVarArgs&);
1197  setdunion(const SetVarArgs&);
1198 
1201  cardinality(const SetExpr&);
1204  min(const SetExpr&);
1207  max(const SetExpr&);
1208 
1211  operator ==(const SetExpr&, const SetExpr&);
1214  operator !=(const SetExpr&, const SetExpr&);
1217  operator <=(const SetExpr&, const SetExpr&);
1220  operator <=(const SetCmpRel&, const SetExpr&);
1223  operator >=(const SetExpr&, const SetExpr&);
1226  operator >=(const SetCmpRel&, const SetExpr&);
1229  operator ||(const SetExpr&, const SetExpr&);
1231 #endif
1232 
1234  class BoolExpr {
1235  public:
1237  enum NodeType {
1247  };
1249  class MiscExpr {
1250  public:
1254  virtual void post(Space& home, BoolVar b, bool neg,
1255  IntConLevel icl) = 0;
1257  virtual GECODE_MINIMODEL_EXPORT ~MiscExpr(void);
1259  static void* operator new(size_t size);
1261  static void operator delete(void* p, size_t size);
1262  };
1264  class Node;
1265  private:
1267  Node* n;
1268  public:
1271  BoolExpr(void);
1274  BoolExpr(const BoolExpr& e);
1277  BoolExpr(const BoolExpr& l, NodeType t, const BoolExpr& r);
1280  BoolExpr(const BoolVar& x);
1283  BoolExpr(const BoolExpr& e, NodeType t);
1286  BoolExpr(const LinIntRel& rl);
1287 #ifdef GECODE_HAS_FLOAT_VARS
1290  BoolExpr(const LinFloatRel& rfl);
1291 #endif
1292 #ifdef GECODE_HAS_SET_VARS
1295  BoolExpr(const SetRel& rs);
1298  BoolExpr(const SetCmpRel& rs);
1299 #endif
1302  explicit BoolExpr(MiscExpr* m);
1305  BoolVar expr(Home home, IntConLevel icl) const;
1308  void rel(Home home, IntConLevel icl) const;
1311  const BoolExpr& operator =(const BoolExpr& e);
1314  ~BoolExpr(void);
1315  };
1316 
1329  operator !(const BoolExpr&);
1332  operator &&(const BoolExpr&, const BoolExpr&);
1335  operator ||(const BoolExpr&, const BoolExpr&);
1338  operator ^(const BoolExpr&, const BoolExpr&);
1339 
1342  operator !=(const BoolExpr&, const BoolExpr&);
1345  operator ==(const BoolExpr&, const BoolExpr&);
1348  operator >>(const BoolExpr&, const BoolExpr&);
1351  operator <<(const BoolExpr&, const BoolExpr&);
1352 
1354 
1363  expr(Home home, const LinIntExpr& e, IntConLevel icl=ICL_DEF);
1364 #ifdef GECODE_HAS_FLOAT_VARS
1367  expr(Home home, const LinFloatExpr& e);
1368 #endif
1369 #ifdef GECODE_HAS_SET_VARS
1372  expr(Home home, const SetExpr& e);
1373 #endif
1376  expr(Home home, const BoolExpr& e, IntConLevel icl=ICL_DEF);
1379  rel(Home home, const BoolExpr& e, IntConLevel icl=ICL_DEF);
1381 
1382 }
1383 
1389 
1390 namespace Gecode {
1391 
1392  namespace MiniModel {
1393  class ExpInfo;
1394  }
1395 
1402  friend class MiniModel::ExpInfo;
1403  private:
1405  class Exp;
1407  Exp* e;
1409  REG(Exp* e);
1410  public:
1412  REG(void);
1414  REG(int s);
1421  REG(const IntArgs& x);
1422 
1424  REG(const REG& r);
1426  const REG& operator =(const REG& r);
1427 
1429  REG operator +(const REG& r);
1431  REG& operator +=(const REG& r);
1433  REG operator |(const REG& r);
1435  REG& operator |=(const REG& r);
1437  REG operator *(void);
1439  REG operator +(void);
1441  REG operator ()(unsigned int n, unsigned int m);
1443  REG operator ()(unsigned int n);
1445  template<class Char, class Traits>
1446  std::basic_ostream<Char,Traits>&
1447  print(std::basic_ostream<Char,Traits>& os) const;
1449  operator DFA(void);
1451  ~REG(void);
1452  };
1453 
1457  template<class Char, class Traits>
1458  std::basic_ostream<Char,Traits>&
1459  operator <<(std::basic_ostream<Char,Traits>& os, const REG& r);
1460 
1461 
1470  abs(const LinIntExpr& e);
1473  min(const LinIntExpr& x, const LinIntExpr& y);
1476  min(const IntVarArgs& x);
1479  max(const LinIntExpr& x, const LinIntExpr& y);
1482  max(const IntVarArgs& x);
1483 #ifdef GECODE_HAS_FLOAT_VARS
1486  operator *(const FloatVar&, const FloatVar&);
1489  operator *(const FloatVar&, const LinFloatExpr&);
1492  operator *(const LinFloatExpr&, const FloatVar&);
1493 #endif
1496  operator *(const LinIntExpr& x, const LinIntExpr& y);
1499  operator /(const LinIntExpr& x, const LinIntExpr& y);
1502  operator %(const LinIntExpr& x, const LinIntExpr& y);
1505  sqr(const LinIntExpr& x);
1508  sqrt(const LinIntExpr& x);
1511  pow(const LinIntExpr& x, int n);
1514  nroot(const LinIntExpr& x, int n);
1517  element(const IntVarArgs& x, const LinIntExpr& y);
1520  element(const BoolVarArgs& x, const LinIntExpr& y);
1523  element(const IntArgs& x, const LinIntExpr& y);
1526  ite(const BoolExpr& b, const LinIntExpr& x, const LinIntExpr& y);
1528 
1529 #ifdef GECODE_HAS_FLOAT_VARS
1532  abs(const LinFloatExpr& e);
1535  min(const LinFloatExpr& x, const LinFloatExpr& y);
1538  min(const FloatVarArgs& x);
1541  max(const LinFloatExpr& x, const LinFloatExpr& y);
1544  max(const FloatVarArgs& x);
1547  operator *(const LinFloatExpr& x, const LinFloatExpr& y);
1550  operator /(const LinFloatExpr& x, const LinFloatExpr& y);
1553  sqr(const LinFloatExpr& x);
1556  sqrt(const LinFloatExpr& x);
1559  pow(const LinFloatExpr& x, int n);
1562  nroot(const LinFloatExpr& x, int n);
1564 
1565 #ifdef GECODE_HAS_MPFR
1566 
1574  exp(const LinFloatExpr& x);
1577  log(const LinFloatExpr& x);
1579 
1588  asin(const LinFloatExpr& x);
1591  sin(const LinFloatExpr& x);
1594  acos(const LinFloatExpr& x);
1597  cos(const LinFloatExpr& x);
1600  atan(const LinFloatExpr& x);
1603  tan(const LinFloatExpr& x);
1605 #endif
1606 #endif
1607 
1614  inline BoolVar
1617  IntConLevel icl=ICL_DEF) {
1618  (void) icl;
1619  BoolVar b(home,0,1); channel(home,b,x);
1620  return b;
1621  }
1623  inline IntVar
1625  IntConLevel icl=ICL_DEF) {
1626  (void) icl;
1627  IntVar x(home,0,1); channel(home,b,x);
1628  return x;
1629  }
1630 #ifdef GECODE_HAS_FLOAT_VARS
1631  inline IntVar
1633  channel(Home home, FloatVar f) {
1634  int min = static_cast<int>(std::max(static_cast<double>(Int::Limits::min),
1635  std::ceil(f.min())));
1636  int max = static_cast<int>(std::min(static_cast<double>(Int::Limits::max),
1637  std::floor(f.max())));
1638  IntVar x(home,min,max);
1639  channel(home,f,x);
1640  return x;
1641  }
1642 #endif
1643 #ifdef GECODE_HAS_SET_VARS
1644  inline SetVar
1647  (void) icl;
1649  rel(home,SOT_UNION,x,s);
1650  nvalues(home,x,IRT_EQ,expr(home,cardinality(s)));
1651  return s;
1652  }
1653 #endif
1654 
1655 
1656 }
1657 
1658 namespace Gecode {
1659 
1674  inline void
1675  atmost(Home home, const IntVarArgs& x, int n, int m,
1676  IntConLevel icl=ICL_DEF) {
1677  count(home,x,n,IRT_LQ,m,icl);
1678  }
1683  inline void
1684  atmost(Home home, const IntVarArgs& x, IntVar y, int m,
1685  IntConLevel icl=ICL_DEF) {
1686  count(home,x,y,IRT_LQ,m,icl);
1687  }
1695  inline void
1696  atmost(Home home, const IntVarArgs& x, const IntArgs& y, int m,
1697  IntConLevel icl=ICL_DEF) {
1698  count(home,x,y,IRT_LQ,m,icl);
1699  }
1704  inline void
1705  atmost(Home home, const IntVarArgs& x, int n, IntVar z,
1706  IntConLevel icl=ICL_DEF) {
1707  count(home,x,n,IRT_LQ,z,icl);
1708  }
1713  inline void
1714  atmost(Home home, const IntVarArgs& x, IntVar y, IntVar z,
1715  IntConLevel icl=ICL_DEF) {
1716  count(home,x,y,IRT_LQ,z,icl);
1717  }
1725  inline void
1726  atmost(Home home, const IntVarArgs& x, const IntArgs& y, IntVar z,
1727  IntConLevel icl=ICL_DEF) {
1728  count(home,x,y,IRT_LQ,z,icl);
1729  }
1730 
1735  inline void
1736  atleast(Home home, const IntVarArgs& x, int n, int m,
1737  IntConLevel icl=ICL_DEF) {
1738  count(home,x,n,IRT_GQ,m,icl);
1739  }
1744  inline void
1745  atleast(Home home, const IntVarArgs& x, IntVar y, int m,
1746  IntConLevel icl=ICL_DEF) {
1747  count(home,x,y,IRT_GQ,m,icl);
1748  }
1756  inline void
1757  atleast(Home home, const IntVarArgs& x, const IntArgs& y, int m,
1758  IntConLevel icl=ICL_DEF) {
1759  count(home,x,y,IRT_GQ,m,icl);
1760  }
1765  inline void
1766  atleast(Home home, const IntVarArgs& x, int n, IntVar z,
1767  IntConLevel icl=ICL_DEF) {
1768  count(home,x,n,IRT_GQ,z,icl);
1769  }
1774  inline void
1775  atleast(Home home, const IntVarArgs& x, IntVar y, IntVar z,
1776  IntConLevel icl=ICL_DEF) {
1777  count(home,x,y,IRT_GQ,z,icl);
1778  }
1786  inline void
1787  atleast(Home home, const IntVarArgs& x, const IntArgs& y, IntVar z,
1788  IntConLevel icl=ICL_DEF) {
1789  count(home,x,y,IRT_GQ,z,icl);
1790  }
1791 
1796  inline void
1797  exactly(Home home, const IntVarArgs& x, int n, int m,
1798  IntConLevel icl=ICL_DEF) {
1799  count(home,x,n,IRT_EQ,m,icl);
1800  }
1805  inline void
1806  exactly(Home home, const IntVarArgs& x, IntVar y, int m,
1807  IntConLevel icl=ICL_DEF) {
1808  count(home,x,y,IRT_EQ,m,icl);
1809  }
1817  inline void
1818  exactly(Home home, const IntVarArgs& x, const IntArgs& y, int m,
1819  IntConLevel icl=ICL_DEF) {
1820  count(home,x,y,IRT_EQ,m,icl);
1821  }
1826  inline void
1827  exactly(Home home, const IntVarArgs& x, int n, IntVar z,
1828  IntConLevel icl=ICL_DEF) {
1829  count(home,x,n,IRT_EQ,z,icl);
1830  }
1835  inline void
1836  exactly(Home home, const IntVarArgs& x, IntVar y, IntVar z,
1837  IntConLevel icl=ICL_DEF) {
1838  count(home,x,y,IRT_EQ,z,icl);
1839  }
1847  inline void
1848  exactly(Home home, const IntVarArgs& x, const IntArgs& y, IntVar z,
1849  IntConLevel icl=ICL_DEF) {
1850  count(home,x,y,IRT_EQ,z,icl);
1851  }
1854  inline void
1855  lex(Home home, const IntVarArgs& x, IntRelType r, const IntVarArgs& y,
1856  IntConLevel icl=ICL_DEF) {
1857  rel(home,x,r,y,icl);
1858  }
1861  inline void
1862  lex(Home home, const BoolVarArgs& x, IntRelType r, const BoolVarArgs& y,
1863  IntConLevel icl=ICL_DEF) {
1864  rel(home,x,r,y,icl);
1865  }
1868  inline void
1869  values(Home home, const IntVarArgs& x, IntSet y,
1870  IntConLevel icl=ICL_DEF) {
1871  dom(home,x,y,icl);
1872  nvalues(home,x,IRT_EQ,y.size(),icl);
1873  }
1874 
1876 
1877 #ifdef GECODE_HAS_SET_VARS
1878 
1893  inline void
1894  channel(Home home, const IntVarArgs& x, SetVar y) {
1895  rel(home,SOT_UNION,x,y);
1896  nvalues(home,x,IRT_EQ,expr(home,cardinality(y)));
1897  }
1898 
1901  inline void
1902  range(Home home, const IntVarArgs& x, SetVar y, SetVar z) {
1903  element(home,SOT_UNION,x,y,z);
1904  }
1905 
1911  inline void
1912  roots(Home home, const IntVarArgs& x, SetVar y, SetVar z) {
1913  SetVarArgs xiv(home,z.lubMax()+1,IntSet::empty,0,x.size()-1);
1914  channel(home,x,xiv);
1915  element(home,SOT_UNION,xiv,z,y);
1916  }
1917 
1919 #endif
1920 }
1921 
1922 namespace Gecode {
1923 
1924  template<class> class Matrix;
1925 
1933  template<class A>
1934  class Slice {
1935  public:
1938  private:
1939  ArgsType _r;
1940  unsigned int _fc,
1941  _tc,
1942  _fr,
1943  _tr;
1944  public:
1946  Slice(const Matrix<A>& a, int fc, int tc, int fr, int tr);
1950  Slice& reverse(void);
1952  operator ArgsType(void);
1954  operator Matrix<ArgsType>(void);
1955 
1957  operator const ArgsType(void) const;
1959  operator const Matrix<ArgsType>(void) const;
1960  };
1961 
1963  template<class A>
1964  typename Slice<A>::ArgsType
1965  operator+(const Slice<A>& x, const Slice<A>& y);
1966 
1968  template<class A>
1969  typename Slice<A>::ArgsType
1970  operator+(const Slice<A>& x, const typename ArrayTraits<A>::ArgsType& y);
1971 
1973  template<class A>
1974  typename Slice<A>::ArgsType
1975  operator+(const typename ArrayTraits<A>::ArgsType& x, const Slice<A>& y);
1976 
1978  template<class A>
1979  typename Slice<A>::ArgsType
1980  operator+(const Slice<A>& x, const typename ArrayTraits<A>::ValueType& y);
1981 
1983  template<class A>
1984  typename Slice<A>::ArgsType
1985  operator+(const typename ArrayTraits<A>::ValueType& x, const Slice<A>& y);
1986 
1997  template<class A>
1998  class Matrix {
1999  public:
2004 
2005  private:
2007  typedef typename ArrayTraits<A>::StorageType StorageType;
2008  StorageType _a;
2009  int _w;
2010  int _h;
2011 
2012  public:
2025  Matrix(A a, int w, int h);
2026 
2039  Matrix(A a, int n);
2040 
2042  int width(void) const;
2044  int height(void) const;
2046  ArgsType const get_array(void) const;
2047 
2053  ValueType& operator ()(int c, int r);
2054 
2060  const ValueType& operator ()(int c, int r) const;
2061 
2071  Slice<A> slice(int fc, int tc, int fr, int tr) const;
2072 
2074  Slice<A> row(int r) const;
2075 
2077  Slice<A> col(int c) const;
2078  };
2079 
2083  template<class Char, class Traits, class A>
2084  std::basic_ostream<Char,Traits>&
2085  operator <<(std::basic_ostream<Char,Traits>& os, const Matrix<A>& m);
2086 
2090  template<class Char, class Traits, class A>
2091  std::basic_ostream<Char,Traits>&
2092  operator <<(std::basic_ostream<Char,Traits>& os, const Slice<A>& s);
2093 
2100  void element(Home home, const Matrix<IntArgs>& m, IntVar x, IntVar y,
2101  IntVar z, IntConLevel icl=ICL_DEF);
2108  void element(Home home, const Matrix<IntArgs>& m, IntVar x, IntVar y,
2109  BoolVar z, IntConLevel icl=ICL_DEF);
2116  void element(Home home, const Matrix<IntVarArgs>& m, IntVar x, IntVar y,
2117  IntVar z, IntConLevel icl=ICL_DEF);
2124  void element(Home home, const Matrix<BoolVarArgs>& m, IntVar x, IntVar y,
2125  BoolVar z, IntConLevel icl=ICL_DEF);
2126 #ifdef GECODE_HAS_SET_VARS
2127 
2133  void element(Home home, const Matrix<IntSetArgs>& m, IntVar x, IntVar y,
2134  SetVar z);
2141  void element(Home home, const Matrix<SetVarArgs>& m, IntVar x, IntVar y,
2142  SetVar z);
2143 #endif
2144 
2148  template<class A>
2153  template<class A>
2158  template<class A>
2163  template<class A>
2170  template<class A>
2172 }
2173 
2174 #include <gecode/minimodel/matrix.hpp>
2175 #include <gecode/minimodel/ldsb.hpp>
2176 
2181 namespace Gecode {
2183  GECODE_MINIMODEL_EXPORT LinIntExpr
2184  sum(const Slice<IntArgs>& slice);
2186  GECODE_MINIMODEL_EXPORT LinIntExpr
2187  sum(const Matrix<IntArgs>& matrix);
2188 }
2191 namespace Gecode {
2192 
2202  namespace MiniModel {
2203 
2205  template<IntRelType irt>
2206  class IntOptimizeSpace : public Space {
2207  public:
2209  IntOptimizeSpace(void);
2211  IntOptimizeSpace(bool share, IntOptimizeSpace& s);
2213  virtual void constrain(const Space& best);
2215  virtual IntVar cost(void) const = 0;
2216  };
2217 
2218 #ifdef GECODE_HAS_FLOAT_VARS
2219 
2221  template<FloatRelType frt>
2222  class FloatOptimizeSpace : public Space {
2223  public:
2225  FloatOptimizeSpace(void);
2227  FloatOptimizeSpace(bool share, FloatOptimizeSpace& s);
2229  virtual void constrain(const Space& best);
2231  virtual FloatVar cost(void) const = 0;
2232  };
2233 
2234 #endif
2235 
2236  }
2237 
2246 
2247 #ifdef GECODE_HAS_FLOAT_VARS
2248 
2253 
2254 #endif
2255 
2257 
2258 }
2259 
2261 
2262 #endif
2263 
2264 // IFDEF: GECODE_HAS_INT_VARS
2265 // STATISTICS: minimodel-any
2266 
FloatVal operator-(const FloatVal &x)
Definition: val.hpp:172
SetExpr singleton(const LinIntExpr &e)
Singleton expression.
Definition: set-expr.cpp:691
Passing float arguments.
Definition: float.hh:937
virtual void post(Space &home, BoolVar b, bool neg, IntConLevel icl)=0
const BoolExpr & operator=(const BoolExpr &e)
Assignment operator.
Definition: bool-expr.cpp:210
MiniModel::IntOptimizeSpace< IRT_GR > IntMaximizeSpace
Class for maximizing integer cost.
Definition: minimodel.hh:2245
void post(Home home, FloatRelType frt) const
Post propagator.
Definition: float-expr.cpp:156
SetRelType srt
Which relation.
Definition: minimodel.hh:1133
NodeType t
Type of node.
Definition: bool-expr.cpp:234
SetRelType
Common relation types for sets.
Definition: set.hh:644
Miscealloneous Boolean expressions.
Definition: minimodel.hh:1249
IntConLevel
Consistency levels for integer propagators.
Definition: int.hh:937
const SetExpr & operator=(const SetExpr &e)
Assignment operator.
Definition: set-expr.cpp:629
NNF * l
Left subtree.
Definition: bool-expr.cpp:244
virtual ~NonLinFloatExpr(void)
Destructor.
Definition: minimodel.hh:695
MiniModel::FloatOptimizeSpace< FRT_LE > FloatMinimizeSpace
Class for minimizing float cost.
Definition: minimodel.hh:2250
SetExpr operator&(const SetExpr &l, const SetExpr &r)
Intersection of set expressions.
Definition: set-expr.cpp:671
const int min
Smallest allowed integer in integer set.
Definition: set.hh:101
void log(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition: arithmetic.cpp:151
void channel(Home home, FloatVar x0, IntVar x1)
Post propagator for channeling a float and an integer variable .
Definition: arithmetic.cpp:218
const FloatNum max
Largest allowed float value.
Definition: float.hh:831
virtual ~NonLinIntExpr(void)
Destructor.
Definition: minimodel.hh:118
Set relations
Definition: minimodel.hh:1139
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:355
int size(void) const
Return size of array (number of elements)
Definition: array.hpp:1662
Regular expressions over integer values.
Definition: minimodel.hh:1401
Reified linear relation.
Definition: minimodel.hh:1244
Linear term with Boolean variable.
Definition: minimodel.hh:151
void max(Home home, FloatVar x0, FloatVar x1, FloatVar x2)
Post propagator for .
Definition: arithmetic.cpp:57
void abs(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition: arithmetic.cpp:49
Passing float variables.
Definition: float.hh:966
Node for Boolean expression
Definition: bool-expr.cpp:47
Less or equal ( )
Definition: int.hh:906
void nroot(Home home, FloatVar x0, int n, FloatVar x1)
Post propagator for for $n 0$.
Definition: arithmetic.cpp:126
Linear relations over integer variables.
Definition: minimodel.hh:227
void pow(Home home, FloatVar x0, int n, FloatVar x1)
Post propagator for for $n 0$.
Definition: arithmetic.cpp:117
void atmost(Home home, const IntVarArgs &x, int n, int m, IntConLevel icl=ICL_DEF)
Post constraint .
Definition: minimodel.hh:1675
BoolExpr operator&&(const BoolExpr &l, const BoolExpr &r)
Conjunction of Boolean expressions.
Definition: bool-expr.cpp:592
void dom(Home home, FloatVar x, FloatVal n)
Propagates .
Definition: dom.cpp:44
void rel(Home home, IntConLevel icl) const
Post propagators for relation.
Definition: bool-expr.cpp:585
Base class for non-linear expressions over integer variables.
Definition: minimodel.hh:107
void post(Home home, bool t) const
Post propagators for relation (or negated relation if t is false)
Definition: set-rel.hpp:62
int height(void) const
Return the height of the matrix.
Definition: matrix.hpp:150
void * ralloc(size_t s)
Allocate s bytes from heap.
Definition: heap.hpp:341
Addition of linear terms.
Definition: minimodel.hh:155
void roots(Home home, const IntVarArgs &x, SetVar y, SetVar z)
Post constraint .
Definition: minimodel.hh:1912
void post(Home home, bool t, IntConLevel icl) const
Post propagator for relation (if t is false for negated relation)
Definition: int-rel.hpp:74
virtual void constrain(const Space &best)
Member function constraining according to cost.
Definition: optimize.hpp:51
Baseclass for integer-based cost-based optimization.
Definition: minimodel.hh:2206
SymmetryHandle columns_interchange(const Matrix< A > &m)
Interchangeable columns symmetry specification.
Definition: ldsb.hpp:55
Expression information.
Definition: reg.cpp:462
~BoolExpr(void)
Destructor.
Definition: bool-expr.cpp:222
Multiplication by coefficient.
Definition: minimodel.hh:157
virtual ~MiscExpr(void)
Destructor.
Definition: bool-expr.cpp:220
Linear term with variable.
Definition: minimodel.hh:721
Comparison relation (for two-sided comparisons)
Definition: minimodel.hh:1126
const int max
Largest allowed integer in integer set.
Definition: set.hh:99
virtual FloatVar post(Home home, FloatVar *ret) const =0
Return variable constrained to be equal to the expression.
Linear expression.
Definition: minimodel.hh:1075
Linear term with integer variable.
Definition: minimodel.hh:150
const int max
Largest allowed integer value.
Definition: int.hh:113
Computation spaces.
Definition: core.hpp:1362
Greater or equal ( )
Definition: int.hh:908
Set expressions
Definition: minimodel.hh:1069
FloatNum max(void) const
Return maximum of domain.
Definition: float.hpp:71
void atleast(Home home, const IntVarArgs &x, int n, int m, IntConLevel icl=ICL_DEF)
Post constraint .
Definition: minimodel.hh:1736
const int min
Smallest allowed integer value.
Definition: int.hh:115
BoolExpr operator^(const BoolExpr &l, const BoolExpr &r)
Exclusive-or of Boolean expressions.
Definition: bool-expr.cpp:600
ArrayTraits< A >::ValueType ValueType
The type of elements of this array.
Definition: minimodel.hh:2001
Reified linear relation.
Definition: minimodel.hh:1243
int width(void) const
Return the width of the matrix.
Definition: matrix.hpp:147
Heap heap
The single global heap.
Definition: heap.cpp:49
SetRel(void)
Default constructor.
Definition: set-rel.hpp:51
const LinIntExpr & operator=(const LinIntExpr &e)
Assignment operator.
Definition: int-expr.cpp:495
FloatOptimizeSpace(void)
Default constructor.
Definition: optimize.hpp:63
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:120
Gecode::FloatVal c(-8, 8)
static FloatVar result(Home home, FloatVar *x)
Return fresh variable if x is NULL, x otherwise.
Definition: minimodel.hh:697
Deterministic finite automaton (DFA)
Definition: int.hh:1881
int p
Number of positive literals for node type.
Definition: bool-expr.cpp:236
const FloatNum min
Smallest allowed float value.
Definition: float.hh:833
A slice of a matrix.
Definition: minimodel.hh:1934
int n
Number of negative literals for node type.
Definition: bool-expr.cpp:238
Equality ( )
Definition: int.hh:904
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:685
Matrix(A a, int w, int h)
Basic constructor.
Definition: matrix.hpp:131
A reference-counted pointer to a SymmetryObject.
Definition: int.hh:4263
MiniModel::IntOptimizeSpace< IRT_LE > IntMinimizeSpace
Class for minimizing integer cost.
Definition: minimodel.hh:2243
IntRelType
Relation types for integers.
Definition: int.hh:903
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:126
NNF * r
Right subtree.
Definition: bool-expr.cpp:246
int lubMax(void) const
Return maximum element of least upper bound.
Definition: set.hpp:91
void sqr(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition: arithmetic.cpp:103
FloatRelType
Relation types for floats.
Definition: float.hh:1054
Linear relations.
Definition: minimodel.hh:789
bool operator!=(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:321
SetExpr(void)
Default constructor.
Definition: set-expr.hpp:48
void lex(Home home, const IntVarArgs &x, IntRelType r, const IntVarArgs &y, IntConLevel icl=ICL_DEF)
Post lexical order between x and y.
Definition: minimodel.hh:1855
SetExpr r
Right side of relation.
Definition: minimodel.hh:1131
void sqrt(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition: arithmetic.cpp:110
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:703
void range(Home home, const IntVarArgs &x, SetVar y, SetVar z)
Post constraint .
Definition: minimodel.hh:1902
Slice< A > row(int r) const
Access row r.
Definition: matrix.hpp:181
LinIntExpr(void)
Default constructor.
Definition: int-expr.cpp:353
virtual void constrain(const Space &best)
Member function constraining according to cost.
Definition: optimize.hpp:73
Reified set relation.
Definition: minimodel.hh:1245
ArrayTraits< A >::ArgsType ArgsType
The type of the Args-array type for ValueType values.
Definition: minimodel.hh:2003
Subtraction of linear terms.
Definition: minimodel.hh:725
Float expressions
Definition: minimodel.hh:715
NodeType
Type of set expression.
Definition: minimodel.hh:1072
Integer sets.
Definition: int.hh:171
NodeType
Type of linear expression.
Definition: minimodel.hh:148
LinFloatExpr(void)
Default constructor.
Definition: float-expr.cpp:228
void element(Home home, IntSharedArray c, IntVar x0, IntVar x1, IntConLevel)
Post domain consistent propagator for .
Definition: element.cpp:43
~LinFloatExpr(void)
Destructor.
Definition: float-expr.cpp:339
SetExpr setunion(const SetVarArgs &x)
Union of set variables.
Definition: set-expr.cpp:705
Boolean expressions.
Definition: minimodel.hh:1234
BoolVar expr(Home home, IntConLevel icl) const
Post propagators for expression.
Definition: bool-expr.cpp:579
void asin(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition: arithmetic.cpp:175
SetExpr l
Left side of relation.
Definition: minimodel.hh:1129
Baseclass for float-based cost-based optimization.
Definition: minimodel.hh:2222
unsigned int size(void) const
Return size (cardinality) of set.
Definition: int-set-1.hpp:161
Passing integer variables.
Definition: int.hh:636
void ite(Home home, BoolVar b, IntVar x, IntVar y, IntVar z, IntConLevel icl)
Post propagator for if-then-else constraint.
Definition: bool.cpp:911
Passing integer arguments.
Definition: int.hh:607
NodeType
Type of linear expression.
Definition: minimodel.hh:719
Passing Boolean variables.
Definition: int.hh:690
void exactly(Home home, const IntVarArgs &x, int n, int m, IntConLevel icl=ICL_DEF)
Post constraint .
Definition: minimodel.hh:1797
Equality ( )
Definition: float.hh:1055
Non-linear expression.
Definition: minimodel.hh:152
static const IntSet empty
Empty set.
Definition: int.hh:262
Multiplication by coefficient.
Definition: minimodel.hh:726
SymmetryHandle columns_reflect(const Matrix< A > &m)
Reflect columns symmetry specification.
Definition: ldsb.hpp:89
Other Boolean expression.
Definition: minimodel.hh:1246
Boolean integer variables.
Definition: int.hh:491
ArgsType const get_array(void) const
Return an Args-array of the contents of the matrix.
Definition: matrix.hpp:153
LinIntExpr cardinality(const SetExpr &e)
Cardinality of set expression.
Definition: set-expr.cpp:815
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:75
Archive & operator>>(Archive &e, FloatNumBranch &nl)
Definition: val-sel.hpp:48
ArrayTraits< A >::ArgsType ArgsType
The type of the Args-array type for ValueType values.
Definition: minimodel.hh:1937
void cos(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition: arithmetic.cpp:196
Union.
Definition: set.hh:662
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
void values(Home home, const IntVarArgs &x, IntSet y, IntConLevel icl=ICL_DEF)
Post constraint .
Definition: minimodel.hh:1869
Passing set variables.
Definition: set.hh:490
const LinFloatExpr & operator=(const LinFloatExpr &e)
Assignment operator.
Definition: float-expr.cpp:330
Sum of float variables.
Definition: minimodel.hh:723
Non-linear expression.
Definition: minimodel.hh:722
BoolVar expr(Home home, const BoolExpr &e, IntConLevel icl)
Post Boolean expression and return its value.
Definition: bool-expr.cpp:632
NodeType
Type of Boolean expression.
Definition: minimodel.hh:1237
Float value type.
Definition: float.hh:321
FloatVal operator*(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:204
~LinIntExpr(void)
Destructor.
Definition: int-expr.cpp:504
Node * x
Pointer to corresponding Boolean expression node.
Definition: bool-expr.cpp:253
SymmetryHandle diagonal_reflect(const Matrix< A > &m)
Reflect around main diagonal symmetry specification.
Definition: ldsb.hpp:112
Set variables
Definition: set.hh:129
Sum of integer variables.
Definition: minimodel.hh:153
Linear expressions over integer variables.
Definition: minimodel.hh:138
void count(Home home, const IntVarArgs &x, int n, IntRelType irt, int m, IntConLevel)
Post propagator for .
Definition: count.cpp:44
void tan(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition: arithmetic.cpp:210
FloatNum min(void) const
Return minimum of domain.
Definition: float.hpp:63
virtual FloatVar cost(void) const =0
Return variable with current cost.
SetCmpRel(const SetExpr &l, SetRelType srt, const SetExpr &r)
Constructor.
Definition: set-rel.hpp:47
bool operator>=(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:281
NonLinFloatExpr * nlfe(void) const
Return non-linear expression inside, or NULL if not non-linear.
Definition: float-expr.cpp:142
Integer variables.
Definition: int.hh:350
void rel(Home home, FloatVar x0, FloatRelType frt, FloatVal n)
Propagates .
Definition: rel.cpp:47
The default consistency for a constraint.
Definition: int.hh:941
IntOptimizeSpace(void)
Default constructor.
Definition: optimize.hpp:42
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:154
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:156
BoolExpr operator!(const BoolExpr &e)
Negated Boolean expression.
Definition: bool-expr.cpp:605
LinIntExpr operator%(const LinIntExpr &e0, const LinIntExpr &e1)
Return expression for .
Definition: int-arith.cpp:456
Archive & operator<<(Archive &e, FloatNumBranch nl)
Definition: val-sel.hpp:43
Implementation of the actual expression tree.
Definition: reg.cpp:56
#define GECODE_MINIMODEL_EXPORT
Definition: minimodel.hh:82
virtual IntVar post(Home home, IntVar *ret, IntConLevel icl) const =0
Return variable constrained to be equal to the expression.
virtual IntVar cost(void) const =0
Return variable with current cost.
Matrix-interface for arrays.
Definition: minimodel.hh:1924
Float variables.
Definition: float.hh:857
bool operator>(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:264
SetExpr operator|(const SetExpr &l, const SetExpr &r)
Union of set expressions.
Definition: set-expr.cpp:675
Integer constant.
Definition: minimodel.hh:149
MiniModel::IntOptimizeSpace< IRT_LE > MinimizeSpace
Class for minimizing integer cost.
Definition: minimodel.hh:2239
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:724
Traits of arrays in Gecode.
Definition: array.hpp:68
bool operator<=(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:247
MiniModel::FloatOptimizeSpace< FRT_GR > FloatMaximizeSpace
Class for maximizing float cost.
Definition: minimodel.hh:2252
Float value constant.
Definition: minimodel.hh:720
struct Gecode::@518::NNF::@57::@58 b
For binary nodes (and, or, eqv)
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 .
Definition: arithmetic.cpp:182
Slice< A > col(int c) const
Access column c.
Definition: matrix.hpp:187
void acos(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition: arithmetic.cpp:189
void exp(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition: arithmetic.cpp:144
Slice< A > slice(int fc, int tc, int fr, int tr) const
Access slice of the matrix.
Definition: matrix.hpp:175
Home class for posting propagators
Definition: core.hpp:717
~SetExpr(void)
Destructor.
Definition: set-expr.cpp:639
void nvalues(Home home, const IntVarArgs &x, IntRelType irt, int y, IntConLevel)
Post propagator for .
Definition: nvalues.cpp:44
struct Gecode::@518::NNF::@57::@59 a
For atomic nodes.
void atan(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition: arithmetic.cpp:203
BoolExpr operator||(const BoolExpr &l, const BoolExpr &r)
Disjunction of Boolean expressions.
Definition: bool-expr.cpp:596
SetVar post(Home home) const
Post propagators for expression.
Definition: set-expr.cpp:649
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
MiniModel::IntOptimizeSpace< IRT_GR > MaximizeSpace
Class for maximizing integer cost.
Definition: minimodel.hh:2241
void post(Home home, IntRelType irt, IntConLevel icl) const
Post propagator.
Definition: int-expr.cpp:160
BoolExpr(void)
Default constructor.
Definition: bool-expr.cpp:118
void post(Home home, bool t) const
Post propagator for relation (if t is false for negated relation)
Definition: float-rel.hpp:76