Generated on Sat Jun 2 2018 07:17:44 for Gecode by doxygen 1.8.13
registry.cpp
Go to the documentation of this file.
1 /* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
2 /*
3  * Main authors:
4  * Guido Tack <tack@gecode.org>
5  *
6  * Contributing authors:
7  * Mikael Lagerkvist <lagerkvist@gmail.com>
8  *
9  * Copyright:
10  * Guido Tack, 2007
11  * Mikael Lagerkvist, 2009
12  *
13  * This file is part of Gecode, the generic constraint
14  * development environment:
15  * http://www.gecode.org
16  *
17  * Permission is hereby granted, free of charge, to any person obtaining
18  * a copy of this software and associated documentation files (the
19  * "Software"), to deal in the Software without restriction, including
20  * without limitation the rights to use, copy, modify, merge, publish,
21  * distribute, sublicense, and/or sell copies of the Software, and to
22  * permit persons to whom the Software is furnished to do so, subject to
23  * the following conditions:
24  *
25  * The above copyright notice and this permission notice shall be
26  * included in all copies or substantial portions of the Software.
27  *
28  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
29  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
30  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
31  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
32  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
33  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
34  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
35  *
36  */
37 
39 #include <gecode/kernel.hh>
40 #include <gecode/int.hh>
41 #include <gecode/minimodel.hh>
42 
43 #ifdef GECODE_HAS_SET_VARS
44 #include <gecode/set.hh>
45 #endif
46 #ifdef GECODE_HAS_FLOAT_VARS
47 #include <gecode/float.hh>
48 #endif
49 #include <gecode/flatzinc.hh>
50 
51 namespace Gecode { namespace FlatZinc {
52 
53  Registry& registry(void) {
54  static Registry r;
55  return r;
56  }
57 
58  void
60  std::map<std::string,poster>::iterator i = r.find(ce.id);
61  if (i == r.end()) {
62  throw FlatZinc::Error("Registry",
63  std::string("Constraint ")+ce.id+" not found");
64  }
65  i->second(s, ce, ce.ann);
66  }
67 
68  void
69  Registry::add(const std::string& id, poster p) {
70  r[id] = p;
71  r["gecode_" + id] = p;
72  }
73 
74  namespace {
75 
76  void p_distinct(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
77  IntVarArgs va = s.arg2intvarargs(ce[0]);
78  IntPropLevel ipl = s.ann2ipl(ann);
79  unshare(s, va);
80  distinct(s, va, ipl == IPL_DEF ? IPL_BND : ipl);
81  }
82 
83  void p_distinctOffset(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
84  IntVarArgs va = s.arg2intvarargs(ce[1]);
85  unshare(s, va);
86  AST::Array* offs = ce.args->a[0]->getArray();
87  IntArgs oa(offs->a.size());
88  for (int i=offs->a.size(); i--; ) {
89  oa[i] = offs->a[i]->getInt();
90  }
91  IntPropLevel ipl = s.ann2ipl(ann);
92  distinct(s, oa, va, ipl == IPL_DEF ? IPL_BND : ipl);
93  }
94 
95  void p_all_equal(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
96  IntVarArgs va = s.arg2intvarargs(ce[0]);
97  rel(s, va, IRT_EQ, s.ann2ipl(ann));
98  }
99 
100  void p_int_CMP(FlatZincSpace& s, IntRelType irt, const ConExpr& ce,
101  AST::Node* ann) {
102  if (ce[0]->isIntVar()) {
103  if (ce[1]->isIntVar()) {
104  rel(s, s.arg2IntVar(ce[0]), irt, s.arg2IntVar(ce[1]),
105  s.ann2ipl(ann));
106  } else {
107  rel(s, s.arg2IntVar(ce[0]), irt, ce[1]->getInt(), s.ann2ipl(ann));
108  }
109  } else {
110  rel(s, s.arg2IntVar(ce[1]), swap(irt), ce[0]->getInt(),
111  s.ann2ipl(ann));
112  }
113  }
114  void p_int_eq(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
115  p_int_CMP(s, IRT_EQ, ce, ann);
116  }
117  void p_int_ne(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
118  p_int_CMP(s, IRT_NQ, ce, ann);
119  }
120  void p_int_ge(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
121  p_int_CMP(s, IRT_GQ, ce, ann);
122  }
123  void p_int_gt(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
124  p_int_CMP(s, IRT_GR, ce, ann);
125  }
126  void p_int_le(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
127  p_int_CMP(s, IRT_LQ, ce, ann);
128  }
129  void p_int_lt(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
130  p_int_CMP(s, IRT_LE, ce, ann);
131  }
132  void p_int_CMP_reif(FlatZincSpace& s, IntRelType irt, ReifyMode rm,
133  const ConExpr& ce, AST::Node* ann) {
134  if (rm == RM_EQV && ce[2]->isBool()) {
135  if (ce[2]->getBool()) {
136  p_int_CMP(s, irt, ce, ann);
137  } else {
138  p_int_CMP(s, neg(irt), ce, ann);
139  }
140  return;
141  }
142  if (ce[0]->isIntVar()) {
143  if (ce[1]->isIntVar()) {
144  rel(s, s.arg2IntVar(ce[0]), irt, s.arg2IntVar(ce[1]),
145  Reify(s.arg2BoolVar(ce[2]), rm), s.ann2ipl(ann));
146  } else {
147  rel(s, s.arg2IntVar(ce[0]), irt, ce[1]->getInt(),
148  Reify(s.arg2BoolVar(ce[2]), rm), s.ann2ipl(ann));
149  }
150  } else {
151  rel(s, s.arg2IntVar(ce[1]), swap(irt), ce[0]->getInt(),
152  Reify(s.arg2BoolVar(ce[2]), rm), s.ann2ipl(ann));
153  }
154  }
155 
156  /* Comparisons */
157  void p_int_eq_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
158  p_int_CMP_reif(s, IRT_EQ, RM_EQV, ce, ann);
159  }
160  void p_int_ne_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
161  p_int_CMP_reif(s, IRT_NQ, RM_EQV, ce, ann);
162  }
163  void p_int_ge_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
164  p_int_CMP_reif(s, IRT_GQ, RM_EQV, ce, ann);
165  }
166  void p_int_gt_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
167  p_int_CMP_reif(s, IRT_GR, RM_EQV, ce, ann);
168  }
169  void p_int_le_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
170  p_int_CMP_reif(s, IRT_LQ, RM_EQV, ce, ann);
171  }
172  void p_int_lt_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
173  p_int_CMP_reif(s, IRT_LE, RM_EQV, ce, ann);
174  }
175 
176  void p_int_eq_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
177  p_int_CMP_reif(s, IRT_EQ, RM_IMP, ce, ann);
178  }
179  void p_int_ne_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
180  p_int_CMP_reif(s, IRT_NQ, RM_IMP, ce, ann);
181  }
182  void p_int_ge_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
183  p_int_CMP_reif(s, IRT_GQ, RM_IMP, ce, ann);
184  }
185  void p_int_gt_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
186  p_int_CMP_reif(s, IRT_GR, RM_IMP, ce, ann);
187  }
188  void p_int_le_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
189  p_int_CMP_reif(s, IRT_LQ, RM_IMP, ce, ann);
190  }
191  void p_int_lt_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
192  p_int_CMP_reif(s, IRT_LE, RM_IMP, ce, ann);
193  }
194 
195  /* linear (in-)equations */
196  void p_int_lin_CMP(FlatZincSpace& s, IntRelType irt, const ConExpr& ce,
197  AST::Node* ann) {
198  IntArgs ia = s.arg2intargs(ce[0]);
199  int singleIntVar;
200  if (s.isBoolArray(ce[1],singleIntVar)) {
201  if (singleIntVar != -1) {
202  if (std::abs(ia[singleIntVar]) == 1 && ce[2]->getInt() == 0) {
203  IntVar siv = s.arg2IntVar(ce[1]->getArray()->a[singleIntVar]);
204  BoolVarArgs iv = s.arg2boolvarargs(ce[1], 0, singleIntVar);
205  IntArgs ia_tmp(ia.size()-1);
206  int count = 0;
207  for (int i=0; i<ia.size(); i++) {
208  if (i != singleIntVar)
209  ia_tmp[count++] = ia[singleIntVar] == -1 ? ia[i] : -ia[i];
210  }
211  IntRelType t = (ia[singleIntVar] == -1 ? irt : swap(irt));
212  linear(s, ia_tmp, iv, t, siv, s.ann2ipl(ann));
213  } else {
214  IntVarArgs iv = s.arg2intvarargs(ce[1]);
215  linear(s, ia, iv, irt, ce[2]->getInt(), s.ann2ipl(ann));
216  }
217  } else {
218  BoolVarArgs iv = s.arg2boolvarargs(ce[1]);
219  linear(s, ia, iv, irt, ce[2]->getInt(), s.ann2ipl(ann));
220  }
221  } else {
222  IntVarArgs iv = s.arg2intvarargs(ce[1]);
223  linear(s, ia, iv, irt, ce[2]->getInt(), s.ann2ipl(ann));
224  }
225  }
226  void p_int_lin_CMP_reif(FlatZincSpace& s, IntRelType irt, ReifyMode rm,
227  const ConExpr& ce, AST::Node* ann) {
228  if (rm == RM_EQV && ce[2]->isBool()) {
229  if (ce[2]->getBool()) {
230  p_int_lin_CMP(s, irt, ce, ann);
231  } else {
232  p_int_lin_CMP(s, neg(irt), ce, ann);
233  }
234  return;
235  }
236  IntArgs ia = s.arg2intargs(ce[0]);
237  int singleIntVar;
238  if (s.isBoolArray(ce[1],singleIntVar)) {
239  if (singleIntVar != -1) {
240  if (std::abs(ia[singleIntVar]) == 1 && ce[2]->getInt() == 0) {
241  IntVar siv = s.arg2IntVar(ce[1]->getArray()->a[singleIntVar]);
242  BoolVarArgs iv = s.arg2boolvarargs(ce[1], 0, singleIntVar);
243  IntArgs ia_tmp(ia.size()-1);
244  int count = 0;
245  for (int i=0; i<ia.size(); i++) {
246  if (i != singleIntVar)
247  ia_tmp[count++] = ia[singleIntVar] == -1 ? ia[i] : -ia[i];
248  }
249  IntRelType t = (ia[singleIntVar] == -1 ? irt : swap(irt));
250  linear(s, ia_tmp, iv, t, siv, Reify(s.arg2BoolVar(ce[3]), rm),
251  s.ann2ipl(ann));
252  } else {
253  IntVarArgs iv = s.arg2intvarargs(ce[1]);
254  linear(s, ia, iv, irt, ce[2]->getInt(),
255  Reify(s.arg2BoolVar(ce[3]), rm), s.ann2ipl(ann));
256  }
257  } else {
258  BoolVarArgs iv = s.arg2boolvarargs(ce[1]);
259  linear(s, ia, iv, irt, ce[2]->getInt(),
260  Reify(s.arg2BoolVar(ce[3]), rm), s.ann2ipl(ann));
261  }
262  } else {
263  IntVarArgs iv = s.arg2intvarargs(ce[1]);
264  linear(s, ia, iv, irt, ce[2]->getInt(),
265  Reify(s.arg2BoolVar(ce[3]), rm),
266  s.ann2ipl(ann));
267  }
268  }
269  void p_int_lin_eq(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
270  p_int_lin_CMP(s, IRT_EQ, ce, ann);
271  }
272  void p_int_lin_eq_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
273  p_int_lin_CMP_reif(s, IRT_EQ, RM_EQV, ce, ann);
274  }
275  void p_int_lin_eq_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
276  p_int_lin_CMP_reif(s, IRT_EQ, RM_IMP, ce, ann);
277  }
278  void p_int_lin_ne(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
279  p_int_lin_CMP(s, IRT_NQ, ce, ann);
280  }
281  void p_int_lin_ne_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
282  p_int_lin_CMP_reif(s, IRT_NQ, RM_EQV, ce, ann);
283  }
284  void p_int_lin_ne_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
285  p_int_lin_CMP_reif(s, IRT_NQ, RM_IMP, ce, ann);
286  }
287  void p_int_lin_le(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
288  p_int_lin_CMP(s, IRT_LQ, ce, ann);
289  }
290  void p_int_lin_le_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
291  p_int_lin_CMP_reif(s, IRT_LQ, RM_EQV, ce, ann);
292  }
293  void p_int_lin_le_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
294  p_int_lin_CMP_reif(s, IRT_LQ, RM_IMP, ce, ann);
295  }
296  void p_int_lin_lt(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
297  p_int_lin_CMP(s, IRT_LE, ce, ann);
298  }
299  void p_int_lin_lt_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
300  p_int_lin_CMP_reif(s, IRT_LE, RM_EQV, ce, ann);
301  }
302  void p_int_lin_lt_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
303  p_int_lin_CMP_reif(s, IRT_LE, RM_IMP, ce, ann);
304  }
305  void p_int_lin_ge(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
306  p_int_lin_CMP(s, IRT_GQ, ce, ann);
307  }
308  void p_int_lin_ge_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
309  p_int_lin_CMP_reif(s, IRT_GQ, RM_EQV, ce, ann);
310  }
311  void p_int_lin_ge_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
312  p_int_lin_CMP_reif(s, IRT_GQ, RM_IMP, ce, ann);
313  }
314  void p_int_lin_gt(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
315  p_int_lin_CMP(s, IRT_GR, ce, ann);
316  }
317  void p_int_lin_gt_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
318  p_int_lin_CMP_reif(s, IRT_GR, RM_EQV, ce, ann);
319  }
320  void p_int_lin_gt_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
321  p_int_lin_CMP_reif(s, IRT_GR, RM_IMP, ce, ann);
322  }
323 
324  void p_bool_lin_CMP(FlatZincSpace& s, IntRelType irt, const ConExpr& ce,
325  AST::Node* ann) {
326  IntArgs ia = s.arg2intargs(ce[0]);
327  BoolVarArgs iv = s.arg2boolvarargs(ce[1]);
328  if (ce[2]->isIntVar())
329  linear(s, ia, iv, irt, s.iv[ce[2]->getIntVar()], s.ann2ipl(ann));
330  else
331  linear(s, ia, iv, irt, ce[2]->getInt(), s.ann2ipl(ann));
332  }
333  void p_bool_lin_CMP_reif(FlatZincSpace& s, IntRelType irt, ReifyMode rm,
334  const ConExpr& ce, AST::Node* ann) {
335  if (rm == RM_EQV && ce[2]->isBool()) {
336  if (ce[2]->getBool()) {
337  p_bool_lin_CMP(s, irt, ce, ann);
338  } else {
339  p_bool_lin_CMP(s, neg(irt), ce, ann);
340  }
341  return;
342  }
343  IntArgs ia = s.arg2intargs(ce[0]);
344  BoolVarArgs iv = s.arg2boolvarargs(ce[1]);
345  if (ce[2]->isIntVar())
346  linear(s, ia, iv, irt, s.iv[ce[2]->getIntVar()],
347  Reify(s.arg2BoolVar(ce[3]), rm),
348  s.ann2ipl(ann));
349  else
350  linear(s, ia, iv, irt, ce[2]->getInt(),
351  Reify(s.arg2BoolVar(ce[3]), rm),
352  s.ann2ipl(ann));
353  }
354  void p_bool_lin_eq(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
355  p_bool_lin_CMP(s, IRT_EQ, ce, ann);
356  }
357  void p_bool_lin_eq_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann)
358  {
359  p_bool_lin_CMP_reif(s, IRT_EQ, RM_EQV, ce, ann);
360  }
361  void p_bool_lin_eq_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann)
362  {
363  p_bool_lin_CMP_reif(s, IRT_EQ, RM_IMP, ce, ann);
364  }
365  void p_bool_lin_ne(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
366  p_bool_lin_CMP(s, IRT_NQ, ce, ann);
367  }
368  void p_bool_lin_ne_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann)
369  {
370  p_bool_lin_CMP_reif(s, IRT_NQ, RM_EQV, ce, ann);
371  }
372  void p_bool_lin_ne_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann)
373  {
374  p_bool_lin_CMP_reif(s, IRT_NQ, RM_IMP, ce, ann);
375  }
376  void p_bool_lin_le(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
377  p_bool_lin_CMP(s, IRT_LQ, ce, ann);
378  }
379  void p_bool_lin_le_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann)
380  {
381  p_bool_lin_CMP_reif(s, IRT_LQ, RM_EQV, ce, ann);
382  }
383  void p_bool_lin_le_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann)
384  {
385  p_bool_lin_CMP_reif(s, IRT_LQ, RM_IMP, ce, ann);
386  }
387  void p_bool_lin_lt(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann)
388  {
389  p_bool_lin_CMP(s, IRT_LE, ce, ann);
390  }
391  void p_bool_lin_lt_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann)
392  {
393  p_bool_lin_CMP_reif(s, IRT_LE, RM_EQV, ce, ann);
394  }
395  void p_bool_lin_lt_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann)
396  {
397  p_bool_lin_CMP_reif(s, IRT_LE, RM_IMP, ce, ann);
398  }
399  void p_bool_lin_ge(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
400  p_bool_lin_CMP(s, IRT_GQ, ce, ann);
401  }
402  void p_bool_lin_ge_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann)
403  {
404  p_bool_lin_CMP_reif(s, IRT_GQ, RM_EQV, ce, ann);
405  }
406  void p_bool_lin_ge_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann)
407  {
408  p_bool_lin_CMP_reif(s, IRT_GQ, RM_IMP, ce, ann);
409  }
410  void p_bool_lin_gt(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
411  p_bool_lin_CMP(s, IRT_GR, ce, ann);
412  }
413  void p_bool_lin_gt_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann)
414  {
415  p_bool_lin_CMP_reif(s, IRT_GR, RM_EQV, ce, ann);
416  }
417  void p_bool_lin_gt_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann)
418  {
419  p_bool_lin_CMP_reif(s, IRT_GR, RM_IMP, ce, ann);
420  }
421 
422  /* arithmetic constraints */
423 
424  void p_int_plus(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
425  if (!ce[0]->isIntVar()) {
426  rel(s, ce[0]->getInt() + s.arg2IntVar(ce[1])
427  == s.arg2IntVar(ce[2]), s.ann2ipl(ann));
428  } else if (!ce[1]->isIntVar()) {
429  rel(s, s.arg2IntVar(ce[0]) + ce[1]->getInt()
430  == s.arg2IntVar(ce[2]), s.ann2ipl(ann));
431  } else if (!ce[2]->isIntVar()) {
432  rel(s, s.arg2IntVar(ce[0]) + s.arg2IntVar(ce[1])
433  == ce[2]->getInt(), s.ann2ipl(ann));
434  } else {
435  rel(s, s.arg2IntVar(ce[0]) + s.arg2IntVar(ce[1])
436  == s.arg2IntVar(ce[2]), s.ann2ipl(ann));
437  }
438  }
439 
440  void p_int_minus(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
441  if (!ce[0]->isIntVar()) {
442  rel(s, ce[0]->getInt() - s.arg2IntVar(ce[1])
443  == s.arg2IntVar(ce[2]), s.ann2ipl(ann));
444  } else if (!ce[1]->isIntVar()) {
445  rel(s, s.arg2IntVar(ce[0]) - ce[1]->getInt()
446  == s.arg2IntVar(ce[2]), s.ann2ipl(ann));
447  } else if (!ce[2]->isIntVar()) {
448  rel(s, s.arg2IntVar(ce[0]) - s.arg2IntVar(ce[1])
449  == ce[2]->getInt(), s.ann2ipl(ann));
450  } else {
451  rel(s, s.arg2IntVar(ce[0]) - s.arg2IntVar(ce[1])
452  == s.arg2IntVar(ce[2]), s.ann2ipl(ann));
453  }
454  }
455 
456  void p_int_times(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
457  IntVar x0 = s.arg2IntVar(ce[0]);
458  IntVar x1 = s.arg2IntVar(ce[1]);
459  IntVar x2 = s.arg2IntVar(ce[2]);
460  mult(s, x0, x1, x2, s.ann2ipl(ann));
461  }
462  void p_int_pow(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
463  IntVar x0 = s.arg2IntVar(ce[0]);
464  IntVar x2 = s.arg2IntVar(ce[2]);
465  pow(s, x0, ce[1]->getInt(), x2, s.ann2ipl(ann));
466  }
467  void p_int_div(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
468  IntVar x0 = s.arg2IntVar(ce[0]);
469  IntVar x1 = s.arg2IntVar(ce[1]);
470  IntVar x2 = s.arg2IntVar(ce[2]);
471  div(s,x0,x1,x2, s.ann2ipl(ann));
472  }
473  void p_int_mod(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
474  IntVar x0 = s.arg2IntVar(ce[0]);
475  IntVar x1 = s.arg2IntVar(ce[1]);
476  IntVar x2 = s.arg2IntVar(ce[2]);
477  mod(s,x0,x1,x2, s.ann2ipl(ann));
478  }
479 
480  void p_int_min(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
481  IntVar x0 = s.arg2IntVar(ce[0]);
482  IntVar x1 = s.arg2IntVar(ce[1]);
483  IntVar x2 = s.arg2IntVar(ce[2]);
484  min(s, x0, x1, x2, s.ann2ipl(ann));
485  }
486  void p_int_max(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
487  IntVar x0 = s.arg2IntVar(ce[0]);
488  IntVar x1 = s.arg2IntVar(ce[1]);
489  IntVar x2 = s.arg2IntVar(ce[2]);
490  max(s, x0, x1, x2, s.ann2ipl(ann));
491  }
492  void p_int_negate(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
493  IntVar x0 = s.arg2IntVar(ce[0]);
494  IntVar x1 = s.arg2IntVar(ce[1]);
495  rel(s, x0 == -x1, s.ann2ipl(ann));
496  }
497 
498  /* Boolean constraints */
499  void p_bool_CMP(FlatZincSpace& s, IntRelType irt, const ConExpr& ce,
500  AST::Node* ann) {
501  rel(s, s.arg2BoolVar(ce[0]), irt, s.arg2BoolVar(ce[1]),
502  s.ann2ipl(ann));
503  }
504  void p_bool_CMP_reif(FlatZincSpace& s, IntRelType irt, ReifyMode rm,
505  const ConExpr& ce, AST::Node* ann) {
506  rel(s, s.arg2BoolVar(ce[0]), irt, s.arg2BoolVar(ce[1]),
507  Reify(s.arg2BoolVar(ce[2]), rm), s.ann2ipl(ann));
508  }
509  void p_bool_eq(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
510  p_bool_CMP(s, IRT_EQ, ce, ann);
511  }
512  void p_bool_eq_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
513  p_bool_CMP_reif(s, IRT_EQ, RM_EQV, ce, ann);
514  }
515  void p_bool_eq_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
516  p_bool_CMP_reif(s, IRT_EQ, RM_IMP, ce, ann);
517  }
518  void p_bool_ne(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
519  p_bool_CMP(s, IRT_NQ, ce, ann);
520  }
521  void p_bool_ne_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
522  p_bool_CMP_reif(s, IRT_NQ, RM_EQV, ce, ann);
523  }
524  void p_bool_ne_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
525  p_bool_CMP_reif(s, IRT_NQ, RM_IMP, ce, ann);
526  }
527  void p_bool_ge(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
528  p_bool_CMP(s, IRT_GQ, ce, ann);
529  }
530  void p_bool_ge_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
531  p_bool_CMP_reif(s, IRT_GQ, RM_EQV, ce, ann);
532  }
533  void p_bool_ge_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
534  p_bool_CMP_reif(s, IRT_GQ, RM_IMP, ce, ann);
535  }
536  void p_bool_le(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
537  p_bool_CMP(s, IRT_LQ, ce, ann);
538  }
539  void p_bool_le_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
540  p_bool_CMP_reif(s, IRT_LQ, RM_EQV, ce, ann);
541  }
542  void p_bool_le_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
543  p_bool_CMP_reif(s, IRT_LQ, RM_IMP, ce, ann);
544  }
545  void p_bool_gt(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
546  p_bool_CMP(s, IRT_GR, ce, ann);
547  }
548  void p_bool_gt_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
549  p_bool_CMP_reif(s, IRT_GR, RM_EQV, ce, ann);
550  }
551  void p_bool_gt_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
552  p_bool_CMP_reif(s, IRT_GR, RM_IMP, ce, ann);
553  }
554  void p_bool_lt(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
555  p_bool_CMP(s, IRT_LE, ce, ann);
556  }
557  void p_bool_lt_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
558  p_bool_CMP_reif(s, IRT_LE, RM_EQV, ce, ann);
559  }
560  void p_bool_lt_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
561  p_bool_CMP_reif(s, IRT_LE, RM_IMP, ce, ann);
562  }
563 
564 #define BOOL_OP(op) \
565  BoolVar b0 = s.arg2BoolVar(ce[0]); \
566  BoolVar b1 = s.arg2BoolVar(ce[1]); \
567  if (ce[2]->isBool()) { \
568  rel(s, b0, op, b1, ce[2]->getBool(), s.ann2ipl(ann)); \
569  } else { \
570  rel(s, b0, op, b1, s.bv[ce[2]->getBoolVar()], s.ann2ipl(ann)); \
571  }
572 
573 #define BOOL_ARRAY_OP(op) \
574  BoolVarArgs bv = s.arg2boolvarargs(ce[0]); \
575  if (ce.size()==1) { \
576  rel(s, op, bv, 1, s.ann2ipl(ann)); \
577  } else if (ce[1]->isBool()) { \
578  rel(s, op, bv, ce[1]->getBool(), s.ann2ipl(ann)); \
579  } else { \
580  rel(s, op, bv, s.bv[ce[1]->getBoolVar()], s.ann2ipl(ann)); \
581  }
582 
583  void p_bool_or(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
584  BOOL_OP(BOT_OR);
585  }
586  void p_bool_or_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
587  BoolVar b0 = s.arg2BoolVar(ce[0]);
588  BoolVar b1 = s.arg2BoolVar(ce[1]);
589  BoolVar b2 = s.arg2BoolVar(ce[2]);
590  clause(s, BOT_OR, BoolVarArgs()<<b0<<b1, BoolVarArgs()<<b2, 1,
591  s.ann2ipl(ann));
592  }
593  void p_bool_and(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
594  BOOL_OP(BOT_AND);
595  }
596  void p_bool_and_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
597  BoolVar b0 = s.arg2BoolVar(ce[0]);
598  BoolVar b1 = s.arg2BoolVar(ce[1]);
599  BoolVar b2 = s.arg2BoolVar(ce[2]);
600  rel(s, b2, BOT_IMP, b0, 1, s.ann2ipl(ann));
601  rel(s, b2, BOT_IMP, b1, 1, s.ann2ipl(ann));
602  }
603  void p_array_bool_and(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann)
604  {
606  }
607  void p_array_bool_and_imp(FlatZincSpace& s, const ConExpr& ce,
608  AST::Node* ann)
609  {
610  BoolVarArgs bv = s.arg2boolvarargs(ce[0]);
611  BoolVar b1 = s.arg2BoolVar(ce[1]);
612  for (unsigned int i=bv.size(); i--;)
613  rel(s, b1, BOT_IMP, bv[i], 1, s.ann2ipl(ann));
614  }
615  void p_array_bool_or(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann)
616  {
618  }
619  void p_array_bool_or_imp(FlatZincSpace& s, const ConExpr& ce,
620  AST::Node* ann)
621  {
622  BoolVarArgs bv = s.arg2boolvarargs(ce[0]);
623  BoolVar b1 = s.arg2BoolVar(ce[1]);
624  clause(s, BOT_OR, bv, BoolVarArgs()<<b1, 1, s.ann2ipl(ann));
625  }
626  void p_array_bool_xor(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann)
627  {
629  }
630  void p_array_bool_xor_imp(FlatZincSpace& s, const ConExpr& ce,
631  AST::Node* ann)
632  {
633  BoolVarArgs bv = s.arg2boolvarargs(ce[0]);
634  BoolVar tmp(s,0,1);
635  rel(s, BOT_XOR, bv, tmp, s.ann2ipl(ann));
636  rel(s, s.arg2BoolVar(ce[1]), BOT_IMP, tmp, 1);
637  }
638  void p_array_bool_clause(FlatZincSpace& s, const ConExpr& ce,
639  AST::Node* ann) {
640  BoolVarArgs bvp = s.arg2boolvarargs(ce[0]);
641  BoolVarArgs bvn = s.arg2boolvarargs(ce[1]);
642  clause(s, BOT_OR, bvp, bvn, 1, s.ann2ipl(ann));
643  }
644  void p_array_bool_clause_reif(FlatZincSpace& s, const ConExpr& ce,
645  AST::Node* ann) {
646  BoolVarArgs bvp = s.arg2boolvarargs(ce[0]);
647  BoolVarArgs bvn = s.arg2boolvarargs(ce[1]);
648  BoolVar b0 = s.arg2BoolVar(ce[2]);
649  clause(s, BOT_OR, bvp, bvn, b0, s.ann2ipl(ann));
650  }
651  void p_array_bool_clause_imp(FlatZincSpace& s, const ConExpr& ce,
652  AST::Node* ann) {
653  BoolVarArgs bvp = s.arg2boolvarargs(ce[0]);
654  BoolVarArgs bvn = s.arg2boolvarargs(ce[1]);
655  BoolVar b0 = s.arg2BoolVar(ce[2]);
656  clause(s, BOT_OR, bvp, bvn, b0, s.ann2ipl(ann));
657  }
658  void p_bool_xor(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
659  BOOL_OP(BOT_XOR);
660  }
661  void p_bool_xor_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
662  BoolVar b0 = s.arg2BoolVar(ce[0]);
663  BoolVar b1 = s.arg2BoolVar(ce[1]);
664  BoolVar b2 = s.arg2BoolVar(ce[2]);
665  clause(s, BOT_OR, BoolVarArgs()<<b0<<b1, BoolVarArgs()<<b2, 1,
666  s.ann2ipl(ann));
667  clause(s, BOT_OR, BoolVarArgs(), BoolVarArgs()<<b0<<b1<<b2, 1,
668  s.ann2ipl(ann));
669  }
670  void p_bool_l_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
671  BoolVar b0 = s.arg2BoolVar(ce[0]);
672  BoolVar b1 = s.arg2BoolVar(ce[1]);
673  if (ce[2]->isBool()) {
674  rel(s, b1, BOT_IMP, b0, ce[2]->getBool(), s.ann2ipl(ann));
675  } else {
676  rel(s, b1, BOT_IMP, b0, s.bv[ce[2]->getBoolVar()], s.ann2ipl(ann));
677  }
678  }
679  void p_bool_r_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
680  BOOL_OP(BOT_IMP);
681  }
682  void p_bool_not(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
683  BoolVar x0 = s.arg2BoolVar(ce[0]);
684  BoolVar x1 = s.arg2BoolVar(ce[1]);
685  rel(s, x0, BOT_XOR, x1, 1, s.ann2ipl(ann));
686  }
687 
688  /* element constraints */
689  void p_array_int_element(FlatZincSpace& s, const ConExpr& ce,
690  AST::Node* ann) {
691  bool isConstant = true;
692  AST::Array* a = ce[1]->getArray();
693  for (int i=a->a.size(); i--;) {
694  if (!a->a[i]->isInt()) {
695  isConstant = false;
696  break;
697  }
698  }
699  IntVar selector = s.arg2IntVar(ce[0]);
700  rel(s, selector > 0);
701  if (isConstant) {
702  IntSharedArray sia = s.arg2intsharedarray(ce[1], 1);
703  element(s, sia, selector, s.arg2IntVar(ce[2]), s.ann2ipl(ann));
704  } else {
705  IntVarArgs iv = s.arg2intvarargs(ce[1], 1);
706  element(s, iv, selector, s.arg2IntVar(ce[2]), s.ann2ipl(ann));
707  }
708  }
709  void p_array_bool_element(FlatZincSpace& s, const ConExpr& ce,
710  AST::Node* ann) {
711  bool isConstant = true;
712  AST::Array* a = ce[1]->getArray();
713  for (int i=a->a.size(); i--;) {
714  if (!a->a[i]->isBool()) {
715  isConstant = false;
716  break;
717  }
718  }
719  IntVar selector = s.arg2IntVar(ce[0]);
720  rel(s, selector > 0);
721  if (isConstant) {
722  IntSharedArray sia = s.arg2boolsharedarray(ce[1], 1);
723  element(s, sia, selector, s.arg2BoolVar(ce[2]), s.ann2ipl(ann));
724  } else {
725  BoolVarArgs iv = s.arg2boolvarargs(ce[1], 1);
726  element(s, iv, selector, s.arg2BoolVar(ce[2]), s.ann2ipl(ann));
727  }
728  }
729 
730  /* coercion constraints */
731  void p_bool2int(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
732  BoolVar x0 = s.arg2BoolVar(ce[0]);
733  IntVar x1 = s.arg2IntVar(ce[1]);
734  if (ce[0]->isBoolVar() && ce[1]->isIntVar()) {
735  s.aliasBool2Int(ce[1]->getIntVar(), ce[0]->getBoolVar());
736  }
737  channel(s, x0, x1, s.ann2ipl(ann));
738  }
739 
740  void p_int_in(FlatZincSpace& s, const ConExpr& ce, AST::Node *) {
741  IntSet d = s.arg2intset(ce[1]);
742  if (ce[0]->isBoolVar()) {
743  IntSetRanges dr(d);
744  Iter::Ranges::Singleton sr(0,1);
745  Iter::Ranges::Inter<IntSetRanges,Iter::Ranges::Singleton> i(dr,sr);
746  IntSet d01(i);
747  if (d01.size() == 0) {
748  s.fail();
749  } else {
750  rel(s, s.arg2BoolVar(ce[0]), IRT_GQ, d01.min());
751  rel(s, s.arg2BoolVar(ce[0]), IRT_LQ, d01.max());
752  }
753  } else {
754  dom(s, s.arg2IntVar(ce[0]), d);
755  }
756  }
757  void p_int_in_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node *) {
758  IntSet d = s.arg2intset(ce[1]);
759  if (ce[0]->isBoolVar()) {
760  IntSetRanges dr(d);
761  Iter::Ranges::Singleton sr(0,1);
762  Iter::Ranges::Inter<IntSetRanges,Iter::Ranges::Singleton> i(dr,sr);
763  IntSet d01(i);
764  if (d01.size() == 0) {
765  rel(s, s.arg2BoolVar(ce[2]) == 0);
766  } else if (d01.max() == 0) {
767  rel(s, s.arg2BoolVar(ce[2]) == !s.arg2BoolVar(ce[0]));
768  } else if (d01.min() == 1) {
769  rel(s, s.arg2BoolVar(ce[2]) == s.arg2BoolVar(ce[0]));
770  } else {
771  rel(s, s.arg2BoolVar(ce[2]) == 1);
772  }
773  } else {
774  dom(s, s.arg2IntVar(ce[0]), d, s.arg2BoolVar(ce[2]));
775  }
776  }
777  void p_int_in_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node *) {
778  IntSet d = s.arg2intset(ce[1]);
779  if (ce[0]->isBoolVar()) {
780  IntSetRanges dr(d);
781  Iter::Ranges::Singleton sr(0,1);
782  Iter::Ranges::Inter<IntSetRanges,Iter::Ranges::Singleton> i(dr,sr);
783  IntSet d01(i);
784  if (d01.size() == 0) {
785  rel(s, s.arg2BoolVar(ce[2]) == 0);
786  } else if (d01.max() == 0) {
787  rel(s, s.arg2BoolVar(ce[2]) >> !s.arg2BoolVar(ce[0]));
788  } else if (d01.min() == 1) {
789  rel(s, s.arg2BoolVar(ce[2]) >> s.arg2BoolVar(ce[0]));
790  }
791  } else {
792  dom(s, s.arg2IntVar(ce[0]), d, Reify(s.arg2BoolVar(ce[2]),RM_IMP));
793  }
794  }
795 
796  /* constraints from the standard library */
797 
798  void p_abs(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
799  IntVar x0 = s.arg2IntVar(ce[0]);
800  IntVar x1 = s.arg2IntVar(ce[1]);
801  abs(s, x0, x1, s.ann2ipl(ann));
802  }
803 
804  void p_array_int_lt(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
805  IntVarArgs iv0 = s.arg2intvarargs(ce[0]);
806  IntVarArgs iv1 = s.arg2intvarargs(ce[1]);
807  rel(s, iv0, IRT_LE, iv1, s.ann2ipl(ann));
808  }
809 
810  void p_array_int_lq(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
811  IntVarArgs iv0 = s.arg2intvarargs(ce[0]);
812  IntVarArgs iv1 = s.arg2intvarargs(ce[1]);
813  rel(s, iv0, IRT_LQ, iv1, s.ann2ipl(ann));
814  }
815 
816  void p_array_bool_lt(FlatZincSpace& s, const ConExpr& ce,
817  AST::Node* ann) {
818  BoolVarArgs bv0 = s.arg2boolvarargs(ce[0]);
819  BoolVarArgs bv1 = s.arg2boolvarargs(ce[1]);
820  rel(s, bv0, IRT_LE, bv1, s.ann2ipl(ann));
821  }
822 
823  void p_array_bool_lq(FlatZincSpace& s, const ConExpr& ce,
824  AST::Node* ann) {
825  BoolVarArgs bv0 = s.arg2boolvarargs(ce[0]);
826  BoolVarArgs bv1 = s.arg2boolvarargs(ce[1]);
827  rel(s, bv0, IRT_LQ, bv1, s.ann2ipl(ann));
828  }
829 
830  void p_count(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
831  IntVarArgs iv = s.arg2intvarargs(ce[0]);
832  if (!ce[1]->isIntVar()) {
833  if (!ce[2]->isIntVar()) {
834  count(s, iv, ce[1]->getInt(), IRT_EQ, ce[2]->getInt(),
835  s.ann2ipl(ann));
836  } else {
837  count(s, iv, ce[1]->getInt(), IRT_EQ, s.arg2IntVar(ce[2]),
838  s.ann2ipl(ann));
839  }
840  } else if (!ce[2]->isIntVar()) {
841  count(s, iv, s.arg2IntVar(ce[1]), IRT_EQ, ce[2]->getInt(),
842  s.ann2ipl(ann));
843  } else {
844  count(s, iv, s.arg2IntVar(ce[1]), IRT_EQ, s.arg2IntVar(ce[2]),
845  s.ann2ipl(ann));
846  }
847  }
848 
849  void p_count_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
850  IntVarArgs iv = s.arg2intvarargs(ce[0]);
851  IntVar x = s.arg2IntVar(ce[1]);
852  IntVar y = s.arg2IntVar(ce[2]);
853  BoolVar b = s.arg2BoolVar(ce[3]);
854  IntVar c(s,0,Int::Limits::max);
855  count(s,iv,x,IRT_EQ,c,s.ann2ipl(ann));
856  rel(s, b == (c==y));
857  }
858  void p_count_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
859  IntVarArgs iv = s.arg2intvarargs(ce[0]);
860  IntVar x = s.arg2IntVar(ce[1]);
861  IntVar y = s.arg2IntVar(ce[2]);
862  BoolVar b = s.arg2BoolVar(ce[3]);
863  IntVar c(s,0,Int::Limits::max);
864  count(s,iv,x,IRT_EQ,c,s.ann2ipl(ann));
865  rel(s, b >> (c==y));
866  }
867 
868  void count_rel(IntRelType irt,
869  FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
870  IntVarArgs iv = s.arg2intvarargs(ce[1]);
871  count(s, iv, ce[2]->getInt(), irt, ce[0]->getInt(), s.ann2ipl(ann));
872  }
873 
874  void p_at_most(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
875  count_rel(IRT_LQ, s, ce, ann);
876  }
877 
878  void p_at_least(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
879  count_rel(IRT_GQ, s, ce, ann);
880  }
881 
882  void p_bin_packing_load(FlatZincSpace& s, const ConExpr& ce,
883  AST::Node* ann) {
884  int minIdx = ce[3]->getInt();
885  IntVarArgs load = s.arg2intvarargs(ce[0]);
886  IntVarArgs l;
887  IntVarArgs bin = s.arg2intvarargs(ce[1]);
888  for (int i=bin.size(); i--;)
889  rel(s, bin[i] >= minIdx);
890  if (minIdx > 0) {
891  for (int i=minIdx; i--;)
892  l << IntVar(s,0,0);
893  } else if (minIdx < 0) {
894  IntVarArgs bin2(bin.size());
895  for (int i=bin.size(); i--;)
896  bin2[i] = expr(s, bin[i]-minIdx, s.ann2ipl(ann));
897  bin = bin2;
898  }
899  l << load;
900  IntArgs sizes = s.arg2intargs(ce[2]);
901 
902  IntVarArgs allvars = l + bin;
903  unshare(s, allvars);
904  binpacking(s, allvars.slice(0,1,l.size()), allvars.slice(l.size(),1,bin.size()),
905  sizes, s.ann2ipl(ann));
906  }
907 
908  void p_global_cardinality(FlatZincSpace& s, const ConExpr& ce,
909  AST::Node* ann) {
910  IntVarArgs iv0 = s.arg2intvarargs(ce[0]);
911  IntArgs cover = s.arg2intargs(ce[1]);
912  IntVarArgs iv1 = s.arg2intvarargs(ce[2]);
913 
914  Region re;
915  IntSet cover_s(cover);
916  IntSetRanges cover_r(cover_s);
917  IntVarRanges* iv0_ri = re.alloc<IntVarRanges>(iv0.size());
918  for (int i=iv0.size(); i--;)
919  iv0_ri[i] = IntVarRanges(iv0[i]);
920  Iter::Ranges::NaryUnion iv0_r(re,iv0_ri,iv0.size());
921  Iter::Ranges::Diff<Iter::Ranges::NaryUnion,IntSetRanges>
922  extra_r(iv0_r,cover_r);
923  Iter::Ranges::ToValues<Iter::Ranges::Diff<
924  Iter::Ranges::NaryUnion,IntSetRanges> > extra(extra_r);
925  for (; extra(); ++extra) {
926  cover << extra.val();
927  iv1 << IntVar(s,0,iv0.size());
928  }
929  IntPropLevel ipl = s.ann2ipl(ann);
930  if (ipl==IPL_DEF)
931  ipl=IPL_BND;
932  if (ipl==IPL_DOM) {
933  IntVarArgs allvars = iv0+iv1;
934  unshare(s, allvars);
935  count(s, allvars.slice(0,1,iv0.size()),
936  allvars.slice(iv0.size(),1,iv1.size()),
937  cover, ipl);
938  } else {
939  unshare(s, iv0);
940  count(s, iv0, iv1, cover, ipl);
941  }
942  }
943 
944  void p_global_cardinality_closed(FlatZincSpace& s, const ConExpr& ce,
945  AST::Node* ann) {
946  IntVarArgs iv0 = s.arg2intvarargs(ce[0]);
947  IntArgs cover = s.arg2intargs(ce[1]);
948  IntVarArgs iv1 = s.arg2intvarargs(ce[2]);
949  IntPropLevel ipl = s.ann2ipl(ann);
950  if (ipl==IPL_DEF)
951  ipl=IPL_BND;
952  if (ipl==IPL_DOM) {
953  IntVarArgs allvars = iv0+iv1;
954  unshare(s, allvars);
955  count(s, allvars.slice(0,1,iv0.size()),
956  allvars.slice(iv0.size(),1,iv1.size()),
957  cover, ipl);
958  } else {
959  unshare(s, iv0);
960  count(s, iv0, iv1, cover, ipl);
961  }
962  }
963 
964  void p_global_cardinality_low_up(FlatZincSpace& s, const ConExpr& ce,
965  AST::Node* ann) {
966  IntVarArgs x = s.arg2intvarargs(ce[0]);
967  IntArgs cover = s.arg2intargs(ce[1]);
968 
969  IntArgs lbound = s.arg2intargs(ce[2]);
970  IntArgs ubound = s.arg2intargs(ce[3]);
971  IntSetArgs y(cover.size());
972  for (int i=cover.size(); i--;)
973  y[i] = IntSet(lbound[i],ubound[i]);
974 
975  IntSet cover_s(cover);
976  Region re;
977  IntVarRanges* xrs = re.alloc<IntVarRanges>(x.size());
978  for (int i=x.size(); i--;)
979  xrs[i].init(x[i]);
980  Iter::Ranges::NaryUnion u(re, xrs, x.size());
981  Iter::Ranges::ToValues<Iter::Ranges::NaryUnion> uv(u);
982  for (; uv(); ++uv) {
983  if (!cover_s.in(uv.val())) {
984  cover << uv.val();
985  y << IntSet(0,x.size());
986  }
987  }
988  unshare(s, x);
989  IntPropLevel ipl = s.ann2ipl(ann);
990  if (ipl==IPL_DEF)
991  ipl=IPL_BND;
992  count(s, x, y, cover, ipl);
993  }
994 
995  void p_global_cardinality_low_up_closed(FlatZincSpace& s,
996  const ConExpr& ce,
997  AST::Node* ann) {
998  IntVarArgs x = s.arg2intvarargs(ce[0]);
999  IntArgs cover = s.arg2intargs(ce[1]);
1000 
1001  IntArgs lbound = s.arg2intargs(ce[2]);
1002  IntArgs ubound = s.arg2intargs(ce[3]);
1003  IntSetArgs y(cover.size());
1004  for (int i=cover.size(); i--;)
1005  y[i] = IntSet(lbound[i],ubound[i]);
1006  unshare(s, x);
1007  IntPropLevel ipl = s.ann2ipl(ann);
1008  if (ipl==IPL_DEF)
1009  ipl=IPL_BND;
1010  count(s, x, y, cover, ipl);
1011  }
1012 
1013  void p_minimum(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1014  IntVarArgs iv = s.arg2intvarargs(ce[1]);
1015  min(s, iv, s.arg2IntVar(ce[0]), s.ann2ipl(ann));
1016  }
1017 
1018  void p_maximum(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1019  IntVarArgs iv = s.arg2intvarargs(ce[1]);
1020  max(s, iv, s.arg2IntVar(ce[0]), s.ann2ipl(ann));
1021  }
1022 
1023  void p_minimum_arg(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1024  IntVarArgs iv = s.arg2intvarargs(ce[0]);
1025  argmin(s, iv, s.arg2IntVar(ce[1]), true, s.ann2ipl(ann));
1026  }
1027 
1028  void p_maximum_arg(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1029  IntVarArgs iv = s.arg2intvarargs(ce[0]);
1030  argmax(s, iv, s.arg2IntVar(ce[1]), true, s.ann2ipl(ann));
1031  }
1032 
1033  void p_regular(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1034  IntVarArgs iv = s.arg2intvarargs(ce[0]);
1035  int q = ce[1]->getInt();
1036  int symbols = ce[2]->getInt();
1037  IntArgs d = s.arg2intargs(ce[3]);
1038  int q0 = ce[4]->getInt();
1039 
1040  int noOfTrans = 0;
1041  for (int i=1; i<=q; i++) {
1042  for (int j=1; j<=symbols; j++) {
1043  if (d[(i-1)*symbols+(j-1)] > 0)
1044  noOfTrans++;
1045  }
1046  }
1047 
1048  Region re;
1049  DFA::Transition* t = re.alloc<DFA::Transition>(noOfTrans+1);
1050  noOfTrans = 0;
1051  for (int i=1; i<=q; i++) {
1052  for (int j=1; j<=symbols; j++) {
1053  if (d[(i-1)*symbols+(j-1)] > 0) {
1054  t[noOfTrans].i_state = i;
1055  t[noOfTrans].symbol = j;
1056  t[noOfTrans].o_state = d[(i-1)*symbols+(j-1)];
1057  noOfTrans++;
1058  }
1059  }
1060  }
1061  t[noOfTrans].i_state = -1;
1062 
1063  // Final states
1064  AST::SetLit* sl = ce[5]->getSet();
1065  int* f;
1066  if (sl->interval) {
1067  f = static_cast<int*>(heap.ralloc(sizeof(int)*(sl->max-sl->min+2)));
1068  for (int i=sl->min; i<=sl->max; i++)
1069  f[i-sl->min] = i;
1070  f[sl->max-sl->min+1] = -1;
1071  } else {
1072  f = static_cast<int*>(heap.ralloc(sizeof(int)*(sl->s.size()+1)));
1073  for (int j=sl->s.size(); j--; )
1074  f[j] = sl->s[j];
1075  f[sl->s.size()] = -1;
1076  }
1077 
1078  DFA dfa(q0,t,f);
1079  free(f);
1080  unshare(s, iv);
1081  extensional(s, iv, s.getSharedDFA(dfa), s.ann2ipl(ann));
1082  }
1083 
1084  void
1085  p_sort(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1086  IntVarArgs x = s.arg2intvarargs(ce[0]);
1087  IntVarArgs y = s.arg2intvarargs(ce[1]);
1088  IntVarArgs xy(x.size()+y.size());
1089  for (int i=x.size(); i--;)
1090  xy[i] = x[i];
1091  for (int i=y.size(); i--;)
1092  xy[i+x.size()] = y[i];
1093  unshare(s, xy);
1094  for (int i=x.size(); i--;)
1095  x[i] = xy[i];
1096  for (int i=y.size(); i--;)
1097  y[i] = xy[i+x.size()];
1098  sorted(s, x, y, s.ann2ipl(ann));
1099  }
1100 
1101  void
1102  p_inverse_offsets(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1103  IntVarArgs x = s.arg2intvarargs(ce[0]);
1104  unshare(s, x);
1105  int xoff = ce[1]->getInt();
1106  IntVarArgs y = s.arg2intvarargs(ce[2]);
1107  unshare(s, y);
1108  int yoff = ce[3]->getInt();
1109  channel(s, x, xoff, y, yoff, s.ann2ipl(ann));
1110  }
1111 
1112  void
1113  p_increasing_int(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1114  IntVarArgs x = s.arg2intvarargs(ce[0]);
1115  rel(s,x,IRT_LQ,s.ann2ipl(ann));
1116  }
1117 
1118  void
1119  p_increasing_bool(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1120  BoolVarArgs x = s.arg2boolvarargs(ce[0]);
1121  rel(s,x,IRT_LQ,s.ann2ipl(ann));
1122  }
1123 
1124  void
1125  p_decreasing_int(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1126  IntVarArgs x = s.arg2intvarargs(ce[0]);
1127  rel(s,x,IRT_GQ,s.ann2ipl(ann));
1128  }
1129 
1130  void
1131  p_decreasing_bool(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1132  BoolVarArgs x = s.arg2boolvarargs(ce[0]);
1133  rel(s,x,IRT_GQ,s.ann2ipl(ann));
1134  }
1135 
1136  void
1137  p_table_int(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1138  IntVarArgs x = s.arg2intvarargs(ce[0]);
1139  TupleSet ts = s.arg2tupleset(ce[1],x.size());
1140  extensional(s,x,ts,s.ann2ipl(ann));
1141  }
1142 
1143  void
1144  p_table_bool(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1145  BoolVarArgs x = s.arg2boolvarargs(ce[0]);
1146  IntArgs tuples = s.arg2boolargs(ce[1]);
1147  int noOfVars = x.size();
1148  int noOfTuples = tuples.size() == 0 ? 0 : (tuples.size()/noOfVars);
1149  TupleSet ts(noOfVars);
1150  for (int i=0; i<noOfTuples; i++) {
1151  IntArgs t(noOfVars);
1152  for (int j=0; j<x.size(); j++) {
1153  t[j] = tuples[i*noOfVars+j];
1154  }
1155  ts.add(t);
1156  }
1157  ts.finalize();
1158  extensional(s,x,ts,s.ann2ipl(ann));
1159  }
1160 
1161  void p_cumulative_opt(FlatZincSpace& s, const ConExpr& ce,
1162  AST::Node* ann) {
1163  IntVarArgs start = s.arg2intvarargs(ce[0]);
1164  IntArgs duration = s.arg2intargs(ce[1]);
1165  IntArgs height = s.arg2intargs(ce[2]);
1166  BoolVarArgs opt = s.arg2boolvarargs(ce[3]);
1167  int bound = ce[4]->getInt();
1168  unshare(s,start);
1169  cumulative(s,bound,start,duration,height,opt,s.ann2ipl(ann));
1170  }
1171 
1172  void p_cumulatives(FlatZincSpace& s, const ConExpr& ce,
1173  AST::Node* ann) {
1174  IntVarArgs start = s.arg2intvarargs(ce[0]);
1175  IntVarArgs duration = s.arg2intvarargs(ce[1]);
1176  IntVarArgs height = s.arg2intvarargs(ce[2]);
1177  int n = start.size();
1178  IntVar bound = s.arg2IntVar(ce[3]);
1179 
1180  if (n==0)
1181  return;
1182 
1183  if (n == 1) {
1184  rel(s, height[0] <= bound);
1185  return;
1186  }
1187 
1188  int minHeight = std::min(height[0].min(),height[1].min());
1189  int minHeight2 = std::max(height[0].min(),height[1].min());
1190  for (int i=2; i<n; i++) {
1191  if (height[i].min() < minHeight) {
1192  minHeight2 = minHeight;
1193  minHeight = height[i].min();
1194  } else if (height[i].min() < minHeight2) {
1195  minHeight2 = height[i].min();
1196  }
1197  }
1198  bool disjunctive =
1199  (minHeight > bound.max()/2) ||
1200  (minHeight2 > bound.max()/2 && minHeight+minHeight2>bound.max());
1201  if (disjunctive) {
1202  rel(s, bound >= max(height));
1203  // Unary
1204  if (duration.assigned()) {
1205  IntArgs durationI(n);
1206  for (int i=n; i--;)
1207  durationI[i] = duration[i].val();
1208  unshare(s,start);
1209  unary(s,start,durationI);
1210  } else {
1211  IntVarArgs end(n);
1212  for (int i=n; i--;)
1213  end[i] = expr(s,start[i]+duration[i]);
1214  unshare(s,start);
1215  unary(s,start,duration,end);
1216  }
1217  } else if (height.assigned()) {
1218  IntArgs heightI(n);
1219  for (int i=n; i--;)
1220  heightI[i] = height[i].val();
1221  if (duration.assigned()) {
1222  IntArgs durationI(n);
1223  for (int i=n; i--;)
1224  durationI[i] = duration[i].val();
1225  cumulative(s, bound, start, durationI, heightI);
1226  } else {
1227  IntVarArgs end(n);
1228  for (int i = n; i--; )
1229  end[i] = expr(s,start[i]+duration[i]);
1230  cumulative(s, bound, start, duration, end, heightI);
1231  }
1232  } else if (bound.assigned()) {
1233  IntArgs machine = IntArgs::create(n,0,0);
1234  IntArgs limit(1, bound.val());
1235  IntVarArgs end(n);
1236  for (int i=n; i--;)
1237  end[i] = expr(s,start[i]+duration[i]);
1238  cumulatives(s, machine, start, duration, end, height, limit, true,
1239  s.ann2ipl(ann));
1240  } else {
1243  IntVarArgs end(start.size());
1244  for (int i = start.size(); i--; ) {
1245  min = std::min(min, start[i].min());
1246  max = std::max(max, start[i].max() + duration[i].max());
1247  end[i] = expr(s, start[i] + duration[i]);
1248  }
1249  for (int time = min; time < max; ++time) {
1250  IntVarArgs x(start.size());
1251  for (int i = start.size(); i--; ) {
1252  IntVar overlaps = channel(s, expr(s, (start[i] <= time) &&
1253  (time < end[i])));
1254  x[i] = expr(s, overlaps * height[i]);
1255  }
1256  linear(s, x, IRT_LQ, bound);
1257  }
1258  }
1259  }
1260 
1261  void p_among_seq_int(FlatZincSpace& s, const ConExpr& ce,
1262  AST::Node* ann) {
1263  IntVarArgs x = s.arg2intvarargs(ce[0]);
1264  IntSet S = s.arg2intset(ce[1]);
1265  int q = ce[2]->getInt();
1266  int l = ce[3]->getInt();
1267  int u = ce[4]->getInt();
1268  unshare(s, x);
1269  sequence(s, x, S, q, l, u, s.ann2ipl(ann));
1270  }
1271 
1272  void p_among_seq_bool(FlatZincSpace& s, const ConExpr& ce,
1273  AST::Node* ann) {
1274  BoolVarArgs x = s.arg2boolvarargs(ce[0]);
1275  bool val = ce[1]->getBool();
1276  int q = ce[2]->getInt();
1277  int l = ce[3]->getInt();
1278  int u = ce[4]->getInt();
1279  IntSet S(val, val);
1280  unshare(s, x);
1281  sequence(s, x, S, q, l, u, s.ann2ipl(ann));
1282  }
1283 
1284  void p_schedule_unary(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
1285  IntVarArgs x = s.arg2intvarargs(ce[0]);
1286  IntArgs p = s.arg2intargs(ce[1]);
1287  unshare(s,x);
1288  unary(s, x, p);
1289  }
1290 
1291  void p_schedule_unary_optional(FlatZincSpace& s, const ConExpr& ce,
1292  AST::Node*) {
1293  IntVarArgs x = s.arg2intvarargs(ce[0]);
1294  IntArgs p = s.arg2intargs(ce[1]);
1295  BoolVarArgs m = s.arg2boolvarargs(ce[2]);
1296  unshare(s,x);
1297  unary(s, x, p, m);
1298  }
1299 
1300  void p_circuit(FlatZincSpace& s, const ConExpr& ce, AST::Node *ann) {
1301  int off = ce[0]->getInt();
1302  IntVarArgs xv = s.arg2intvarargs(ce[1]);
1303  unshare(s,xv);
1304  circuit(s,off,xv,s.ann2ipl(ann));
1305  }
1306  void p_circuit_cost_array(FlatZincSpace& s, const ConExpr& ce,
1307  AST::Node *ann) {
1308  IntArgs c = s.arg2intargs(ce[0]);
1309  IntVarArgs xv = s.arg2intvarargs(ce[1]);
1310  IntVarArgs yv = s.arg2intvarargs(ce[2]);
1311  IntVar z = s.arg2IntVar(ce[3]);
1312  unshare(s,xv);
1313  circuit(s,c,xv,yv,z,s.ann2ipl(ann));
1314  }
1315  void p_circuit_cost(FlatZincSpace& s, const ConExpr& ce, AST::Node *ann) {
1316  IntArgs c = s.arg2intargs(ce[0]);
1317  IntVarArgs xv = s.arg2intvarargs(ce[1]);
1318  IntVar z = s.arg2IntVar(ce[2]);
1319  unshare(s,xv);
1320  circuit(s,c,xv,z,s.ann2ipl(ann));
1321  }
1322 
1323  void p_nooverlap(FlatZincSpace& s, const ConExpr& ce, AST::Node *ann) {
1324  IntVarArgs x0 = s.arg2intvarargs(ce[0]);
1325  IntVarArgs w = s.arg2intvarargs(ce[1]);
1326  IntVarArgs y0 = s.arg2intvarargs(ce[2]);
1327  IntVarArgs h = s.arg2intvarargs(ce[3]);
1328  if (w.assigned() && h.assigned()) {
1329  IntArgs iw(w.size());
1330  for (int i=w.size(); i--;)
1331  iw[i] = w[i].val();
1332  IntArgs ih(h.size());
1333  for (int i=h.size(); i--;)
1334  ih[i] = h[i].val();
1335  nooverlap(s,x0,iw,y0,ih,s.ann2ipl(ann));
1336 
1337  int miny = y0[0].min();
1338  int maxy = y0[0].max();
1339  int maxdy = ih[0];
1340  for (int i=1; i<y0.size(); i++) {
1341  miny = std::min(miny,y0[i].min());
1342  maxy = std::max(maxy,y0[i].max());
1343  maxdy = std::max(maxdy,ih[i]);
1344  }
1345  int minx = x0[0].min();
1346  int maxx = x0[0].max();
1347  int maxdx = iw[0];
1348  for (int i=1; i<x0.size(); i++) {
1349  minx = std::min(minx,x0[i].min());
1350  maxx = std::max(maxx,x0[i].max());
1351  maxdx = std::max(maxdx,iw[i]);
1352  }
1353  if (miny > Int::Limits::min && maxy < Int::Limits::max) {
1354  cumulative(s,maxdy+maxy-miny,x0,iw,ih);
1355  cumulative(s,maxdx+maxx-minx,y0,ih,iw);
1356  }
1357  } else {
1358  IntVarArgs x1(x0.size()), y1(y0.size());
1359  for (int i=x0.size(); i--; )
1360  x1[i] = expr(s, x0[i] + w[i]);
1361  for (int i=y0.size(); i--; )
1362  y1[i] = expr(s, y0[i] + h[i]);
1363  nooverlap(s,x0,w,x1,y0,h,y1,s.ann2ipl(ann));
1364  }
1365  }
1366 
1367  void p_precede(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1368  IntVarArgs x = s.arg2intvarargs(ce[0]);
1369  int p_s = ce[1]->getInt();
1370  int p_t = ce[2]->getInt();
1371  precede(s,x,p_s,p_t,s.ann2ipl(ann));
1372  }
1373 
1374  void p_nvalue(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1375  IntVarArgs x = s.arg2intvarargs(ce[1]);
1376  if (ce[0]->isIntVar()) {
1377  IntVar y = s.arg2IntVar(ce[0]);
1378  nvalues(s,x,IRT_EQ,y,s.ann2ipl(ann));
1379  } else {
1380  nvalues(s,x,IRT_EQ,ce[0]->getInt(),s.ann2ipl(ann));
1381  }
1382  }
1383 
1384  void p_among(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1385  IntVarArgs x = s.arg2intvarargs(ce[1]);
1386  IntSet v = s.arg2intset(ce[2]);
1387  if (ce[0]->isIntVar()) {
1388  IntVar n = s.arg2IntVar(ce[0]);
1389  unshare(s, x);
1390  count(s,x,v,IRT_EQ,n,s.ann2ipl(ann));
1391  } else {
1392  unshare(s, x);
1393  count(s,x,v,IRT_EQ,ce[0]->getInt(),s.ann2ipl(ann));
1394  }
1395  }
1396 
1397  void p_member_int(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1398  IntVarArgs x = s.arg2intvarargs(ce[0]);
1399  IntVar y = s.arg2IntVar(ce[1]);
1400  member(s,x,y,s.ann2ipl(ann));
1401  }
1402  void p_member_int_reif(FlatZincSpace& s, const ConExpr& ce,
1403  AST::Node* ann) {
1404  IntVarArgs x = s.arg2intvarargs(ce[0]);
1405  IntVar y = s.arg2IntVar(ce[1]);
1406  BoolVar b = s.arg2BoolVar(ce[2]);
1407  member(s,x,y,b,s.ann2ipl(ann));
1408  }
1409  void p_member_bool(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1410  BoolVarArgs x = s.arg2boolvarargs(ce[0]);
1411  BoolVar y = s.arg2BoolVar(ce[1]);
1412  member(s,x,y,s.ann2ipl(ann));
1413  }
1414  void p_member_bool_reif(FlatZincSpace& s, const ConExpr& ce,
1415  AST::Node* ann) {
1416  BoolVarArgs x = s.arg2boolvarargs(ce[0]);
1417  BoolVar y = s.arg2BoolVar(ce[1]);
1418  member(s,x,y,s.arg2BoolVar(ce[2]),s.ann2ipl(ann));
1419  }
1420 
1421  class IntPoster {
1422  public:
1423  IntPoster(void) {
1424  registry().add("all_different_int", &p_distinct);
1425  registry().add("all_different_offset", &p_distinctOffset);
1426  registry().add("all_equal_int", &p_all_equal);
1427  registry().add("int_eq", &p_int_eq);
1428  registry().add("int_ne", &p_int_ne);
1429  registry().add("int_ge", &p_int_ge);
1430  registry().add("int_gt", &p_int_gt);
1431  registry().add("int_le", &p_int_le);
1432  registry().add("int_lt", &p_int_lt);
1433  registry().add("int_eq_reif", &p_int_eq_reif);
1434  registry().add("int_ne_reif", &p_int_ne_reif);
1435  registry().add("int_ge_reif", &p_int_ge_reif);
1436  registry().add("int_gt_reif", &p_int_gt_reif);
1437  registry().add("int_le_reif", &p_int_le_reif);
1438  registry().add("int_lt_reif", &p_int_lt_reif);
1439  registry().add("int_eq_imp", &p_int_eq_imp);
1440  registry().add("int_ne_imp", &p_int_ne_imp);
1441  registry().add("int_ge_imp", &p_int_ge_imp);
1442  registry().add("int_gt_imp", &p_int_gt_imp);
1443  registry().add("int_le_imp", &p_int_le_imp);
1444  registry().add("int_lt_imp", &p_int_lt_imp);
1445  registry().add("int_lin_eq", &p_int_lin_eq);
1446  registry().add("int_lin_eq_reif", &p_int_lin_eq_reif);
1447  registry().add("int_lin_eq_imp", &p_int_lin_eq_imp);
1448  registry().add("int_lin_ne", &p_int_lin_ne);
1449  registry().add("int_lin_ne_reif", &p_int_lin_ne_reif);
1450  registry().add("int_lin_ne_imp", &p_int_lin_ne_imp);
1451  registry().add("int_lin_le", &p_int_lin_le);
1452  registry().add("int_lin_le_reif", &p_int_lin_le_reif);
1453  registry().add("int_lin_le_imp", &p_int_lin_le_imp);
1454  registry().add("int_lin_lt", &p_int_lin_lt);
1455  registry().add("int_lin_lt_reif", &p_int_lin_lt_reif);
1456  registry().add("int_lin_lt_imp", &p_int_lin_lt_imp);
1457  registry().add("int_lin_ge", &p_int_lin_ge);
1458  registry().add("int_lin_ge_reif", &p_int_lin_ge_reif);
1459  registry().add("int_lin_ge_imp", &p_int_lin_ge_imp);
1460  registry().add("int_lin_gt", &p_int_lin_gt);
1461  registry().add("int_lin_gt_reif", &p_int_lin_gt_reif);
1462  registry().add("int_lin_gt_imp", &p_int_lin_gt_imp);
1463  registry().add("int_plus", &p_int_plus);
1464  registry().add("int_minus", &p_int_minus);
1465  registry().add("int_times", &p_int_times);
1466  registry().add("gecode_int_pow", &p_int_pow);
1467  registry().add("int_div", &p_int_div);
1468  registry().add("int_mod", &p_int_mod);
1469  registry().add("int_min", &p_int_min);
1470  registry().add("int_max", &p_int_max);
1471  registry().add("int_abs", &p_abs);
1472  registry().add("int_negate", &p_int_negate);
1473  registry().add("bool_eq", &p_bool_eq);
1474  registry().add("bool_eq_reif", &p_bool_eq_reif);
1475  registry().add("bool_eq_imp", &p_bool_eq_imp);
1476  registry().add("bool_ne", &p_bool_ne);
1477  registry().add("bool_ne_reif", &p_bool_ne_reif);
1478  registry().add("bool_ne_imp", &p_bool_ne_imp);
1479  registry().add("bool_ge", &p_bool_ge);
1480  registry().add("bool_ge_reif", &p_bool_ge_reif);
1481  registry().add("bool_ge_imp", &p_bool_ge_imp);
1482  registry().add("bool_le", &p_bool_le);
1483  registry().add("bool_le_reif", &p_bool_le_reif);
1484  registry().add("bool_le_imp", &p_bool_le_imp);
1485  registry().add("bool_gt", &p_bool_gt);
1486  registry().add("bool_gt_reif", &p_bool_gt_reif);
1487  registry().add("bool_gt_imp", &p_bool_gt_imp);
1488  registry().add("bool_lt", &p_bool_lt);
1489  registry().add("bool_lt_reif", &p_bool_lt_reif);
1490  registry().add("bool_lt_imp", &p_bool_lt_imp);
1491  registry().add("bool_or", &p_bool_or);
1492  registry().add("bool_or_imp", &p_bool_or_imp);
1493  registry().add("bool_and", &p_bool_and);
1494  registry().add("bool_and_imp", &p_bool_and_imp);
1495  registry().add("bool_xor", &p_bool_xor);
1496  registry().add("bool_xor_imp", &p_bool_xor_imp);
1497  registry().add("array_bool_and", &p_array_bool_and);
1498  registry().add("array_bool_and_imp", &p_array_bool_and_imp);
1499  registry().add("array_bool_or", &p_array_bool_or);
1500  registry().add("array_bool_or_imp", &p_array_bool_or_imp);
1501  registry().add("array_bool_xor", &p_array_bool_xor);
1502  registry().add("array_bool_xor_imp", &p_array_bool_xor_imp);
1503  registry().add("bool_clause", &p_array_bool_clause);
1504  registry().add("bool_clause_reif", &p_array_bool_clause_reif);
1505  registry().add("bool_clause_imp", &p_array_bool_clause_imp);
1506  registry().add("bool_left_imp", &p_bool_l_imp);
1507  registry().add("bool_right_imp", &p_bool_r_imp);
1508  registry().add("bool_not", &p_bool_not);
1509  registry().add("array_int_element", &p_array_int_element);
1510  registry().add("array_var_int_element", &p_array_int_element);
1511  registry().add("array_bool_element", &p_array_bool_element);
1512  registry().add("array_var_bool_element", &p_array_bool_element);
1513  registry().add("bool2int", &p_bool2int);
1514  registry().add("int_in", &p_int_in);
1515  registry().add("int_in_reif", &p_int_in_reif);
1516  registry().add("int_in_imp", &p_int_in_imp);
1517 #ifndef GECODE_HAS_SET_VARS
1518  registry().add("set_in", &p_int_in);
1519  registry().add("set_in_reif", &p_int_in_reif);
1520  registry().add("set_in_imp", &p_int_in_imp);
1521 #endif
1522 
1523  registry().add("array_int_lt", &p_array_int_lt);
1524  registry().add("array_int_lq", &p_array_int_lq);
1525  registry().add("array_bool_lt", &p_array_bool_lt);
1526  registry().add("array_bool_lq", &p_array_bool_lq);
1527  registry().add("count", &p_count);
1528  registry().add("count_reif", &p_count_reif);
1529  registry().add("count_imp", &p_count_imp);
1530  registry().add("at_least_int", &p_at_least);
1531  registry().add("at_most_int", &p_at_most);
1532  registry().add("gecode_bin_packing_load", &p_bin_packing_load);
1533  registry().add("gecode_global_cardinality", &p_global_cardinality);
1534  registry().add("gecode_global_cardinality_closed",
1535  &p_global_cardinality_closed);
1536  registry().add("global_cardinality_low_up",
1537  &p_global_cardinality_low_up);
1538  registry().add("global_cardinality_low_up_closed",
1539  &p_global_cardinality_low_up_closed);
1540  registry().add("array_int_minimum", &p_minimum);
1541  registry().add("array_int_maximum", &p_maximum);
1542  registry().add("gecode_minimum_arg_int", &p_minimum_arg);
1543  registry().add("gecode_maximum_arg_int", &p_maximum_arg);
1544  registry().add("array_int_maximum", &p_maximum);
1545  registry().add("gecode_regular", &p_regular);
1546  registry().add("sort", &p_sort);
1547  registry().add("inverse_offsets", &p_inverse_offsets);
1548  registry().add("increasing_int", &p_increasing_int);
1549  registry().add("increasing_bool", &p_increasing_bool);
1550  registry().add("decreasing_int", &p_decreasing_int);
1551  registry().add("decreasing_bool", &p_decreasing_bool);
1552  registry().add("gecode_table_int", &p_table_int);
1553  registry().add("gecode_table_bool", &p_table_bool);
1554  registry().add("cumulatives", &p_cumulatives);
1555  registry().add("gecode_among_seq_int", &p_among_seq_int);
1556  registry().add("gecode_among_seq_bool", &p_among_seq_bool);
1557 
1558  registry().add("bool_lin_eq", &p_bool_lin_eq);
1559  registry().add("bool_lin_ne", &p_bool_lin_ne);
1560  registry().add("bool_lin_le", &p_bool_lin_le);
1561  registry().add("bool_lin_lt", &p_bool_lin_lt);
1562  registry().add("bool_lin_ge", &p_bool_lin_ge);
1563  registry().add("bool_lin_gt", &p_bool_lin_gt);
1564 
1565  registry().add("bool_lin_eq_reif", &p_bool_lin_eq_reif);
1566  registry().add("bool_lin_eq_imp", &p_bool_lin_eq_imp);
1567  registry().add("bool_lin_ne_reif", &p_bool_lin_ne_reif);
1568  registry().add("bool_lin_ne_imp", &p_bool_lin_ne_imp);
1569  registry().add("bool_lin_le_reif", &p_bool_lin_le_reif);
1570  registry().add("bool_lin_le_imp", &p_bool_lin_le_imp);
1571  registry().add("bool_lin_lt_reif", &p_bool_lin_lt_reif);
1572  registry().add("bool_lin_lt_imp", &p_bool_lin_lt_imp);
1573  registry().add("bool_lin_ge_reif", &p_bool_lin_ge_reif);
1574  registry().add("bool_lin_ge_imp", &p_bool_lin_ge_imp);
1575  registry().add("bool_lin_gt_reif", &p_bool_lin_gt_reif);
1576  registry().add("bool_lin_gt_imp", &p_bool_lin_gt_imp);
1577 
1578  registry().add("gecode_schedule_unary", &p_schedule_unary);
1579  registry().add("gecode_schedule_unary_optional", &p_schedule_unary_optional);
1580  registry().add("gecode_schedule_cumulative_optional", &p_cumulative_opt);
1581 
1582  registry().add("gecode_circuit", &p_circuit);
1583  registry().add("gecode_circuit_cost_array", &p_circuit_cost_array);
1584  registry().add("gecode_circuit_cost", &p_circuit_cost);
1585  registry().add("gecode_nooverlap", &p_nooverlap);
1586  registry().add("gecode_precede", &p_precede);
1587  registry().add("nvalue",&p_nvalue);
1588  registry().add("among",&p_among);
1589  registry().add("member_int",&p_member_int);
1590  registry().add("gecode_member_int_reif",&p_member_int_reif);
1591  registry().add("member_bool",&p_member_bool);
1592  registry().add("gecode_member_bool_reif",&p_member_bool_reif);
1593  }
1594  };
1595  IntPoster __int_poster;
1596 
1597 #ifdef GECODE_HAS_SET_VARS
1598  void p_set_OP(FlatZincSpace& s, SetOpType op,
1599  const ConExpr& ce, AST::Node *) {
1600  rel(s, s.arg2SetVar(ce[0]), op, s.arg2SetVar(ce[1]),
1601  SRT_EQ, s.arg2SetVar(ce[2]));
1602  }
1603  void p_set_union(FlatZincSpace& s, const ConExpr& ce, AST::Node *ann) {
1604  p_set_OP(s, SOT_UNION, ce, ann);
1605  }
1606  void p_set_intersect(FlatZincSpace& s, const ConExpr& ce, AST::Node *ann) {
1607  p_set_OP(s, SOT_INTER, ce, ann);
1608  }
1609  void p_set_diff(FlatZincSpace& s, const ConExpr& ce, AST::Node *ann) {
1610  p_set_OP(s, SOT_MINUS, ce, ann);
1611  }
1612 
1613  void p_set_symdiff(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
1614  SetVar x = s.arg2SetVar(ce[0]);
1615  SetVar y = s.arg2SetVar(ce[1]);
1616 
1617  SetVarLubRanges xub(x);
1618  IntSet xubs(xub);
1619  SetVar x_y(s,IntSet::empty,xubs);
1620  rel(s, x, SOT_MINUS, y, SRT_EQ, x_y);
1621 
1622  SetVarLubRanges yub(y);
1623  IntSet yubs(yub);
1624  SetVar y_x(s,IntSet::empty,yubs);
1625  rel(s, y, SOT_MINUS, x, SRT_EQ, y_x);
1626 
1627  rel(s, x_y, SOT_UNION, y_x, SRT_EQ, s.arg2SetVar(ce[2]));
1628  }
1629 
1630  void p_array_set_OP(FlatZincSpace& s, SetOpType op,
1631  const ConExpr& ce, AST::Node *) {
1632  SetVarArgs xs = s.arg2setvarargs(ce[0]);
1633  rel(s, op, xs, s.arg2SetVar(ce[1]));
1634  }
1635  void p_array_set_union(FlatZincSpace& s, const ConExpr& ce, AST::Node *ann) {
1636  p_array_set_OP(s, SOT_UNION, ce, ann);
1637  }
1638  void p_array_set_partition(FlatZincSpace& s, const ConExpr& ce, AST::Node *ann) {
1639  p_array_set_OP(s, SOT_DUNION, ce, ann);
1640  }
1641 
1642 
1643  void p_set_rel(FlatZincSpace& s, SetRelType srt, const ConExpr& ce) {
1644  rel(s, s.arg2SetVar(ce[0]), srt, s.arg2SetVar(ce[1]));
1645  }
1646 
1647  void p_set_eq(FlatZincSpace& s, const ConExpr& ce, AST::Node *) {
1648  p_set_rel(s, SRT_EQ, ce);
1649  }
1650  void p_set_ne(FlatZincSpace& s, const ConExpr& ce, AST::Node *) {
1651  p_set_rel(s, SRT_NQ, ce);
1652  }
1653  void p_set_subset(FlatZincSpace& s, const ConExpr& ce, AST::Node *) {
1654  p_set_rel(s, SRT_SUB, ce);
1655  }
1656  void p_set_superset(FlatZincSpace& s, const ConExpr& ce, AST::Node *) {
1657  p_set_rel(s, SRT_SUP, ce);
1658  }
1659  void p_set_le(FlatZincSpace& s, const ConExpr& ce, AST::Node *) {
1660  p_set_rel(s, SRT_LQ, ce);
1661  }
1662  void p_set_lt(FlatZincSpace& s, const ConExpr& ce, AST::Node *) {
1663  p_set_rel(s, SRT_LE, ce);
1664  }
1665  void p_set_card(FlatZincSpace& s, const ConExpr& ce, AST::Node *) {
1666  if (!ce[1]->isIntVar()) {
1667  cardinality(s, s.arg2SetVar(ce[0]), ce[1]->getInt(),
1668  ce[1]->getInt());
1669  } else {
1670  cardinality(s, s.arg2SetVar(ce[0]), s.arg2IntVar(ce[1]));
1671  }
1672  }
1673  void p_set_in(FlatZincSpace& s, const ConExpr& ce, AST::Node *) {
1674  if (!ce[1]->isSetVar()) {
1675  IntSet d = s.arg2intset(ce[1]);
1676  if (ce[0]->isBoolVar()) {
1677  IntSetRanges dr(d);
1678  Iter::Ranges::Singleton sr(0,1);
1679  Iter::Ranges::Inter<IntSetRanges,Iter::Ranges::Singleton> i(dr,sr);
1680  IntSet d01(i);
1681  if (d01.size() == 0) {
1682  s.fail();
1683  } else {
1684  rel(s, s.arg2BoolVar(ce[0]), IRT_GQ, d01.min());
1685  rel(s, s.arg2BoolVar(ce[0]), IRT_LQ, d01.max());
1686  }
1687  } else {
1688  dom(s, s.arg2IntVar(ce[0]), d);
1689  }
1690  } else {
1691  if (!ce[0]->isIntVar()) {
1692  dom(s, s.arg2SetVar(ce[1]), SRT_SUP, ce[0]->getInt());
1693  } else {
1694  rel(s, s.arg2SetVar(ce[1]), SRT_SUP, s.arg2IntVar(ce[0]));
1695  }
1696  }
1697  }
1698  void p_set_rel_reif(FlatZincSpace& s, SetRelType srt, const ConExpr& ce) {
1699  rel(s, s.arg2SetVar(ce[0]), srt, s.arg2SetVar(ce[1]),
1700  s.arg2BoolVar(ce[2]));
1701  }
1702 
1703  void p_set_eq_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node *) {
1704  p_set_rel_reif(s,SRT_EQ,ce);
1705  }
1706  void p_set_le_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node *) {
1707  p_set_rel_reif(s,SRT_LQ,ce);
1708  }
1709  void p_set_lt_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node *) {
1710  p_set_rel_reif(s,SRT_LE,ce);
1711  }
1712  void p_set_ne_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node *) {
1713  p_set_rel_reif(s,SRT_NQ,ce);
1714  }
1715  void p_set_subset_reif(FlatZincSpace& s, const ConExpr& ce,
1716  AST::Node *) {
1717  p_set_rel_reif(s,SRT_SUB,ce);
1718  }
1719  void p_set_superset_reif(FlatZincSpace& s, const ConExpr& ce,
1720  AST::Node *) {
1721  p_set_rel_reif(s,SRT_SUP,ce);
1722  }
1723  void p_set_in_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann, ReifyMode rm) {
1724  if (!ce[1]->isSetVar()) {
1725  if (rm==RM_EQV) {
1726  p_int_in_reif(s,ce,ann);
1727  } else {
1728  assert(rm==RM_IMP);
1729  p_int_in_imp(s,ce,ann);
1730  }
1731  } else {
1732  if (!ce[0]->isIntVar()) {
1733  dom(s, s.arg2SetVar(ce[1]), SRT_SUP, ce[0]->getInt(),
1734  Reify(s.arg2BoolVar(ce[2]),rm));
1735  } else {
1736  rel(s, s.arg2SetVar(ce[1]), SRT_SUP, s.arg2IntVar(ce[0]),
1737  Reify(s.arg2BoolVar(ce[2]),rm));
1738  }
1739  }
1740  }
1741  void p_set_in_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1742  p_set_in_reif(s,ce,ann,RM_EQV);
1743  }
1744  void p_set_in_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1745  p_set_in_reif(s,ce,ann,RM_IMP);
1746  }
1747  void p_set_disjoint(FlatZincSpace& s, const ConExpr& ce, AST::Node *) {
1748  rel(s, s.arg2SetVar(ce[0]), SRT_DISJ, s.arg2SetVar(ce[1]));
1749  }
1750 
1751  void p_link_set_to_booleans(FlatZincSpace& s, const ConExpr& ce,
1752  AST::Node *) {
1753  SetVar x = s.arg2SetVar(ce[0]);
1754  int idx = ce[2]->getInt();
1755  assert(idx >= 0);
1756  rel(s, x || IntSet(Set::Limits::min,idx-1));
1757  BoolVarArgs y = s.arg2boolvarargs(ce[1],idx);
1758  unshare(s, y);
1759  channel(s, y, x);
1760  }
1761 
1762  void p_array_set_element(FlatZincSpace& s, const ConExpr& ce,
1763  AST::Node*) {
1764  bool isConstant = true;
1765  AST::Array* a = ce[1]->getArray();
1766  for (int i=a->a.size(); i--;) {
1767  if (a->a[i]->isSetVar()) {
1768  isConstant = false;
1769  break;
1770  }
1771  }
1772  IntVar selector = s.arg2IntVar(ce[0]);
1773  rel(s, selector > 0);
1774  if (isConstant) {
1775  IntSetArgs sv = s.arg2intsetargs(ce[1],1);
1776  element(s, sv, selector, s.arg2SetVar(ce[2]));
1777  } else {
1778  SetVarArgs sv = s.arg2setvarargs(ce[1], 1);
1779  element(s, sv, selector, s.arg2SetVar(ce[2]));
1780  }
1781  }
1782 
1783  void p_array_set_element_op(FlatZincSpace& s, const ConExpr& ce,
1784  AST::Node*, SetOpType op,
1785  const IntSet& universe =
1787  bool isConstant = true;
1788  AST::Array* a = ce[1]->getArray();
1789  for (int i=a->a.size(); i--;) {
1790  if (a->a[i]->isSetVar()) {
1791  isConstant = false;
1792  break;
1793  }
1794  }
1795  SetVar selector = s.arg2SetVar(ce[0]);
1796  dom(s, selector, SRT_DISJ, 0);
1797  if (isConstant) {
1798  IntSetArgs sv = s.arg2intsetargs(ce[1], 1);
1799  element(s, op, sv, selector, s.arg2SetVar(ce[2]), universe);
1800  } else {
1801  SetVarArgs sv = s.arg2setvarargs(ce[1], 1);
1802  element(s, op, sv, selector, s.arg2SetVar(ce[2]), universe);
1803  }
1804  }
1805 
1806  void p_array_set_element_union(FlatZincSpace& s, const ConExpr& ce,
1807  AST::Node* ann) {
1808  p_array_set_element_op(s, ce, ann, SOT_UNION);
1809  }
1810 
1811  void p_array_set_element_intersect(FlatZincSpace& s, const ConExpr& ce,
1812  AST::Node* ann) {
1813  p_array_set_element_op(s, ce, ann, SOT_INTER);
1814  }
1815 
1816  void p_array_set_element_intersect_in(FlatZincSpace& s,
1817  const ConExpr& ce,
1818  AST::Node* ann) {
1819  IntSet d = s.arg2intset(ce[3]);
1820  p_array_set_element_op(s, ce, ann, SOT_INTER, d);
1821  }
1822 
1823  void p_array_set_element_partition(FlatZincSpace& s, const ConExpr& ce,
1824  AST::Node* ann) {
1825  p_array_set_element_op(s, ce, ann, SOT_DUNION);
1826  }
1827 
1828  void p_set_convex(FlatZincSpace& s, const ConExpr& ce, AST::Node *) {
1829  convex(s, s.arg2SetVar(ce[0]));
1830  }
1831 
1832  void p_array_set_seq(FlatZincSpace& s, const ConExpr& ce, AST::Node *) {
1833  SetVarArgs sv = s.arg2setvarargs(ce[0]);
1834  sequence(s, sv);
1835  }
1836 
1837  void p_array_set_seq_union(FlatZincSpace& s, const ConExpr& ce,
1838  AST::Node *) {
1839  SetVarArgs sv = s.arg2setvarargs(ce[0]);
1840  sequence(s, sv, s.arg2SetVar(ce[1]));
1841  }
1842 
1843  void p_int_set_channel(FlatZincSpace& s, const ConExpr& ce,
1844  AST::Node *) {
1845  int xoff=ce[1]->getInt();
1846  assert(xoff >= 0);
1847  int yoff=ce[3]->getInt();
1848  assert(yoff >= 0);
1849  IntVarArgs xv = s.arg2intvarargs(ce[0], xoff);
1850  SetVarArgs yv = s.arg2setvarargs(ce[2], yoff, 1, IntSet(0, xoff-1));
1851  IntSet xd(yoff,yv.size()-1);
1852  for (int i=xoff; i<xv.size(); i++) {
1853  dom(s, xv[i], xd);
1854  }
1855  IntSet yd(xoff,xv.size()-1);
1856  for (int i=yoff; i<yv.size(); i++) {
1857  dom(s, yv[i], SRT_SUB, yd);
1858  }
1859  channel(s,xv,yv);
1860  }
1861 
1862  void p_range(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
1863  int xoff=ce[1]->getInt();
1864  assert(xoff >= 0);
1865  IntVarArgs xv = s.arg2intvarargs(ce[0],xoff);
1866  element(s, SOT_UNION, xv, s.arg2SetVar(ce[2]), s.arg2SetVar(ce[3]));
1867  }
1868 
1869  void p_weights(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
1870  IntArgs e = s.arg2intargs(ce[0]);
1871  IntArgs w = s.arg2intargs(ce[1]);
1872  SetVar x = s.arg2SetVar(ce[2]);
1873  IntVar y = s.arg2IntVar(ce[3]);
1874  weights(s,e,w,x,y);
1875  }
1876 
1877  void p_inverse_set(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
1878  int xoff = ce[2]->getInt();
1879  int yoff = ce[3]->getInt();
1880  SetVarArgs x = s.arg2setvarargs(ce[0],xoff);
1881  SetVarArgs y = s.arg2setvarargs(ce[1],yoff);
1882  channel(s, x, y);
1883  }
1884 
1885  void p_precede_set(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
1886  SetVarArgs x = s.arg2setvarargs(ce[0]);
1887  int p_s = ce[1]->getInt();
1888  int p_t = ce[2]->getInt();
1889  precede(s,x,p_s,p_t);
1890  }
1891 
1892  class SetPoster {
1893  public:
1894  SetPoster(void) {
1895  registry().add("set_eq", &p_set_eq);
1896  registry().add("set_le", &p_set_le);
1897  registry().add("set_lt", &p_set_lt);
1898  registry().add("equal", &p_set_eq);
1899  registry().add("set_ne", &p_set_ne);
1900  registry().add("set_union", &p_set_union);
1901  registry().add("array_set_element", &p_array_set_element);
1902  registry().add("array_var_set_element", &p_array_set_element);
1903  registry().add("set_intersect", &p_set_intersect);
1904  registry().add("set_diff", &p_set_diff);
1905  registry().add("set_symdiff", &p_set_symdiff);
1906  registry().add("set_subset", &p_set_subset);
1907  registry().add("set_superset", &p_set_superset);
1908  registry().add("set_card", &p_set_card);
1909  registry().add("set_in", &p_set_in);
1910  registry().add("set_eq_reif", &p_set_eq_reif);
1911  registry().add("set_le_reif", &p_set_le_reif);
1912  registry().add("set_lt_reif", &p_set_lt_reif);
1913  registry().add("equal_reif", &p_set_eq_reif);
1914  registry().add("set_ne_reif", &p_set_ne_reif);
1915  registry().add("set_subset_reif", &p_set_subset_reif);
1916  registry().add("set_superset_reif", &p_set_superset_reif);
1917  registry().add("set_in_reif", &p_set_in_reif);
1918  registry().add("set_in_imp", &p_set_in_imp);
1919  registry().add("disjoint", &p_set_disjoint);
1920  registry().add("gecode_link_set_to_booleans",
1921  &p_link_set_to_booleans);
1922 
1923  registry().add("array_set_union", &p_array_set_union);
1924  registry().add("array_set_partition", &p_array_set_partition);
1925  registry().add("set_convex", &p_set_convex);
1926  registry().add("array_set_seq", &p_array_set_seq);
1927  registry().add("array_set_seq_union", &p_array_set_seq_union);
1928  registry().add("gecode_array_set_element_union",
1929  &p_array_set_element_union);
1930  registry().add("gecode_array_set_element_intersect",
1931  &p_array_set_element_intersect);
1932  registry().add("gecode_array_set_element_intersect_in",
1933  &p_array_set_element_intersect_in);
1934  registry().add("gecode_array_set_element_partition",
1935  &p_array_set_element_partition);
1936  registry().add("gecode_int_set_channel",
1937  &p_int_set_channel);
1938  registry().add("gecode_range",
1939  &p_range);
1940  registry().add("gecode_set_weights",
1941  &p_weights);
1942  registry().add("gecode_inverse_set", &p_inverse_set);
1943  registry().add("gecode_precede_set", &p_precede_set);
1944  }
1945  };
1946  SetPoster __set_poster;
1947 #endif
1948 
1949 #ifdef GECODE_HAS_FLOAT_VARS
1950 
1951  void p_int2float(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
1952  IntVar x0 = s.arg2IntVar(ce[0]);
1953  FloatVar x1 = s.arg2FloatVar(ce[1]);
1954  channel(s, x0, x1);
1955  }
1956 
1957  void p_float_lin_cmp(FlatZincSpace& s, FloatRelType frt,
1958  const ConExpr& ce, AST::Node*) {
1959  FloatValArgs fa = s.arg2floatargs(ce[0]);
1960  FloatVarArgs fv = s.arg2floatvarargs(ce[1]);
1961  linear(s, fa, fv, frt, ce[2]->getFloat());
1962  }
1963  void p_float_lin_cmp_reif(FlatZincSpace& s, FloatRelType frt,
1964  const ConExpr& ce, AST::Node*) {
1965  FloatValArgs fa = s.arg2floatargs(ce[0]);
1966  FloatVarArgs fv = s.arg2floatvarargs(ce[1]);
1967  linear(s, fa, fv, frt, ce[2]->getFloat(), s.arg2BoolVar(ce[3]));
1968  }
1969  void p_float_lin_eq(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1970  p_float_lin_cmp(s,FRT_EQ,ce,ann);
1971  }
1972  void p_float_lin_eq_reif(FlatZincSpace& s, const ConExpr& ce,
1973  AST::Node* ann) {
1974  p_float_lin_cmp_reif(s,FRT_EQ,ce,ann);
1975  }
1976  void p_float_lin_le(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1977  p_float_lin_cmp(s,FRT_LQ,ce,ann);
1978  }
1979  void p_float_lin_lt(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1980  p_float_lin_cmp(s,FRT_LE,ce,ann);
1981  }
1982  void p_float_lin_le_reif(FlatZincSpace& s, const ConExpr& ce,
1983  AST::Node* ann) {
1984  p_float_lin_cmp_reif(s,FRT_LQ,ce,ann);
1985  }
1986  void p_float_lin_lt_reif(FlatZincSpace& s, const ConExpr& ce,
1987  AST::Node* ann) {
1988  p_float_lin_cmp_reif(s,FRT_LE,ce,ann);
1989  }
1990 
1991  void p_float_times(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
1992  FloatVar x = s.arg2FloatVar(ce[0]);
1993  FloatVar y = s.arg2FloatVar(ce[1]);
1994  FloatVar z = s.arg2FloatVar(ce[2]);
1995  mult(s,x,y,z);
1996  }
1997 
1998  void p_float_div(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
1999  FloatVar x = s.arg2FloatVar(ce[0]);
2000  FloatVar y = s.arg2FloatVar(ce[1]);
2001  FloatVar z = s.arg2FloatVar(ce[2]);
2002  div(s,x,y,z);
2003  }
2004 
2005  void p_float_plus(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
2006  FloatVar x = s.arg2FloatVar(ce[0]);
2007  FloatVar y = s.arg2FloatVar(ce[1]);
2008  FloatVar z = s.arg2FloatVar(ce[2]);
2009  rel(s,x+y==z);
2010  }
2011 
2012  void p_float_sqrt(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
2013  FloatVar x = s.arg2FloatVar(ce[0]);
2014  FloatVar y = s.arg2FloatVar(ce[1]);
2015  sqrt(s,x,y);
2016  }
2017 
2018  void p_float_abs(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
2019  FloatVar x = s.arg2FloatVar(ce[0]);
2020  FloatVar y = s.arg2FloatVar(ce[1]);
2021  abs(s,x,y);
2022  }
2023 
2024  void p_float_eq(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
2025  FloatVar x = s.arg2FloatVar(ce[0]);
2026  FloatVar y = s.arg2FloatVar(ce[1]);
2027  rel(s,x,FRT_EQ,y);
2028  }
2029  void p_float_eq_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
2030  FloatVar x = s.arg2FloatVar(ce[0]);
2031  FloatVar y = s.arg2FloatVar(ce[1]);
2032  BoolVar b = s.arg2BoolVar(ce[2]);
2033  rel(s,x,FRT_EQ,y,b);
2034  }
2035  void p_float_le(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
2036  FloatVar x = s.arg2FloatVar(ce[0]);
2037  FloatVar y = s.arg2FloatVar(ce[1]);
2038  rel(s,x,FRT_LQ,y);
2039  }
2040  void p_float_le_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
2041  FloatVar x = s.arg2FloatVar(ce[0]);
2042  FloatVar y = s.arg2FloatVar(ce[1]);
2043  BoolVar b = s.arg2BoolVar(ce[2]);
2044  rel(s,x,FRT_LQ,y,b);
2045  }
2046  void p_float_max(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
2047  FloatVar x = s.arg2FloatVar(ce[0]);
2048  FloatVar y = s.arg2FloatVar(ce[1]);
2049  FloatVar z = s.arg2FloatVar(ce[2]);
2050  max(s,x,y,z);
2051  }
2052  void p_float_min(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
2053  FloatVar x = s.arg2FloatVar(ce[0]);
2054  FloatVar y = s.arg2FloatVar(ce[1]);
2055  FloatVar z = s.arg2FloatVar(ce[2]);
2056  min(s,x,y,z);
2057  }
2058  void p_float_lt(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
2059  FloatVar x = s.arg2FloatVar(ce[0]);
2060  FloatVar y = s.arg2FloatVar(ce[1]);
2061  rel(s, x, FRT_LQ, y);
2062  rel(s, x, FRT_EQ, y, BoolVar(s,0,0));
2063  }
2064 
2065  void p_float_lt_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
2066  FloatVar x = s.arg2FloatVar(ce[0]);
2067  FloatVar y = s.arg2FloatVar(ce[1]);
2068  BoolVar b = s.arg2BoolVar(ce[2]);
2069  BoolVar b0(s,0,1);
2070  BoolVar b1(s,0,1);
2071  rel(s, b == (b0 && !b1));
2072  rel(s, x, FRT_LQ, y, b0);
2073  rel(s, x, FRT_EQ, y, b1);
2074  }
2075 
2076  void p_float_ne(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
2077  FloatVar x = s.arg2FloatVar(ce[0]);
2078  FloatVar y = s.arg2FloatVar(ce[1]);
2079  rel(s, x, FRT_EQ, y, BoolVar(s,0,0));
2080  }
2081 
2082 #ifdef GECODE_HAS_MPFR
2083 #define P_FLOAT_OP(Op) \
2084  void p_float_ ## Op (FlatZincSpace& s, const ConExpr& ce, AST::Node*) {\
2085  FloatVar x = s.arg2FloatVar(ce[0]);\
2086  FloatVar y = s.arg2FloatVar(ce[1]);\
2087  Op(s,x,y);\
2088  }
2089  P_FLOAT_OP(acos)
2090  P_FLOAT_OP(asin)
2091  P_FLOAT_OP(atan)
2092  P_FLOAT_OP(cos)
2093  P_FLOAT_OP(exp)
2094  P_FLOAT_OP(sin)
2095  P_FLOAT_OP(tan)
2096  // P_FLOAT_OP(sinh)
2097  // P_FLOAT_OP(tanh)
2098  // P_FLOAT_OP(cosh)
2099 #undef P_FLOAT_OP
2100 
2101  void p_float_ln(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
2102  FloatVar x = s.arg2FloatVar(ce[0]);
2103  FloatVar y = s.arg2FloatVar(ce[1]);
2104  log(s,x,y);
2105  }
2106  void p_float_log10(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
2107  FloatVar x = s.arg2FloatVar(ce[0]);
2108  FloatVar y = s.arg2FloatVar(ce[1]);
2109  log(s,10.0,x,y);
2110  }
2111  void p_float_log2(FlatZincSpace& s, const ConExpr& ce, AST::Node*) {
2112  FloatVar x = s.arg2FloatVar(ce[0]);
2113  FloatVar y = s.arg2FloatVar(ce[1]);
2114  log(s,2.0,x,y);
2115  }
2116 
2117 #endif
2118 
2119  class FloatPoster {
2120  public:
2121  FloatPoster(void) {
2122  registry().add("int2float",&p_int2float);
2123  registry().add("float_abs",&p_float_abs);
2124  registry().add("float_sqrt",&p_float_sqrt);
2125  registry().add("float_eq",&p_float_eq);
2126  registry().add("float_eq_reif",&p_float_eq_reif);
2127  registry().add("float_le",&p_float_le);
2128  registry().add("float_le_reif",&p_float_le_reif);
2129  registry().add("float_lt",&p_float_lt);
2130  registry().add("float_lt_reif",&p_float_lt_reif);
2131  registry().add("float_ne",&p_float_ne);
2132  registry().add("float_times",&p_float_times);
2133  registry().add("float_div",&p_float_div);
2134  registry().add("float_plus",&p_float_plus);
2135  registry().add("float_max",&p_float_max);
2136  registry().add("float_min",&p_float_min);
2137 
2138  registry().add("float_lin_eq",&p_float_lin_eq);
2139  registry().add("float_lin_eq_reif",&p_float_lin_eq_reif);
2140  registry().add("float_lin_le",&p_float_lin_le);
2141  registry().add("float_lin_lt",&p_float_lin_lt);
2142  registry().add("float_lin_le_reif",&p_float_lin_le_reif);
2143  registry().add("float_lin_lt_reif",&p_float_lin_lt_reif);
2144 
2145 #ifdef GECODE_HAS_MPFR
2146  registry().add("float_acos",&p_float_acos);
2147  registry().add("float_asin",&p_float_asin);
2148  registry().add("float_atan",&p_float_atan);
2149  registry().add("float_cos",&p_float_cos);
2150  // registry().add("float_cosh",&p_float_cosh);
2151  registry().add("float_exp",&p_float_exp);
2152  registry().add("float_ln",&p_float_ln);
2153  registry().add("float_log10",&p_float_log10);
2154  registry().add("float_log2",&p_float_log2);
2155  registry().add("float_sin",&p_float_sin);
2156  // registry().add("float_sinh",&p_float_sinh);
2157  registry().add("float_tan",&p_float_tan);
2158  // registry().add("float_tanh",&p_float_tanh);
2159 #endif
2160  }
2161  } __float_poster;
2162 #endif
2163 
2164  }
2165 }}
2166 
2167 // STATISTICS: flatzinc-any
Bounds propagation.
Definition: int.hh:953
void mod(Home home, IntVar x0, IntVar x1, IntVar x2, IntPropLevel ipl)
Post propagator for .
Definition: arithmetic.cpp:263
static IntArgs create(int n, int start, int inc=1)
Allocate array with n elements such that for all .
Definition: array.hpp:68
Post propagator for SetVar SetOpType op
Definition: set.hh:765
NodeType t
Type of node.
Definition: bool-expr.cpp:230
SetRelType
Common relation types for sets.
Definition: set.hh:641
void mult(Home home, FloatVar x0, FloatVar x1, FloatVar x2)
Post propagator for .
Definition: arithmetic.cpp:88
IntArgs arg2intargs(AST::Node *arg, int offset=0)
Convert arg (array of integers) to IntArgs.
Definition: flatzinc.cpp:2119
void post(FlatZincSpace &s, const ConExpr &ce)
Post constraint specified by ce.
Definition: registry.cpp:59
NNF * l
Left subtree.
Definition: bool-expr.cpp:240
void sorted(Home home, const IntVarArgs &x, const IntVarArgs &y, const IntVarArgs &z, IntPropLevel)
Post propagator that y is x sorted in increasing order.
Definition: sorted.cpp:39
int size(void) const
Return size of array (number of elements)
Definition: array.hpp:1653
const int min
Smallest allowed integer in integer set.
Definition: set.hh:99
Map from constraint identifier to constraint posting functions.
Definition: registry.hh:44
void sequence(Home home, const IntVarArgs &x, const IntSet &s, int q, int l, int u, IntPropLevel)
Post propagator for .
Definition: sequence.cpp:47
void log(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
void channel(Home home, FloatVar x0, IntVar x1)
Post propagator for channeling a float and an integer variable .
Definition: channel.cpp:41
const FloatNum max
Largest allowed float value.
Definition: float.hh:844
void count(Home home, const IntVarArgs &x, int n, IntRelType irt, int m, IntPropLevel)
Post propagator for .
Definition: count.cpp:40
Less or equal ( )
Definition: float.hh:1068
void max(Home home, FloatVar x0, FloatVar x1, FloatVar x2)
Post propagator for .
Definition: arithmetic.cpp:49
Gecode::IntVarArray iv
The integer variables.
Definition: flatzinc.hh:480
void abs(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition: arithmetic.cpp:41
Less or equal ( )
Definition: int.hh:903
void pow(Home home, FloatVar x0, int n, FloatVar x1)
Post propagator for for $n 0$.
Definition: arithmetic.cpp:109
Conjunction.
Definition: int.hh:926
void member(Home home, const IntVarArgs &x, IntVar y, IntPropLevel)
Post domain consistent propagator for .
Definition: member.cpp:39
void dom(Home home, FloatVar x, FloatVal n)
Propagates .
Definition: dom.cpp:40
void linear(Home home, const FloatVarArgs &x, FloatRelType frt, FloatVal c)
Post propagator for .
Definition: linear.cpp:41
void * ralloc(size_t s)
Allocate s bytes from heap.
Definition: heap.hpp:357
Implication.
Definition: int.hh:928
std::vector< Node * > a
Definition: ast.hh:233
void circuit(Home home, int offset, const IntVarArgs &x, IntPropLevel ipl)
Post propagator such that x forms a circuit.
Definition: circuit.cpp:41
void argmin(Home home, const IntVarArgs &x, IntVar y, bool tiebreak, IntPropLevel)
Post propagator for .
Definition: arithmetic.cpp:163
Less ( )
Definition: float.hh:1069
SetOpType
Common operations for sets.
Definition: set.hh:658
Greater ( )
Definition: int.hh:906
Superset ( )
Definition: set.hh:645
void binpacking(Home home, const IntVarArgs &l, const IntVarArgs &b, const IntArgs &s, IntPropLevel)
Post propagator for bin packing.
Definition: bin-packing.cpp:41
const int max
Largest allowed integer in integer set.
Definition: set.hh:97
ArgArray< IntSet > IntSetArgs
Passing set arguments.
Definition: int.hh:595
const int max
Largest allowed integer value.
Definition: int.hh:112
Greater or equal ( )
Definition: int.hh:905
Difference.
Definition: set.hh:662
Exclusive or.
Definition: int.hh:930
const int min
Smallest allowed integer value.
Definition: int.hh:114
Gecode::IntSet d(v, 7)
Gecode::FloatVal c(-8, 8)
int p
Number of positive literals for node type.
Definition: bool-expr.cpp:232
const FloatNum min
Smallest allowed float value.
Definition: float.hh:846
Gecode::IntArgs i(4, 1, 2, 3, 4)
IntRelType neg(IntRelType irt)
Return negated relation type of irt.
Definition: irt.hpp:52
int n
Number of negative literals for node type.
Definition: bool-expr.cpp:234
Equality ( )
Definition: int.hh:901
void unshare(Home home, IntVarArgs &x, IntPropLevel ipl)
Replace multiple variable occurences in x by fresh variables.
Definition: unshare.cpp:136
Options opt
The options.
Definition: test.cpp:97
IntPropLevel ann2ipl(AST::Node *ann)
Convert ann to integer propagation level.
Definition: flatzinc.cpp:2383
void nvalues(Home home, const IntVarArgs &x, IntRelType irt, int y, IntPropLevel)
Post propagator for .
Definition: nvalues.cpp:40
IntRelType
Relation types for integers.
Definition: int.hh:900
IntVar arg2IntVar(AST::Node *n)
Convert n to IntVar.
Definition: flatzinc.cpp:2282
FloatRelType
Relation types for floats.
Definition: float.hh:1065
Less or equal ( )
Definition: set.hh:648
Simple propagation levels.
Definition: int.hh:951
void extensional(Home home, const IntVarArgs &x, DFA dfa, IntPropLevel)
Post domain consistent propagator for extensional constraint described by a DFA.
Definition: extensional.cpp:43
BoolVarArgs arg2boolvarargs(AST::Node *arg, int offset=0, int siv=-1)
Convert arg to BoolVarArgs.
Definition: flatzinc.cpp:2245
void sqrt(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition: arithmetic.cpp:102
Reification specification.
Definition: int.hh:851
void distinct(Home home, const IntVarArgs &x, IntPropLevel ipl)
Post propagator for for all .
Definition: distinct.cpp:46
Subset ( )
Definition: set.hh:644
void argmax(Home home, const IntVarArgs &x, IntVar y, bool tiebreak, IntPropLevel)
Post propagator for .
Definition: arithmetic.cpp:110
#define BOOL_OP(op)
Definition: registry.cpp:564
Intersection
Definition: set.hh:661
union Gecode::@585::NNF::@62 u
Union depending on nodetype t.
Less ( )
Definition: int.hh:904
Post propagator for SetVar SetOpType SetVar SetRelType SetVar z
Definition: set.hh:765
Less ( )
Definition: set.hh:649
Disjunction.
Definition: int.hh:927
IntVarArgs arg2intvarargs(AST::Node *arg, int offset=0)
Convert arg to IntVarArgs.
Definition: flatzinc.cpp:2224
void convex(Home home, SetVar x)
Definition: convex.cpp:41
void asin(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
AST::Array * ann
Constraint annotations.
Definition: conexpr.hh:50
Passing integer variables.
Definition: int.hh:633
bool isBoolArray(AST::Node *b, int &singleInt)
Check if b is array of Booleans (or has a single integer)
Definition: flatzinc.cpp:2292
SharedArray< int > IntSharedArray
Arrays of integers that can be shared among several element constraints.
Definition: int.hh:1451
Passing integer arguments.
Definition: int.hh:604
Passing Boolean variables.
Definition: int.hh:687
Equality ( )
Definition: float.hh:1066
static const IntSet empty
Empty set.
Definition: int.hh:259
BoolVar expr(Home home, const BoolExpr &e, IntPropLevel ipl)
Post Boolean expression and return its value.
Definition: bool-expr.cpp:628
void nooverlap(Home home, const IntVarArgs &x, const IntArgs &w, const IntVarArgs &y, const IntArgs &h, IntPropLevel)
Post propagator for rectangle packing.
Definition: no-overlap.cpp:51
LinIntExpr cardinality(const SetExpr &e)
Cardinality of set expression.
Definition: set-expr.cpp:814
Post propagator for SetVar SetOpType SetVar SetRelType r
Definition: set.hh:765
const int v[7]
Definition: distinct.cpp:259
void min(Home home, FloatVar x0, FloatVar x1, FloatVar x2)
Post propagator for .
Definition: arithmetic.cpp:67
void cos(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
IntPropLevel
Propagation levels for integer propagators.
Definition: int.hh:949
Union.
Definition: set.hh:659
AST::Array * args
Constraint arguments.
Definition: conexpr.hh:48
struct Gecode::@585::NNF::@62::@63 b
For binary nodes (and, or, eqv)
Post propagator for f(x \diamond_{\mathit{op}} y) \sim_r z \f$ void rel(Home home
Post propagator for SetVar SetOpType SetVar y
Definition: set.hh:765
void div(Home home, FloatVar x0, FloatVar x1, FloatVar x2)
Post propagator for .
Definition: arithmetic.cpp:127
struct Gecode::@585::NNF::@62::@64 a
For atomic nodes.
void tan(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Disjoint union.
Definition: set.hh:660
void(* poster)(FlatZincSpace &, const ConExpr &, AST::Node *)
Type of constraint posting function.
Definition: registry.hh:47
void precede(Home home, const IntVarArgs &x, int s, int t, IntPropLevel)
Post propagator that s precedes t in x.
Definition: precede.cpp:43
Integer variables.
Definition: int.hh:347
Heap heap
The single global heap.
Definition: heap.cpp:44
void rel(Home home, FloatVar x0, FloatRelType frt, FloatVal n)
Propagates .
Definition: rel.cpp:43
Exception class for FlatZinc errors
Definition: flatzinc.hh:660
Domain propagation Options: basic versus advanced propagation.
Definition: int.hh:954
Equality ( )
Definition: set.hh:642
Disjoint ( )
Definition: set.hh:646
Post propagator for SetVar x
Definition: set.hh:765
void add(const std::string &id, poster p)
Add posting function p with identifier id.
Definition: registry.cpp:69
#define BOOL_ARRAY_OP(op)
Definition: registry.cpp:573
A space that can be initialized with a FlatZinc model.
Definition: flatzinc.hh:423
Disequality ( )
Definition: set.hh:643
Gecode toplevel namespace
void weights(Home home, IntSharedArray elements, IntSharedArray weights, SetVar x, IntVar y)
Definition: int.cpp:292
Implication for reification.
Definition: int.hh:837
void sin(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
A node in a FlatZinc abstract syntax tree.
Definition: ast.hh:67
Disequality ( )
Definition: int.hh:902
void acos(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
void exp(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
void cumulative(Home home, int c, const TaskTypeArgs &t, const IntVarArgs &s, const IntArgs &p, const IntArgs &u, IntPropLevel ipl)
Post propagators for scheduling tasks on cumulative resources.
Definition: cumulative.cpp:353
ReifyMode
Mode for reification.
Definition: int.hh:823
void unary(Home home, const IntVarArgs &s, const IntArgs &p, IntPropLevel ipl)
Post propagators for scheduling tasks on unary resources.
Definition: unary.cpp:44
#define P_FLOAT_OP(Op)
Definition: registry.cpp:2083
void element(Home home, IntSharedArray c, IntVar x0, IntVar x1, IntPropLevel)
Post domain consistent propagator for .
Definition: element.cpp:39
Registry & registry(void)
Return global registry object.
Definition: registry.cpp:53
void atan(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
std::string id
Identifier for the constraint.
Definition: conexpr.hh:46
T * a
Element array.
Definition: array.hpp:515
void clause(Home home, BoolOpType o, const BoolVarArgs &x, const BoolVarArgs &y, int n, IntPropLevel)
Post domain consistent propagator for Boolean clause with positive variables x and negative variables...
Definition: bool.cpp:906
Equivalence for reification (default)
Definition: int.hh:830
IntRelType swap(IntRelType irt)
Return swapped relation type of irt.
Definition: irt.hpp:37
void cumulatives(Home home, const IntVarArgs &m, const IntVarArgs &s, const IntVarArgs &p, const IntVarArgs &e, const IntVarArgs &u, const IntArgs &c, bool at_most, IntPropLevel cl)
Post propagators for the cumulatives constraint.
BoolVar arg2BoolVar(AST::Node *n)
Convert n to BoolVar.
Definition: flatzinc.cpp:2271
Abstract representation of a constraint.
Definition: conexpr.hh:43