Generated on for Gecode by doxygen 1.17.0
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.dev>
5 *
6 * Contributing authors:
7 * Mikael Zayenz Lagerkvist <lagerkvist@gmail.com>
8 *
9 * Copyright:
10 * Guido Tack, 2007
11 * Mikael Zayenz Lagerkvist, 2009
12 *
13 * This file is part of Gecode, the generic constraint
14 * development environment:
15 * http://www.gecode.dev
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_FLOAT_VARS
44#include <gecode/float.hh>
45#endif
46#include <gecode/flatzinc.hh>
48
49namespace Gecode { namespace FlatZinc {
50
52 static Registry r;
53 return r;
54 }
55
56 void
58 std::map<std::string,poster>::iterator i = r.find(ce.id);
59 if (i == r.end()) {
60 throw FlatZinc::Error("Registry",
61 std::string("Constraint ")+ce.id+" not found", ce.ann);
62 }
63 i->second(s, ce, ce.ann);
64 }
65
66 void
67 Registry::add(const std::string& id, poster p) {
68 r[id] = p;
69 r["gecode_" + id] = p;
70 r["fzn_" + id] = p;
71 }
72
73 namespace {
74
75 void p_distinct(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
76 IntVarArgs va = s.arg2intvarargs(ce[0]);
77 IntPropLevel ipl = s.ann2ipl(ann);
78 unshare(s, va);
79 distinct(s, va, ipl == IPL_DEF ? IPL_BND : ipl);
80 }
81
82 void p_distinctOffset(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
83 IntVarArgs va = s.arg2intvarargs(ce[1]);
84 unshare(s, va);
85 AST::Array* offs = ce.args->a[0]->getArray();
86 IntArgs oa(offs->a.size());
87 for (int i=offs->a.size(); i--; ) {
88 oa[i] = offs->a[i]->getInt();
89 }
90 IntPropLevel ipl = s.ann2ipl(ann);
91 distinct(s, oa, va, ipl == IPL_DEF ? IPL_BND : ipl);
92 }
93
94 void p_all_equal(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
95 IntVarArgs va = s.arg2intvarargs(ce[0]);
96 rel(s, va, IRT_EQ, s.ann2ipl(ann));
97 }
98
99 void p_int_CMP(FlatZincSpace& s, IntRelType irt, const ConExpr& ce,
100 AST::Node* ann) {
101 if (ce[0]->isIntVar()) {
102 if (ce[1]->isIntVar()) {
103 rel(s, s.arg2IntVar(ce[0]), irt, s.arg2IntVar(ce[1]),
104 s.ann2ipl(ann));
105 } else {
106 rel(s, s.arg2IntVar(ce[0]), irt, ce[1]->getInt(), s.ann2ipl(ann));
107 }
108 } else {
109 rel(s, s.arg2IntVar(ce[1]), swap(irt), ce[0]->getInt(),
110 s.ann2ipl(ann));
111 }
112 }
113 void p_int_eq(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
114 p_int_CMP(s, IRT_EQ, ce, ann);
115 }
116 void p_int_ne(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
117 p_int_CMP(s, IRT_NQ, ce, ann);
118 }
119 void p_int_ge(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
120 p_int_CMP(s, IRT_GQ, ce, ann);
121 }
122 void p_int_gt(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
123 p_int_CMP(s, IRT_GR, ce, ann);
124 }
125 void p_int_le(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
126 p_int_CMP(s, IRT_LQ, ce, ann);
127 }
128 void p_int_lt(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
129 p_int_CMP(s, IRT_LE, ce, ann);
130 }
131 void p_int_CMP_reif(FlatZincSpace& s, IntRelType irt, ReifyMode rm,
132 const ConExpr& ce, AST::Node* ann) {
133 if (rm == RM_EQV && ce[2]->isBool()) {
134 if (ce[2]->getBool()) {
135 p_int_CMP(s, irt, ce, ann);
136 } else {
137 p_int_CMP(s, neg(irt), ce, ann);
138 }
139 return;
140 }
141 if (ce[0]->isIntVar()) {
142 if (ce[1]->isIntVar()) {
143 rel(s, s.arg2IntVar(ce[0]), irt, s.arg2IntVar(ce[1]),
144 Reify(s.arg2BoolVar(ce[2]), rm), s.ann2ipl(ann));
145 } else {
146 rel(s, s.arg2IntVar(ce[0]), irt, ce[1]->getInt(),
147 Reify(s.arg2BoolVar(ce[2]), rm), s.ann2ipl(ann));
148 }
149 } else {
150 rel(s, s.arg2IntVar(ce[1]), swap(irt), ce[0]->getInt(),
151 Reify(s.arg2BoolVar(ce[2]), rm), s.ann2ipl(ann));
152 }
153 }
154
155 /* Comparisons */
156 void p_int_eq_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
157 p_int_CMP_reif(s, IRT_EQ, RM_EQV, ce, ann);
158 }
159 void p_int_ne_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
160 p_int_CMP_reif(s, IRT_NQ, RM_EQV, ce, ann);
161 }
162 void p_int_ge_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
163 p_int_CMP_reif(s, IRT_GQ, RM_EQV, ce, ann);
164 }
165 void p_int_gt_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
166 p_int_CMP_reif(s, IRT_GR, RM_EQV, ce, ann);
167 }
168 void p_int_le_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
169 p_int_CMP_reif(s, IRT_LQ, RM_EQV, ce, ann);
170 }
171 void p_int_lt_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
172 p_int_CMP_reif(s, IRT_LE, RM_EQV, ce, ann);
173 }
174
175 void p_int_eq_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
176 p_int_CMP_reif(s, IRT_EQ, RM_IMP, ce, ann);
177 }
178 void p_int_ne_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
179 p_int_CMP_reif(s, IRT_NQ, RM_IMP, ce, ann);
180 }
181 void p_int_ge_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
182 p_int_CMP_reif(s, IRT_GQ, RM_IMP, ce, ann);
183 }
184 void p_int_gt_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
185 p_int_CMP_reif(s, IRT_GR, RM_IMP, ce, ann);
186 }
187 void p_int_le_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
188 p_int_CMP_reif(s, IRT_LQ, RM_IMP, ce, ann);
189 }
190 void p_int_lt_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
191 p_int_CMP_reif(s, IRT_LE, RM_IMP, ce, ann);
192 }
193
194 /* linear (in-)equations */
195 void p_int_lin_CMP(FlatZincSpace& s, IntRelType irt, const ConExpr& ce,
196 AST::Node* ann) {
197 IntArgs ia = s.arg2intargs(ce[0]);
198 int singleIntVar;
199 if (s.isBoolArray(ce[1],singleIntVar)) {
200 if (singleIntVar != -1) {
201 if (std::abs(ia[singleIntVar]) == 1 && ce[2]->getInt() == 0) {
202 IntVar siv = s.arg2IntVar(ce[1]->getArray()->a[singleIntVar]);
203 BoolVarArgs iv = s.arg2boolvarargs(ce[1], 0, singleIntVar);
204 IntArgs ia_tmp(ia.size()-1);
205 int count = 0;
206 for (int i=0; i<ia.size(); i++) {
207 if (i != singleIntVar)
208 ia_tmp[count++] = ia[singleIntVar] == -1 ? ia[i] : -ia[i];
209 }
210 IntRelType t = (ia[singleIntVar] == -1 ? irt : swap(irt));
211 linear(s, ia_tmp, iv, t, siv, s.ann2ipl(ann));
212 } else {
213 IntVarArgs iv = s.arg2intvarargs(ce[1]);
214 linear(s, ia, iv, irt, ce[2]->getInt(), s.ann2ipl(ann));
215 }
216 } else {
217 BoolVarArgs iv = s.arg2boolvarargs(ce[1]);
218 linear(s, ia, iv, irt, ce[2]->getInt(), s.ann2ipl(ann));
219 }
220 } else {
221 IntVarArgs iv = s.arg2intvarargs(ce[1]);
222 linear(s, ia, iv, irt, ce[2]->getInt(), s.ann2ipl(ann));
223 }
224 }
225 void p_int_lin_CMP_reif(FlatZincSpace& s, IntRelType irt, ReifyMode rm,
226 const ConExpr& ce, AST::Node* ann) {
227 if (rm == RM_EQV && ce[2]->isBool()) {
228 if (ce[2]->getBool()) {
229 p_int_lin_CMP(s, irt, ce, ann);
230 } else {
231 p_int_lin_CMP(s, neg(irt), ce, ann);
232 }
233 return;
234 }
235 IntArgs ia = s.arg2intargs(ce[0]);
236 int singleIntVar;
237 if (s.isBoolArray(ce[1],singleIntVar)) {
238 if (singleIntVar != -1) {
239 if (std::abs(ia[singleIntVar]) == 1 && ce[2]->getInt() == 0) {
240 IntVar siv = s.arg2IntVar(ce[1]->getArray()->a[singleIntVar]);
241 BoolVarArgs iv = s.arg2boolvarargs(ce[1], 0, singleIntVar);
242 IntArgs ia_tmp(ia.size()-1);
243 int count = 0;
244 for (int i=0; i<ia.size(); i++) {
245 if (i != singleIntVar)
246 ia_tmp[count++] = ia[singleIntVar] == -1 ? ia[i] : -ia[i];
247 }
248 IntRelType t = (ia[singleIntVar] == -1 ? irt : swap(irt));
249 linear(s, ia_tmp, iv, t, siv, Reify(s.arg2BoolVar(ce[3]), rm),
250 s.ann2ipl(ann));
251 } else {
252 IntVarArgs iv = s.arg2intvarargs(ce[1]);
253 linear(s, ia, iv, irt, ce[2]->getInt(),
254 Reify(s.arg2BoolVar(ce[3]), rm), s.ann2ipl(ann));
255 }
256 } else {
257 BoolVarArgs iv = s.arg2boolvarargs(ce[1]);
258 linear(s, ia, iv, irt, ce[2]->getInt(),
259 Reify(s.arg2BoolVar(ce[3]), rm), s.ann2ipl(ann));
260 }
261 } else {
262 IntVarArgs iv = s.arg2intvarargs(ce[1]);
263 linear(s, ia, iv, irt, ce[2]->getInt(),
264 Reify(s.arg2BoolVar(ce[3]), rm),
265 s.ann2ipl(ann));
266 }
267 }
268 void p_int_lin_eq(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
269 p_int_lin_CMP(s, IRT_EQ, ce, ann);
270 }
271 void p_int_lin_eq_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
272 p_int_lin_CMP_reif(s, IRT_EQ, RM_EQV, ce, ann);
273 }
274 void p_int_lin_eq_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
275 p_int_lin_CMP_reif(s, IRT_EQ, RM_IMP, ce, ann);
276 }
277 void p_int_lin_ne(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
278 p_int_lin_CMP(s, IRT_NQ, ce, ann);
279 }
280 void p_int_lin_ne_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
281 p_int_lin_CMP_reif(s, IRT_NQ, RM_EQV, ce, ann);
282 }
283 void p_int_lin_ne_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
284 p_int_lin_CMP_reif(s, IRT_NQ, RM_IMP, ce, ann);
285 }
286 void p_int_lin_le(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
287 p_int_lin_CMP(s, IRT_LQ, ce, ann);
288 }
289 void p_int_lin_le_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
290 p_int_lin_CMP_reif(s, IRT_LQ, RM_EQV, ce, ann);
291 }
292 void p_int_lin_le_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
293 p_int_lin_CMP_reif(s, IRT_LQ, RM_IMP, ce, ann);
294 }
295 void p_int_lin_lt(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
296 p_int_lin_CMP(s, IRT_LE, ce, ann);
297 }
298 void p_int_lin_lt_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
299 p_int_lin_CMP_reif(s, IRT_LE, RM_EQV, ce, ann);
300 }
301 void p_int_lin_lt_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
302 p_int_lin_CMP_reif(s, IRT_LE, RM_IMP, ce, ann);
303 }
304 void p_int_lin_ge(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
305 p_int_lin_CMP(s, IRT_GQ, ce, ann);
306 }
307 void p_int_lin_ge_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
308 p_int_lin_CMP_reif(s, IRT_GQ, RM_EQV, ce, ann);
309 }
310 void p_int_lin_ge_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
311 p_int_lin_CMP_reif(s, IRT_GQ, RM_IMP, ce, ann);
312 }
313 void p_int_lin_gt(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
314 p_int_lin_CMP(s, IRT_GR, ce, ann);
315 }
316 void p_int_lin_gt_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
317 p_int_lin_CMP_reif(s, IRT_GR, RM_EQV, ce, ann);
318 }
319 void p_int_lin_gt_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
320 p_int_lin_CMP_reif(s, IRT_GR, RM_IMP, ce, ann);
321 }
322
323 void p_bool_lin_CMP(FlatZincSpace& s, IntRelType irt, const ConExpr& ce,
324 AST::Node* ann) {
325 IntArgs ia = s.arg2intargs(ce[0]);
326 BoolVarArgs iv = s.arg2boolvarargs(ce[1]);
327 if (ce[2]->isIntVar())
328 linear(s, ia, iv, irt, s.iv[ce[2]->getIntVar()], s.ann2ipl(ann));
329 else
330 linear(s, ia, iv, irt, ce[2]->getInt(), s.ann2ipl(ann));
331 }
332 void p_bool_lin_CMP_reif(FlatZincSpace& s, IntRelType irt, ReifyMode rm,
333 const ConExpr& ce, AST::Node* ann) {
334 if (rm == RM_EQV && ce[2]->isBool()) {
335 if (ce[2]->getBool()) {
336 p_bool_lin_CMP(s, irt, ce, ann);
337 } else {
338 p_bool_lin_CMP(s, neg(irt), ce, ann);
339 }
340 return;
341 }
342 IntArgs ia = s.arg2intargs(ce[0]);
343 BoolVarArgs iv = s.arg2boolvarargs(ce[1]);
344 if (ce[2]->isIntVar())
345 linear(s, ia, iv, irt, s.iv[ce[2]->getIntVar()],
346 Reify(s.arg2BoolVar(ce[3]), rm),
347 s.ann2ipl(ann));
348 else
349 linear(s, ia, iv, irt, ce[2]->getInt(),
350 Reify(s.arg2BoolVar(ce[3]), rm),
351 s.ann2ipl(ann));
352 }
353 void p_bool_lin_eq(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
354 p_bool_lin_CMP(s, IRT_EQ, ce, ann);
355 }
356 void p_bool_lin_eq_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann)
357 {
358 p_bool_lin_CMP_reif(s, IRT_EQ, RM_EQV, ce, ann);
359 }
360 void p_bool_lin_eq_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann)
361 {
362 p_bool_lin_CMP_reif(s, IRT_EQ, RM_IMP, ce, ann);
363 }
364 void p_bool_lin_ne(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
365 p_bool_lin_CMP(s, IRT_NQ, ce, ann);
366 }
367 void p_bool_lin_ne_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann)
368 {
369 p_bool_lin_CMP_reif(s, IRT_NQ, RM_EQV, ce, ann);
370 }
371 void p_bool_lin_ne_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann)
372 {
373 p_bool_lin_CMP_reif(s, IRT_NQ, RM_IMP, ce, ann);
374 }
375 void p_bool_lin_le(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
376 p_bool_lin_CMP(s, IRT_LQ, ce, ann);
377 }
378 void p_bool_lin_le_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann)
379 {
380 p_bool_lin_CMP_reif(s, IRT_LQ, RM_EQV, ce, ann);
381 }
382 void p_bool_lin_le_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann)
383 {
384 p_bool_lin_CMP_reif(s, IRT_LQ, RM_IMP, ce, ann);
385 }
386 void p_bool_lin_lt(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann)
387 {
388 p_bool_lin_CMP(s, IRT_LE, ce, ann);
389 }
390 void p_bool_lin_lt_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann)
391 {
392 p_bool_lin_CMP_reif(s, IRT_LE, RM_EQV, ce, ann);
393 }
394 void p_bool_lin_lt_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann)
395 {
396 p_bool_lin_CMP_reif(s, IRT_LE, RM_IMP, ce, ann);
397 }
398 void p_bool_lin_ge(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
399 p_bool_lin_CMP(s, IRT_GQ, ce, ann);
400 }
401 void p_bool_lin_ge_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann)
402 {
403 p_bool_lin_CMP_reif(s, IRT_GQ, RM_EQV, ce, ann);
404 }
405 void p_bool_lin_ge_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann)
406 {
407 p_bool_lin_CMP_reif(s, IRT_GQ, RM_IMP, ce, ann);
408 }
409 void p_bool_lin_gt(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
410 p_bool_lin_CMP(s, IRT_GR, ce, ann);
411 }
412 void p_bool_lin_gt_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann)
413 {
414 p_bool_lin_CMP_reif(s, IRT_GR, RM_EQV, ce, ann);
415 }
416 void p_bool_lin_gt_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann)
417 {
418 p_bool_lin_CMP_reif(s, IRT_GR, RM_IMP, ce, ann);
419 }
420
421 /* arithmetic constraints */
422
423 void p_int_plus(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
424 if (!ce[0]->isIntVar()) {
425 rel(s, ce[0]->getInt() + s.arg2IntVar(ce[1])
426 == s.arg2IntVar(ce[2]), s.ann2ipl(ann));
427 } else if (!ce[1]->isIntVar()) {
428 rel(s, s.arg2IntVar(ce[0]) + ce[1]->getInt()
429 == s.arg2IntVar(ce[2]), s.ann2ipl(ann));
430 } else if (!ce[2]->isIntVar()) {
431 rel(s, s.arg2IntVar(ce[0]) + s.arg2IntVar(ce[1])
432 == ce[2]->getInt(), s.ann2ipl(ann));
433 } else {
434 rel(s, s.arg2IntVar(ce[0]) + s.arg2IntVar(ce[1])
435 == s.arg2IntVar(ce[2]), s.ann2ipl(ann));
436 }
437 }
438
439 void p_int_minus(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
440 if (!ce[0]->isIntVar()) {
441 rel(s, ce[0]->getInt() - s.arg2IntVar(ce[1])
442 == s.arg2IntVar(ce[2]), s.ann2ipl(ann));
443 } else if (!ce[1]->isIntVar()) {
444 rel(s, s.arg2IntVar(ce[0]) - ce[1]->getInt()
445 == s.arg2IntVar(ce[2]), s.ann2ipl(ann));
446 } else if (!ce[2]->isIntVar()) {
447 rel(s, s.arg2IntVar(ce[0]) - s.arg2IntVar(ce[1])
448 == ce[2]->getInt(), s.ann2ipl(ann));
449 } else {
450 rel(s, s.arg2IntVar(ce[0]) - s.arg2IntVar(ce[1])
451 == s.arg2IntVar(ce[2]), s.ann2ipl(ann));
452 }
453 }
454
455 void p_int_times(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
456 IntVar x0 = s.arg2IntVar(ce[0]);
457 IntVar x1 = s.arg2IntVar(ce[1]);
458 IntVar x2 = s.arg2IntVar(ce[2]);
459 mult(s, x0, x1, x2, s.ann2ipl(ann));
460 }
461 void p_int_pow(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
462 IntVar x0 = s.arg2IntVar(ce[0]);
463 IntVar x2 = s.arg2IntVar(ce[2]);
464 pow(s, x0, ce[1]->getInt(), x2, s.ann2ipl(ann));
465 }
466 void p_int_div(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
467 IntVar x0 = s.arg2IntVar(ce[0]);
468 IntVar x1 = s.arg2IntVar(ce[1]);
469 IntVar x2 = s.arg2IntVar(ce[2]);
470 IntVarArgs x = {x0, x1, x2};
471 unshare(s, x);
472 div(s,x[0],x[1],x[2], s.ann2ipl(ann));
473 }
474 void p_int_mod(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
475 IntVar x0 = s.arg2IntVar(ce[0]);
476 IntVar x1 = s.arg2IntVar(ce[1]);
477 IntVar x2 = s.arg2IntVar(ce[2]);
478 IntVarArgs x = {x0, x1, x2};
479 unshare(s, x);
480 mod(s,x[0],x[1],x[2], s.ann2ipl(ann));
481 }
482
483 void p_int_min(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
484 IntVar x0 = s.arg2IntVar(ce[0]);
485 IntVar x1 = s.arg2IntVar(ce[1]);
486 IntVar x2 = s.arg2IntVar(ce[2]);
487 min(s, x0, x1, x2, s.ann2ipl(ann));
488 }
489 void p_int_max(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
490 IntVar x0 = s.arg2IntVar(ce[0]);
491 IntVar x1 = s.arg2IntVar(ce[1]);
492 IntVar x2 = s.arg2IntVar(ce[2]);
493 max(s, x0, x1, x2, s.ann2ipl(ann));
494 }
495 void p_int_negate(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
496 IntVar x0 = s.arg2IntVar(ce[0]);
497 IntVar x1 = s.arg2IntVar(ce[1]);
498 rel(s, x0 == -x1, s.ann2ipl(ann));
499 }
500
501 /* Boolean constraints */
502 void p_bool_CMP(FlatZincSpace& s, IntRelType irt, const ConExpr& ce,
503 AST::Node* ann) {
504 rel(s, s.arg2BoolVar(ce[0]), irt, s.arg2BoolVar(ce[1]),
505 s.ann2ipl(ann));
506 }
507 void p_bool_CMP_reif(FlatZincSpace& s, IntRelType irt, ReifyMode rm,
508 const ConExpr& ce, AST::Node* ann) {
509 rel(s, s.arg2BoolVar(ce[0]), irt, s.arg2BoolVar(ce[1]),
510 Reify(s.arg2BoolVar(ce[2]), rm), s.ann2ipl(ann));
511 }
512 void p_bool_eq(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
513 p_bool_CMP(s, IRT_EQ, ce, ann);
514 }
515 void p_bool_eq_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
516 p_bool_CMP_reif(s, IRT_EQ, RM_EQV, ce, ann);
517 }
518 void p_bool_eq_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
519 p_bool_CMP_reif(s, IRT_EQ, RM_IMP, ce, ann);
520 }
521 void p_bool_ne(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
522 p_bool_CMP(s, IRT_NQ, ce, ann);
523 }
524 void p_bool_ne_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
525 p_bool_CMP_reif(s, IRT_NQ, RM_EQV, ce, ann);
526 }
527 void p_bool_ne_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
528 p_bool_CMP_reif(s, IRT_NQ, RM_IMP, ce, ann);
529 }
530 void p_bool_ge(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
531 p_bool_CMP(s, IRT_GQ, ce, ann);
532 }
533 void p_bool_ge_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
534 p_bool_CMP_reif(s, IRT_GQ, RM_EQV, ce, ann);
535 }
536 void p_bool_ge_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
537 p_bool_CMP_reif(s, IRT_GQ, RM_IMP, ce, ann);
538 }
539 void p_bool_le(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
540 p_bool_CMP(s, IRT_LQ, ce, ann);
541 }
542 void p_bool_le_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
543 p_bool_CMP_reif(s, IRT_LQ, RM_EQV, ce, ann);
544 }
545 void p_bool_le_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
546 p_bool_CMP_reif(s, IRT_LQ, RM_IMP, ce, ann);
547 }
548 void p_bool_gt(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
549 p_bool_CMP(s, IRT_GR, ce, ann);
550 }
551 void p_bool_gt_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
552 p_bool_CMP_reif(s, IRT_GR, RM_EQV, ce, ann);
553 }
554 void p_bool_gt_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
555 p_bool_CMP_reif(s, IRT_GR, RM_IMP, ce, ann);
556 }
557 void p_bool_lt(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
558 p_bool_CMP(s, IRT_LE, ce, ann);
559 }
560 void p_bool_lt_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
561 p_bool_CMP_reif(s, IRT_LE, RM_EQV, ce, ann);
562 }
563 void p_bool_lt_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
564 p_bool_CMP_reif(s, IRT_LE, RM_IMP, ce, ann);
565 }
566
567#define BOOL_OP(op) \
568 BoolVar b0 = s.arg2BoolVar(ce[0]); \
569 BoolVar b1 = s.arg2BoolVar(ce[1]); \
570 if (ce[2]->isBool()) { \
571 rel(s, b0, op, b1, ce[2]->getBool(), s.ann2ipl(ann)); \
572 } else { \
573 rel(s, b0, op, b1, s.bv[ce[2]->getBoolVar()], s.ann2ipl(ann)); \
574 }
575
576#define BOOL_ARRAY_OP(op) \
577 BoolVarArgs bv = s.arg2boolvarargs(ce[0]); \
578 if (ce.size()==1) { \
579 rel(s, op, bv, 1, s.ann2ipl(ann)); \
580 } else if (ce[1]->isBool()) { \
581 rel(s, op, bv, ce[1]->getBool(), s.ann2ipl(ann)); \
582 } else { \
583 rel(s, op, bv, s.bv[ce[1]->getBoolVar()], s.ann2ipl(ann)); \
584 }
585
586 void p_bool_or(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
588 }
589 void p_bool_or_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
590 BoolVar b0 = s.arg2BoolVar(ce[0]);
591 BoolVar b1 = s.arg2BoolVar(ce[1]);
592 BoolVar b2 = s.arg2BoolVar(ce[2]);
593 clause(s, BOT_OR, BoolVarArgs()<<b0<<b1, BoolVarArgs()<<b2, 1,
594 s.ann2ipl(ann));
595 }
596 void p_bool_and(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
598 }
599 void p_bool_and_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
600 BoolVar b0 = s.arg2BoolVar(ce[0]);
601 BoolVar b1 = s.arg2BoolVar(ce[1]);
602 BoolVar b2 = s.arg2BoolVar(ce[2]);
603 rel(s, b2, BOT_IMP, b0, 1, s.ann2ipl(ann));
604 rel(s, b2, BOT_IMP, b1, 1, s.ann2ipl(ann));
605 }
606 void p_array_bool_and(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann)
607 {
609 }
610 void p_array_bool_and_imp(FlatZincSpace& s, const ConExpr& ce,
611 AST::Node* ann)
612 {
613 BoolVarArgs bv = s.arg2boolvarargs(ce[0]);
614 BoolVar b1 = s.arg2BoolVar(ce[1]);
615 for (unsigned int i=bv.size(); i--;)
616 rel(s, b1, BOT_IMP, bv[i], 1, s.ann2ipl(ann));
617 }
618 void p_array_bool_or(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann)
619 {
621 }
622 void p_array_bool_or_imp(FlatZincSpace& s, const ConExpr& ce,
623 AST::Node* ann)
624 {
625 BoolVarArgs bv = s.arg2boolvarargs(ce[0]);
626 BoolVar b1 = s.arg2BoolVar(ce[1]);
627 clause(s, BOT_OR, bv, BoolVarArgs()<<b1, 1, s.ann2ipl(ann));
628 }
629 void p_array_bool_xor(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann)
630 {
632 }
633 void p_array_bool_xor_imp(FlatZincSpace& s, const ConExpr& ce,
634 AST::Node* ann)
635 {
636 BoolVarArgs bv = s.arg2boolvarargs(ce[0]);
637 BoolVar tmp(s,0,1);
638 rel(s, BOT_XOR, bv, tmp, s.ann2ipl(ann));
639 rel(s, s.arg2BoolVar(ce[1]), BOT_IMP, tmp, 1);
640 }
641 void p_array_bool_clause(FlatZincSpace& s, const ConExpr& ce,
642 AST::Node* ann) {
643 BoolVarArgs bvp = s.arg2boolvarargs(ce[0]);
644 BoolVarArgs bvn = s.arg2boolvarargs(ce[1]);
645 clause(s, BOT_OR, bvp, bvn, 1, s.ann2ipl(ann));
646 }
647 void p_array_bool_clause_reif(FlatZincSpace& s, const ConExpr& ce,
648 AST::Node* ann) {
649 BoolVarArgs bvp = s.arg2boolvarargs(ce[0]);
650 BoolVarArgs bvn = s.arg2boolvarargs(ce[1]);
651 BoolVar b0 = s.arg2BoolVar(ce[2]);
652 clause(s, BOT_OR, bvp, bvn, b0, s.ann2ipl(ann));
653 }
654 void p_array_bool_clause_imp(FlatZincSpace& s, const ConExpr& ce,
655 AST::Node* ann) {
656 BoolVarArgs bvp = s.arg2boolvarargs(ce[0]);
657 BoolVarArgs bvn = s.arg2boolvarargs(ce[1]);
658 BoolVar b0 = s.arg2BoolVar(ce[2]);
659 clause(s, BOT_OR, bvp, bvn, b0, s.ann2ipl(ann));
660 }
661 void p_bool_xor(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
663 }
664 void p_bool_xor_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
665 BoolVar b0 = s.arg2BoolVar(ce[0]);
666 BoolVar b1 = s.arg2BoolVar(ce[1]);
667 BoolVar b2 = s.arg2BoolVar(ce[2]);
668 clause(s, BOT_OR, BoolVarArgs()<<b0<<b1, BoolVarArgs()<<b2, 1,
669 s.ann2ipl(ann));
670 clause(s, BOT_OR, BoolVarArgs(), BoolVarArgs()<<b0<<b1<<b2, 1,
671 s.ann2ipl(ann));
672 }
673 void p_bool_l_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
674 BoolVar b0 = s.arg2BoolVar(ce[0]);
675 BoolVar b1 = s.arg2BoolVar(ce[1]);
676 if (ce[2]->isBool()) {
677 rel(s, b1, BOT_IMP, b0, ce[2]->getBool(), s.ann2ipl(ann));
678 } else {
679 rel(s, b1, BOT_IMP, b0, s.bv[ce[2]->getBoolVar()], s.ann2ipl(ann));
680 }
681 }
682 void p_bool_r_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
684 }
685 void p_bool_not(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
686 BoolVar x0 = s.arg2BoolVar(ce[0]);
687 BoolVar x1 = s.arg2BoolVar(ce[1]);
688 rel(s, x0, BOT_XOR, x1, 1, s.ann2ipl(ann));
689 }
690
691 /* element constraints */
692 void p_array_int_element(FlatZincSpace& s, const ConExpr& ce,
693 AST::Node* ann) {
694 bool isConstant = true;
695 AST::Array* a = ce[1]->getArray();
696 for (int i=a->a.size(); i--;) {
697 if (!a->a[i]->isInt()) {
698 isConstant = false;
699 break;
700 }
701 }
702 IntVar selector = s.arg2IntVar(ce[0]);
703 rel(s, selector > 0);
704 if (isConstant) {
705 IntSharedArray sia = s.arg2intsharedarray(ce[1]);
706 element(s, sia, selector, -1, s.arg2IntVar(ce[2]), s.ann2ipl(ann));
707 } else {
708 IntVarArgs iv = s.arg2intvarargs(ce[1]);
709 element(s, iv, selector, -1, s.arg2IntVar(ce[2]), s.ann2ipl(ann));
710 }
711 }
712 void p_array_int_element_offset(FlatZincSpace& s, const ConExpr& ce,
713 AST::Node* ann) {
714 bool isConstant = true;
715 AST::Array* a = ce[2]->getArray();
716 for (int i=a->a.size(); i--;) {
717 if (!a->a[i]->isInt()) {
718 isConstant = false;
719 break;
720 }
721 }
722 IntVar selector = s.arg2IntVar(ce[0]);
723 int offset = ce[1]->getInt();
724 rel(s, selector >= offset);
725 if (isConstant) {
726 IntSharedArray sia = s.arg2intsharedarray(ce[2]);
727 element(s, sia, selector, -offset, s.arg2IntVar(ce[3]), s.ann2ipl(ann));
728 } else {
729 IntVarArgs iv = s.arg2intvarargs(ce[2]);
730 element(s, iv, selector, -offset, s.arg2IntVar(ce[3]), s.ann2ipl(ann));
731 }
732 }
733 void p_array_int_element2d(FlatZincSpace& s, const ConExpr& ce,
734 AST::Node* ann) {
735 bool isConstant = true;
736 AST::Array* a = ce[2]->getArray();
737 for (int i=a->a.size(); i--;) {
738 if (!a->a[i]->isInt()) {
739 isConstant = false;
740 break;
741 }
742 }
743 IntVar selector0 = s.arg2IntVar(ce[0]);
744 IntVar selector1 = s.arg2IntVar(ce[1]);
745 IntSet idxset0 = s.arg2intset(ce[3]);
746 IntSet idxset1 = s.arg2intset(ce[4]);
747
748 int w = idxset1.size();
749 int s1off = idxset1.min();
750 int h = idxset0.size();
751 int s0off = idxset0.min();
752
753 if (isConstant) {
754 IntSharedArray sia = s.arg2intsharedarray(ce[2], 0);
755 element(s, sia, selector1, -s1off, w, selector0, -s0off, h, s.arg2IntVar(ce[5]), s.ann2ipl(ann));
756 } else {
757 IntVarArgs iv = s.arg2intvarargs(ce[2], 0);
758 element(s, iv, selector1, -s1off, w, selector0, -s0off, h, s.arg2IntVar(ce[5]), s.ann2ipl(ann));
759 }
760 }
761 void p_array_bool_element(FlatZincSpace& s, const ConExpr& ce,
762 AST::Node* ann) {
763 bool isConstant = true;
764 AST::Array* a = ce[1]->getArray();
765 for (int i=a->a.size(); i--;) {
766 if (!a->a[i]->isBool()) {
767 isConstant = false;
768 break;
769 }
770 }
771 IntVar selector = s.arg2IntVar(ce[0]);
772 rel(s, selector > 0);
773 if (isConstant) {
774 IntSharedArray sia = s.arg2boolsharedarray(ce[1], 1);
775 element(s, sia, selector, s.arg2BoolVar(ce[2]), s.ann2ipl(ann));
776 } else {
777 BoolVarArgs iv = s.arg2boolvarargs(ce[1], 1);
778 element(s, iv, selector, s.arg2BoolVar(ce[2]), s.ann2ipl(ann));
779 }
780 }
781 void p_array_bool_element_offset(FlatZincSpace& s, const ConExpr& ce,
782 AST::Node* ann) {
783 bool isConstant = true;
784 AST::Array* a = ce[2]->getArray();
785 for (int i=a->a.size(); i--;) {
786 if (!a->a[i]->isBool()) {
787 isConstant = false;
788 break;
789 }
790 }
791 IntVar selector = s.arg2IntVar(ce[0]);
792 int offset = ce[1]->getInt();
793 rel(s, selector >= offset);
794 if (isConstant) {
795 IntSharedArray sia = s.arg2boolsharedarray(ce[2]);
796 element(s, sia, selector, -offset, s.arg2BoolVar(ce[3]), s.ann2ipl(ann));
797 } else {
798 BoolVarArgs iv = s.arg2boolvarargs(ce[2]);
799 element(s, iv, selector, -offset, s.arg2BoolVar(ce[3]), s.ann2ipl(ann));
800 }
801 }
802 void p_array_bool_element2d(FlatZincSpace& s, const ConExpr& ce,
803 AST::Node* ann) {
804 bool isConstant = true;
805 AST::Array* a = ce[2]->getArray();
806 for (int i=a->a.size(); i--;) {
807 if (!a->a[i]->isBool()) {
808 isConstant = false;
809 break;
810 }
811 }
812 IntVar selector0 = s.arg2IntVar(ce[0]);
813 IntVar selector1 = s.arg2IntVar(ce[1]);
814 IntSet idxset0 = s.arg2intset(ce[3]);
815 IntSet idxset1 = s.arg2intset(ce[4]);
816
817 int w = idxset1.size();
818 int s1off = idxset1.min();
819 int h = idxset0.size();
820 int s0off = idxset0.min();
821
822 if (isConstant) {
823 IntSharedArray sia = s.arg2boolsharedarray(ce[2], 0);
824 element(s, sia, selector1, -s1off, w, selector0, -s0off, h, s.arg2BoolVar(ce[5]), s.ann2ipl(ann));
825 } else {
826 BoolVarArgs iv = s.arg2boolvarargs(ce[2], 0);
827 element(s, iv, selector1, -s1off, w, selector0, -s0off, h, s.arg2BoolVar(ce[5]), s.ann2ipl(ann));
828 }
829 }
830
831 /* coercion constraints */
832 void p_bool2int(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
833 BoolVar x0 = s.arg2BoolVar(ce[0]);
834 IntVar x1 = s.arg2IntVar(ce[1]);
835 if (ce[0]->isBoolVar() && ce[1]->isIntVar()) {
836 s.aliasBool2Int(ce[1]->getIntVar(), ce[0]->getBoolVar());
837 }
838 channel(s, x0, x1, s.ann2ipl(ann));
839 }
840
841 void p_int_in(FlatZincSpace& s, const ConExpr& ce, AST::Node *) {
842 IntSet d = s.arg2intset(ce[1]);
843 if (ce[0]->isBoolVar()) {
844 IntSetRanges dr(d);
845 Iter::Ranges::Singleton sr(0,1);
846 Iter::Ranges::Inter<IntSetRanges,Iter::Ranges::Singleton> i(dr,sr);
847 IntSet d01(i);
848 if (d01.size() == 0) {
849 s.fail();
850 } else {
851 rel(s, s.arg2BoolVar(ce[0]), IRT_GQ, d01.min());
852 rel(s, s.arg2BoolVar(ce[0]), IRT_LQ, d01.max());
853 }
854 } else {
855 dom(s, s.arg2IntVar(ce[0]), d);
856 }
857 }
858 }
859
860 namespace RegistryDetail {
861
863 IntSet d = s.arg2intset(ce[1]);
864 if (ce[0]->isBoolVar()) {
865 IntSetRanges dr(d);
868 IntSet d01(i);
869 if (d01.size() == 0) {
870 rel(s, s.arg2BoolVar(ce[2]) == 0);
871 } else if (d01.max() == 0) {
872 rel(s, s.arg2BoolVar(ce[2]) == !s.arg2BoolVar(ce[0]));
873 } else if (d01.min() == 1) {
874 rel(s, s.arg2BoolVar(ce[2]) == s.arg2BoolVar(ce[0]));
875 } else {
876 rel(s, s.arg2BoolVar(ce[2]) == 1);
877 }
878 } else {
879 dom(s, s.arg2IntVar(ce[0]), d, s.arg2BoolVar(ce[2]));
880 }
881 }
883 IntSet d = s.arg2intset(ce[1]);
884 if (ce[0]->isBoolVar()) {
885 IntSetRanges dr(d);
888 IntSet d01(i);
889 if (d01.size() == 0) {
890 rel(s, s.arg2BoolVar(ce[2]) == 0);
891 } else if (d01.max() == 0) {
892 rel(s, s.arg2BoolVar(ce[2]) >> !s.arg2BoolVar(ce[0]));
893 } else if (d01.min() == 1) {
894 rel(s, s.arg2BoolVar(ce[2]) >> s.arg2BoolVar(ce[0]));
895 }
896 } else {
897 dom(s, s.arg2IntVar(ce[0]), d, Reify(s.arg2BoolVar(ce[2]),RM_IMP));
898 }
899 }
900
901 }
902
903 namespace {
904
905 /* constraints from the standard library */
906
907 void p_abs(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
908 IntVar x0 = s.arg2IntVar(ce[0]);
909 IntVar x1 = s.arg2IntVar(ce[1]);
910 abs(s, x0, x1, s.ann2ipl(ann));
911 }
912
913 void p_array_int_lt(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
914 IntVarArgs iv0 = s.arg2intvarargs(ce[0]);
915 IntVarArgs iv1 = s.arg2intvarargs(ce[1]);
916 rel(s, iv0, IRT_LE, iv1, s.ann2ipl(ann));
917 }
918
919 void p_array_int_lq(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
920 IntVarArgs iv0 = s.arg2intvarargs(ce[0]);
921 IntVarArgs iv1 = s.arg2intvarargs(ce[1]);
922 rel(s, iv0, IRT_LQ, iv1, s.ann2ipl(ann));
923 }
924
925 void p_array_bool_lt(FlatZincSpace& s, const ConExpr& ce,
926 AST::Node* ann) {
927 BoolVarArgs bv0 = s.arg2boolvarargs(ce[0]);
928 BoolVarArgs bv1 = s.arg2boolvarargs(ce[1]);
929 rel(s, bv0, IRT_LE, bv1, s.ann2ipl(ann));
930 }
931
932 void p_array_bool_lq(FlatZincSpace& s, const ConExpr& ce,
933 AST::Node* ann) {
934 BoolVarArgs bv0 = s.arg2boolvarargs(ce[0]);
935 BoolVarArgs bv1 = s.arg2boolvarargs(ce[1]);
936 rel(s, bv0, IRT_LQ, bv1, s.ann2ipl(ann));
937 }
938
939 void p_count(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
940 IntVarArgs iv = s.arg2intvarargs(ce[0]);
941 if (!ce[1]->isIntVar()) {
942 if (!ce[2]->isIntVar()) {
943 count(s, iv, ce[1]->getInt(), IRT_EQ, ce[2]->getInt(),
944 s.ann2ipl(ann));
945 } else {
946 count(s, iv, ce[1]->getInt(), IRT_EQ, s.arg2IntVar(ce[2]),
947 s.ann2ipl(ann));
948 }
949 } else if (!ce[2]->isIntVar()) {
950 count(s, iv, s.arg2IntVar(ce[1]), IRT_EQ, ce[2]->getInt(),
951 s.ann2ipl(ann));
952 } else {
953 count(s, iv, s.arg2IntVar(ce[1]), IRT_EQ, s.arg2IntVar(ce[2]),
954 s.ann2ipl(ann));
955 }
956 }
957
958 void p_count_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
959 IntVarArgs iv = s.arg2intvarargs(ce[0]);
960 IntVar x = s.arg2IntVar(ce[1]);
961 IntVar y = s.arg2IntVar(ce[2]);
962 BoolVar b = s.arg2BoolVar(ce[3]);
963 IntVar c(s,0,Int::Limits::max);
964 count(s,iv,x,IRT_EQ,c,s.ann2ipl(ann));
965 rel(s, b == (c==y));
966 }
967 void p_count_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
968 IntVarArgs iv = s.arg2intvarargs(ce[0]);
969 IntVar x = s.arg2IntVar(ce[1]);
970 IntVar y = s.arg2IntVar(ce[2]);
971 BoolVar b = s.arg2BoolVar(ce[3]);
972 IntVar c(s,0,Int::Limits::max);
973 count(s,iv,x,IRT_EQ,c,s.ann2ipl(ann));
974 rel(s, b >> (c==y));
975 }
976
977 void count_rel(IntRelType irt,
978 FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
979 IntVarArgs iv = s.arg2intvarargs(ce[1]);
980 count(s, iv, ce[2]->getInt(), irt, ce[0]->getInt(), s.ann2ipl(ann));
981 }
982
983 void p_at_most(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
984 count_rel(IRT_LQ, s, ce, ann);
985 }
986
987 void p_at_least(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
988 count_rel(IRT_GQ, s, ce, ann);
989 }
990
991 void p_bin_packing_load(FlatZincSpace& s, const ConExpr& ce,
992 AST::Node* ann) {
993 int minIdx = ce[3]->getInt();
994 IntVarArgs load = s.arg2intvarargs(ce[0]);
995 IntVarArgs l;
996 IntVarArgs bin = s.arg2intvarargs(ce[1]);
997 for (int i=bin.size(); i--;)
998 rel(s, bin[i] >= minIdx);
999 if (minIdx > 0) {
1000 for (int i=minIdx; i--;)
1001 l << IntVar(s,0,0);
1002 } else if (minIdx < 0) {
1003 IntVarArgs bin2(bin.size());
1004 for (int i=bin.size(); i--;)
1005 bin2[i] = expr(s, bin[i]-minIdx, s.ann2ipl(ann));
1006 bin = bin2;
1007 }
1008 l << load;
1009 IntArgs sizes = s.arg2intargs(ce[2]);
1010
1011 IntVarArgs allvars = l + bin;
1012 unshare(s, allvars);
1013 binpacking(s, allvars.slice(0,1,l.size()), allvars.slice(l.size(),1,bin.size()),
1014 sizes, s.ann2ipl(ann));
1015 }
1016
1017 void p_global_cardinality(FlatZincSpace& s, const ConExpr& ce,
1018 AST::Node* ann) {
1019 IntVarArgs iv0 = s.arg2intvarargs(ce[0]);
1020 IntArgs cover = s.arg2intargs(ce[1]);
1021 IntVarArgs iv1 = s.arg2intvarargs(ce[2]);
1022
1023 Region re;
1024 IntSet cover_s(cover);
1025 IntSetRanges cover_r(cover_s);
1026 IntVarRanges* iv0_ri = re.alloc<IntVarRanges>(iv0.size());
1027 for (int i=iv0.size(); i--;)
1028 iv0_ri[i] = IntVarRanges(iv0[i]);
1029 Iter::Ranges::NaryUnion iv0_r(re,iv0_ri,iv0.size());
1030 Iter::Ranges::Diff<Iter::Ranges::NaryUnion,IntSetRanges>
1031 extra_r(iv0_r,cover_r);
1032 Iter::Ranges::ToValues<Iter::Ranges::Diff<
1033 Iter::Ranges::NaryUnion,IntSetRanges> > extra(extra_r);
1034 for (; extra(); ++extra) {
1035 cover << extra.val();
1036 iv1 << IntVar(s,0,iv0.size());
1037 }
1038 IntPropLevel ipl = s.ann2ipl(ann);
1039 if (ipl==IPL_DEF)
1040 ipl=IPL_BND;
1041 if (ipl==IPL_DOM) {
1042 IntVarArgs allvars = iv0+iv1;
1043 unshare(s, allvars);
1044 count(s, allvars.slice(0,1,iv0.size()),
1045 allvars.slice(iv0.size(),1,iv1.size()),
1046 cover, ipl);
1047 } else {
1048 unshare(s, iv0);
1049 count(s, iv0, iv1, cover, ipl);
1050 }
1051 }
1052
1053 void p_global_cardinality_closed(FlatZincSpace& s, const ConExpr& ce,
1054 AST::Node* ann) {
1055 IntVarArgs iv0 = s.arg2intvarargs(ce[0]);
1056 IntArgs cover = s.arg2intargs(ce[1]);
1057 IntVarArgs iv1 = s.arg2intvarargs(ce[2]);
1058 IntPropLevel ipl = s.ann2ipl(ann);
1059 if (ipl==IPL_DEF)
1060 ipl=IPL_BND;
1061 if (ipl==IPL_DOM) {
1062 IntVarArgs allvars = iv0+iv1;
1063 unshare(s, allvars);
1064 count(s, allvars.slice(0,1,iv0.size()),
1065 allvars.slice(iv0.size(),1,iv1.size()),
1066 cover, ipl);
1067 } else {
1068 unshare(s, iv0);
1069 count(s, iv0, iv1, cover, ipl);
1070 }
1071 }
1072
1073 void p_global_cardinality_low_up(FlatZincSpace& s, const ConExpr& ce,
1074 AST::Node* ann) {
1075 IntVarArgs x = s.arg2intvarargs(ce[0]);
1076 IntArgs cover = s.arg2intargs(ce[1]);
1077
1078 IntArgs lbound = s.arg2intargs(ce[2]);
1079 IntArgs ubound = s.arg2intargs(ce[3]);
1080 IntSetArgs y(cover.size());
1081 for (int i=cover.size(); i--;)
1082 y[i] = IntSet(lbound[i],ubound[i]);
1083
1084 IntSet cover_s(cover);
1085 Region re;
1086 IntVarRanges* xrs = re.alloc<IntVarRanges>(x.size());
1087 for (int i=x.size(); i--;)
1088 xrs[i].init(x[i]);
1089 Iter::Ranges::NaryUnion u(re, xrs, x.size());
1090 Iter::Ranges::ToValues<Iter::Ranges::NaryUnion> uv(u);
1091 for (; uv(); ++uv) {
1092 if (!cover_s.in(uv.val())) {
1093 cover << uv.val();
1094 y << IntSet(0,x.size());
1095 }
1096 }
1097 unshare(s, x);
1098 IntPropLevel ipl = s.ann2ipl(ann);
1099 if (ipl==IPL_DEF)
1100 ipl=IPL_BND;
1101 count(s, x, y, cover, ipl);
1102 }
1103
1104 void p_global_cardinality_low_up_closed(FlatZincSpace& s,
1105 const ConExpr& ce,
1106 AST::Node* ann) {
1107 IntVarArgs x = s.arg2intvarargs(ce[0]);
1108 IntArgs cover = s.arg2intargs(ce[1]);
1109
1110 IntArgs lbound = s.arg2intargs(ce[2]);
1111 IntArgs ubound = s.arg2intargs(ce[3]);
1112 IntSetArgs y(cover.size());
1113 for (int i=cover.size(); i--;)
1114 y[i] = IntSet(lbound[i],ubound[i]);
1115 unshare(s, x);
1116 IntPropLevel ipl = s.ann2ipl(ann);
1117 if (ipl==IPL_DEF)
1118 ipl=IPL_BND;
1119 count(s, x, y, cover, ipl);
1120 }
1121
1122 void p_minimum(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1123 IntVarArgs iv = s.arg2intvarargs(ce[1]);
1124 min(s, iv, s.arg2IntVar(ce[0]), s.ann2ipl(ann));
1125 }
1126
1127 void p_maximum(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1128 IntVarArgs iv = s.arg2intvarargs(ce[1]);
1129 max(s, iv, s.arg2IntVar(ce[0]), s.ann2ipl(ann));
1130 }
1131
1132 void p_minimum_arg(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1133 IntVar x = s.arg2IntVar(ce[2]);
1134 IntVarArgs iv = x + s.arg2intvarargs(ce[0]);
1135 unshare(s, iv);
1136 int offset = ce[1]->getInt();
1137 argmin(s, iv.slice(1), offset, x, true, s.ann2ipl(ann));
1138 }
1139
1140 void p_maximum_arg(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1141 IntVar x = s.arg2IntVar(ce[2]);
1142 IntVarArgs iv = x + s.arg2intvarargs(ce[0]);
1143 unshare(s, iv);
1144 int offset = ce[1]->getInt();
1145 argmax(s, iv.slice(1), offset, x, true, s.ann2ipl(ann));
1146 }
1147
1148 void p_minimum_arg_bool(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1149 BoolVarArgs bv = s.arg2boolvarargs(ce[0]);
1150 unshare(s, bv);
1151 int offset = ce[1]->getInt();
1152 argmin(s, bv, offset, s.arg2IntVar(ce[2]), true, s.ann2ipl(ann));
1153 }
1154
1155 void p_maximum_arg_bool(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1156 BoolVarArgs bv = s.arg2boolvarargs(ce[0]);
1157 unshare(s, bv);
1158 int offset = ce[1]->getInt();
1159 argmax(s, bv, offset, s.arg2IntVar(ce[2]), true, s.ann2ipl(ann));
1160 }
1161
1162 void p_regular(FlatZincSpace& s, IntVarArgs iv, int q, int symbols_min,
1163 int symbols_max, IntArgs d, int q0, AST::SetLit* finals,
1164 AST::Node* ann) {
1165 int symbols = symbols_max - symbols_min + 1;
1166
1167 int noOfTrans = 0;
1168 for (int i=0; i<q; i++) {
1169 for (int j=0; j<symbols; j++) {
1170 if (d[i*symbols+j] > 0)
1171 noOfTrans++;
1172 }
1173 }
1174
1175 Region re;
1176 DFA::Transition* t = re.alloc<DFA::Transition>(noOfTrans+1);
1177 noOfTrans = 0;
1178 for (int i=1; i<=q; i++) {
1179 for (int j=0; j<symbols; j++) {
1180 if (d[(i-1)*symbols+j] > 0) {
1181 t[noOfTrans].i_state = i;
1182 t[noOfTrans].symbol = symbols_min + j;
1183 t[noOfTrans].o_state = d[(i-1)*symbols+j];
1184 noOfTrans++;
1185 }
1186 }
1187 }
1188 t[noOfTrans].i_state = -1;
1189
1190 // Final states
1191 int* f;
1192 if (finals->interval) {
1193 f = static_cast<int*>(heap.ralloc(sizeof(int)*(finals->max-finals->min+2)));
1194 for (int i=finals->min; i<=finals->max; i++)
1195 f[i-finals->min] = i;
1196 f[finals->max-finals->min+1] = -1;
1197 } else {
1198 f = static_cast<int*>(heap.ralloc(sizeof(int)*(finals->s.size()+1)));
1199 for (int j=finals->s.size(); j--; )
1200 f[j] = finals->s[j];
1201 f[finals->s.size()] = -1;
1202 }
1203
1204 DFA dfa(q0,t,f);
1205 free(f);
1206 unshare(s, iv);
1207 extensional(s, iv, s.getSharedDFA(dfa), s.ann2ipl(ann));
1208 }
1209
1210 void p_regular(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1211 p_regular(s, s.arg2intvarargs(ce[0]), ce[1]->getInt(), 1, ce[2]->getInt(),
1212 s.arg2intargs(ce[3]), ce[4]->getInt(), ce[5]->getSet(), ann);
1213 }
1214
1215 void p_regular_set(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1216 p_regular(s, s.arg2intvarargs(ce[0]), ce[1]->getInt(), ce[2]->getInt(),
1217 ce[3]->getInt(), s.arg2intargs(ce[4]), ce[5]->getInt(),
1218 ce[6]->getSet(), ann);
1219 }
1220
1221
1222 void p_regular_nfa_int(FlatZincSpace& s, const ConExpr& ce,
1223 AST::Node* ann) {
1224 IntVarArgs x = s.arg2intvarargs(ce[0]);
1225 int q = ce[1]->getInt(), first_symbol = ce[2]->getInt();
1226 int symbols = ce[3]->getInt(), initial = ce[5]->getInt();
1227 IntSetArgs table = s.arg2intsetargs(ce[4]);
1228 IntSet finals = s.arg2intset(ce[6]);
1229 if ((q <= 0) || (symbols <= 0) ||
1230 (static_cast<long long>(q)*symbols != table.size()) ||
1231 (initial < 1) || (initial > q) ||
1232 ((finals.size() != 0) && ((finals.min() < 1) || (finals.max() > q))) ||
1233 (first_symbol < Int::Limits::min) ||
1234 (static_cast<long long>(first_symbol)+symbols-1 > Int::Limits::max))
1235 throw FlatZinc::Error("Registry", "invalid NFA dimensions or states");
1236 std::vector<DFA::Transition> transitions;
1237 for (int state=0; state<q; state++)
1238 for (int symbol=0; symbol<symbols; symbol++) {
1239 const IntSet& targets = table[state*symbols+symbol];
1240 if ((targets.size() != 0) && ((targets.min() < 1) || (targets.max() > q)))
1241 throw FlatZinc::Error("Registry", "invalid NFA transition");
1242 for (IntSetValues target(targets); target(); ++target)
1243 transitions.push_back(DFA::Transition(state+1,first_symbol+symbol,target.val()));
1244 }
1245 transitions.push_back(DFA::Transition(-1,0,0));
1246 std::vector<int> accepting;
1247 for (IntSetValues final(finals); final(); ++final)
1248 accepting.push_back(final.val());
1249 accepting.push_back(-1);
1250 DFA automaton = DFA::nfa(initial,transitions.data(),accepting.data());
1251 unshare(s,x);
1252 extensional(s,x,s.getSharedDFA(automaton),s.ann2ipl(ann));
1253 }
1254
1255 void
1256 p_sort(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1257 IntVarArgs x = s.arg2intvarargs(ce[0]);
1258 IntVarArgs y = s.arg2intvarargs(ce[1]);
1259 IntVarArgs xy(x.size()+y.size());
1260 for (int i=x.size(); i--;)
1261 xy[i] = x[i];
1262 for (int i=y.size(); i--;)
1263 xy[i+x.size()] = y[i];
1264 unshare(s, xy);
1265 for (int i=x.size(); i--;)
1266 x[i] = xy[i];
1267 for (int i=y.size(); i--;)
1268 y[i] = xy[i+x.size()];
1269 sorted(s, x, y, s.ann2ipl(ann));
1270 }
1271
1272 void
1273 p_inverse_offsets(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1274 IntVarArgs x = s.arg2intvarargs(ce[0]);
1275 int xoff = ce[1]->getInt();
1276 IntVarArgs y = s.arg2intvarargs(ce[2]);
1277 int yoff = ce[3]->getInt();
1278 IntVarArgs xy = x + y;
1279 unshare(s, xy);
1280 channel(s, xy.slice(0, 1, x.size()), xoff, xy.slice(x.size()), yoff, s.ann2ipl(ann));
1281 }
1282
1283 void
1284 p_increasing_int(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1285 IntVarArgs x = s.arg2intvarargs(ce[0]);
1286 rel(s,x,IRT_LQ,s.ann2ipl(ann));
1287 }
1288
1289 void
1290 p_increasing_bool(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1291 BoolVarArgs x = s.arg2boolvarargs(ce[0]);
1292 rel(s,x,IRT_LQ,s.ann2ipl(ann));
1293 }
1294
1295 void
1296 p_decreasing_int(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1297 IntVarArgs x = s.arg2intvarargs(ce[0]);
1298 rel(s,x,IRT_GQ,s.ann2ipl(ann));
1299 }
1300
1301 void
1302 p_decreasing_bool(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1303 BoolVarArgs x = s.arg2boolvarargs(ce[0]);
1304 rel(s,x,IRT_GQ,s.ann2ipl(ann));
1305 }
1306
1307 void
1308 p_table_int(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1309 IntVarArgs x = s.arg2intvarargs(ce[0]);
1310 IntArgs tuples = s.arg2intargs(ce[1]);
1311 TupleSet ts = s.arg2tupleset(tuples,x.size());
1312 unshare(s,x);
1313 extensional(s,x,ts,s.ann2ipl(ann));
1314 }
1315
1316 void
1317 p_table_int_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1318 IntVarArgs x = s.arg2intvarargs(ce[0]);
1319 IntArgs tuples = s.arg2intargs(ce[1]);
1320 TupleSet ts = s.arg2tupleset(tuples,x.size());
1321 unshare(s,x);
1322 extensional(s,x,ts,Reify(s.arg2BoolVar(ce[2]),RM_EQV),s.ann2ipl(ann));
1323 }
1324
1325 void
1326 p_table_int_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1327 IntVarArgs x = s.arg2intvarargs(ce[0]);
1328 IntArgs tuples = s.arg2intargs(ce[1]);
1329 TupleSet ts = s.arg2tupleset(tuples,x.size());
1330 unshare(s,x);
1331 extensional(s,x,ts,Reify(s.arg2BoolVar(ce[2]),RM_IMP),s.ann2ipl(ann));
1332 }
1333
1334 void
1335 p_table_bool(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1336 BoolVarArgs x = s.arg2boolvarargs(ce[0]);
1337 IntArgs tuples = s.arg2boolargs(ce[1]);
1338 TupleSet ts = s.arg2tupleset(tuples,x.size());
1339 unshare(s,x);
1340 extensional(s,x,ts,s.ann2ipl(ann));
1341 }
1342
1343 void
1344 p_table_bool_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1345 BoolVarArgs x = s.arg2boolvarargs(ce[0]);
1346 IntArgs tuples = s.arg2boolargs(ce[1]);
1347 TupleSet ts = s.arg2tupleset(tuples,x.size());
1348 unshare(s,x);
1349 extensional(s,x,ts,Reify(s.arg2BoolVar(ce[2]),RM_EQV),s.ann2ipl(ann));
1350 }
1351
1352 void
1353 p_table_bool_imp(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1354 BoolVarArgs x = s.arg2boolvarargs(ce[0]);
1355 IntArgs tuples = s.arg2boolargs(ce[1]);
1356 TupleSet ts = s.arg2tupleset(tuples,x.size());
1357 unshare(s,x);
1358 extensional(s,x,ts,Reify(s.arg2BoolVar(ce[2]),RM_IMP),s.ann2ipl(ann));
1359 }
1360
1361 void p_cumulative_opt(FlatZincSpace& s, const ConExpr& ce,
1362 AST::Node* ann) {
1363 IntVarArgs start = s.arg2intvarargs(ce[0]);
1364 IntArgs duration = s.arg2intargs(ce[1]);
1365 IntArgs height = s.arg2intargs(ce[2]);
1366 BoolVarArgs opt = s.arg2boolvarargs(ce[3]);
1367 IntVar bound = s.arg2IntVar(ce[4]);
1368 unshare(s,start);
1369 cumulative(s,bound,start,duration,height,opt,s.ann2ipl(ann));
1370 }
1371
1372 void p_among_seq_int(FlatZincSpace& s, const ConExpr& ce,
1373 AST::Node* ann) {
1374 IntVarArgs x = s.arg2intvarargs(ce[0]);
1375 IntSet S = s.arg2intset(ce[1]);
1376 int q = ce[2]->getInt();
1377 int l = ce[3]->getInt();
1378 int u = ce[4]->getInt();
1379 unshare(s, x);
1380 sequence(s, x, S, q, l, u, s.ann2ipl(ann));
1381 }
1382
1383 void p_among_seq_bool(FlatZincSpace& s, const ConExpr& ce,
1384 AST::Node* ann) {
1385 BoolVarArgs x = s.arg2boolvarargs(ce[0]);
1386 bool val = ce[1]->getBool();
1387 int q = ce[2]->getInt();
1388 int l = ce[3]->getInt();
1389 int u = ce[4]->getInt();
1390 IntSet S(val, val);
1391 unshare(s, x);
1392 sequence(s, x, S, q, l, u, s.ann2ipl(ann));
1393 }
1394
1395 void p_schedule_unary(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1396 IntVarArgs x = s.arg2intvarargs(ce[0]);
1397 IntArgs p = s.arg2intargs(ce[1]);
1398 unshare(s,x);
1399 unary(s, x, p, s.ann2ipl(ann));
1400 }
1401
1402 void p_schedule_unary_optional(FlatZincSpace& s, const ConExpr& ce,
1403 AST::Node* ann) {
1404 IntVarArgs x = s.arg2intvarargs(ce[0]);
1405 IntArgs p = s.arg2intargs(ce[1]);
1406 BoolVarArgs m = s.arg2boolvarargs(ce[2]);
1407 unshare(s,x);
1408 unary(s, x, p, m, s.ann2ipl(ann));
1409 }
1410
1411 void p_circuit(FlatZincSpace& s, const ConExpr& ce, AST::Node *ann) {
1412 int off = ce[0]->getInt();
1413 IntVarArgs xv = s.arg2intvarargs(ce[1]);
1414 unshare(s,xv);
1415 circuit(s,off,xv,s.ann2ipl(ann));
1416 }
1417 void p_circuit_cost_array(FlatZincSpace& s, const ConExpr& ce,
1418 AST::Node *ann) {
1419 IntArgs c = s.arg2intargs(ce[0]);
1420 IntVarArgs xv = s.arg2intvarargs(ce[1]);
1421 IntVarArgs yv = s.arg2intvarargs(ce[2]);
1422 IntVar z = s.arg2IntVar(ce[3]);
1423 unshare(s,xv);
1424 circuit(s,c,xv,yv,z,s.ann2ipl(ann));
1425 }
1426 void p_circuit_cost(FlatZincSpace& s, const ConExpr& ce, AST::Node *ann) {
1427 IntArgs c = s.arg2intargs(ce[0]);
1428 IntVarArgs xv = s.arg2intvarargs(ce[1]);
1429 IntVar z = s.arg2IntVar(ce[2]);
1430 unshare(s,xv);
1431 circuit(s,c,xv,z,s.ann2ipl(ann));
1432 }
1433
1434 void p_nooverlap(FlatZincSpace& s, const ConExpr& ce, AST::Node *ann) {
1435 IntVarArgs x0 = s.arg2intvarargs(ce[0]);
1436 IntVarArgs w = s.arg2intvarargs(ce[1]);
1437 IntVarArgs y0 = s.arg2intvarargs(ce[2]);
1438 IntVarArgs h = s.arg2intvarargs(ce[3]);
1439 if (w.assigned() && h.assigned()) {
1440 IntArgs iw(w.size());
1441 for (int i=w.size(); i--;)
1442 iw[i] = w[i].val();
1443 IntArgs ih(h.size());
1444 for (int i=h.size(); i--;)
1445 ih[i] = h[i].val();
1446 nooverlap(s,x0,iw,y0,ih,s.ann2ipl(ann));
1447
1448 int miny = y0[0].min();
1449 int maxy = y0[0].max();
1450 int maxdy = ih[0];
1451 for (int i=1; i<y0.size(); i++) {
1452 miny = std::min(miny,y0[i].min());
1453 maxy = std::max(maxy,y0[i].max());
1454 maxdy = std::max(maxdy,ih[i]);
1455 }
1456 int minx = x0[0].min();
1457 int maxx = x0[0].max();
1458 int maxdx = iw[0];
1459 for (int i=1; i<x0.size(); i++) {
1460 minx = std::min(minx,x0[i].min());
1461 maxx = std::max(maxx,x0[i].max());
1462 maxdx = std::max(maxdx,iw[i]);
1463 }
1464 if (miny > Int::Limits::min && maxy < Int::Limits::max) {
1465 cumulative(s,maxdy+maxy-miny,x0,iw,ih);
1466 cumulative(s,maxdx+maxx-minx,y0,ih,iw);
1467 }
1468 } else {
1469 IntVarArgs x1(x0.size()), y1(y0.size());
1470 for (int i=x0.size(); i--; )
1471 x1[i] = expr(s, x0[i] + w[i]);
1472 for (int i=y0.size(); i--; )
1473 y1[i] = expr(s, y0[i] + h[i]);
1474 nooverlap(s,x0,w,x1,y0,h,y1,s.ann2ipl(ann));
1475 }
1476 }
1477
1478 void p_precede(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1479 IntVarArgs x = s.arg2intvarargs(ce[0]);
1480 int p_s = ce[1]->getInt();
1481 int p_t = ce[2]->getInt();
1482 precede(s,x,p_s,p_t,s.ann2ipl(ann));
1483 }
1484
1485 void p_nvalue(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1486 IntVarArgs x = s.arg2intvarargs(ce[1]);
1487 if (ce[0]->isIntVar()) {
1488 IntVar y = s.arg2IntVar(ce[0]);
1489 nvalues(s,x,IRT_EQ,y,s.ann2ipl(ann));
1490 } else {
1491 nvalues(s,x,IRT_EQ,ce[0]->getInt(),s.ann2ipl(ann));
1492 }
1493 }
1494
1495 void p_among(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1496 IntVarArgs x = s.arg2intvarargs(ce[1]);
1497 IntSet v = s.arg2intset(ce[2]);
1498 if (ce[0]->isIntVar()) {
1499 IntVar n = s.arg2IntVar(ce[0]);
1500 unshare(s, x);
1501 count(s,x,v,IRT_EQ,n,s.ann2ipl(ann));
1502 } else {
1503 unshare(s, x);
1504 count(s,x,v,IRT_EQ,ce[0]->getInt(),s.ann2ipl(ann));
1505 }
1506 }
1507
1508 void p_member_int(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1509 IntVarArgs x = s.arg2intvarargs(ce[0]);
1510 IntVar y = s.arg2IntVar(ce[1]);
1511 member(s,x,y,s.ann2ipl(ann));
1512 }
1513 void p_member_int_reif(FlatZincSpace& s, const ConExpr& ce,
1514 AST::Node* ann) {
1515 IntVarArgs x = s.arg2intvarargs(ce[0]);
1516 IntVar y = s.arg2IntVar(ce[1]);
1517 BoolVar b = s.arg2BoolVar(ce[2]);
1518 member(s,x,y,b,s.ann2ipl(ann));
1519 }
1520 void p_member_bool(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1521 BoolVarArgs x = s.arg2boolvarargs(ce[0]);
1522 BoolVar y = s.arg2BoolVar(ce[1]);
1523 member(s,x,y,s.ann2ipl(ann));
1524 }
1525 void p_member_bool_reif(FlatZincSpace& s, const ConExpr& ce,
1526 AST::Node* ann) {
1527 BoolVarArgs x = s.arg2boolvarargs(ce[0]);
1528 BoolVar y = s.arg2BoolVar(ce[1]);
1529 member(s,x,y,s.arg2BoolVar(ce[2]),s.ann2ipl(ann));
1530 }
1531
1536 void blackbox_source(AST::Node* ann, std::string& mode,
1537 std::string& target,
1538 std::vector<std::string>& args) {
1539 auto string_arg = [](AST::Node* n, const char* what) {
1540 if ((n == nullptr) || !n->isString()) {
1541 throw FlatZinc::Error("Registry",
1542 std::string("Malformed blackbox annotation: ") +
1543 what + " must be a string.");
1544 }
1545 return n->getString();
1546 };
1547 AST::Call* c = nullptr;
1548 bool has_dll = (ann != nullptr) && ann->hasCall("blackbox_dll");
1549 bool has_exec = (ann != nullptr) && ann->hasCall("blackbox_exec");
1550 if (has_dll && has_exec) {
1551 throw FlatZinc::Error(
1552 "Registry", "Blackbox constraint has multiple execution method annotations.");
1553 } else if (has_dll) {
1554 c = ann->getCall("blackbox_dll");
1555 mode = "dll";
1556 } else if (has_exec) {
1557 c = ann->getCall("blackbox_exec");
1558 mode = "exec";
1559 } else {
1560 throw FlatZinc::Error(
1561 "Registry", "Blackbox constraint is missing a valid annotation specifying "
1562 "execution method.");
1563 }
1564 if ((c == nullptr) || (c->args == nullptr)) {
1565 throw FlatZinc::Error("Registry",
1566 "Malformed blackbox annotation: missing target.");
1567 }
1568 // For a single-argument call `args` is the bare argument node; for the
1569 // `(target, args)` form it is an array of the two arguments.
1570 if (AST::Array* arr = dynamic_cast<AST::Array*>(c->args)) {
1571 if (arr->a.size() != 2) {
1572 throw FlatZinc::Error(
1573 "Registry", "Malformed blackbox annotation: expected a target string and "
1574 "an argument array.");
1575 }
1576 target = string_arg(arr->a[0], "target");
1577 if (!arr->a[1]->isArray()) {
1578 throw FlatZinc::Error(
1579 "Registry", "Malformed blackbox annotation: argument list must be an array "
1580 "of strings.");
1581 }
1582 AST::Array* al = arr->a[1]->getArray();
1583 for (unsigned int i = 0; i < al->a.size(); i++) {
1584 args.push_back(string_arg(al->a[i], "argument"));
1585 }
1586 } else {
1587 target = string_arg(c->args, "target");
1588 }
1589 }
1590
1591 void p_blackbox(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1592 std::string mode;
1593 std::string target;
1594 std::vector<std::string> args;
1595 blackbox_source(ann, mode, target, args);
1596 IntVarArgs int_input = s.arg2intvarargs(ce[0]);
1597 IntVarArgs int_output = s.arg2intvarargs(ce[2]);
1598#ifdef GECODE_HAS_FLOAT_VARS
1599 FloatVarArgs float_input = s.arg2floatvarargs(ce[1]);
1600 FloatVarArgs float_output = s.arg2floatvarargs(ce[3]);
1601#else
1602 if (!ce[1]->getArray()->a.empty() || !ce[3]->getArray()->a.empty()) {
1603 throw FlatZinc::Error("Registry",
1604 "Blackbox propagator cannot use floating point values when Gecode is compiled without floating point decision variable support.");
1605 }
1606#endif
1607 FlatZinc::blackbox(s, BlackBoxAccess::context(s), int_input, int_output,
1609float_input, float_output,
1610#endif
1611 mode, target, args);
1612 }
1613
1614 void p_blackbox_bounds(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1615 std::string mode;
1616 std::string target;
1617 std::vector<std::string> args;
1618 blackbox_source(ann, mode, target, args);
1619 IntVarArgs ivar = s.arg2intvarargs(ce[0]);
1620#ifdef GECODE_HAS_FLOAT_VARS
1621 FloatVarArgs fvar = s.arg2floatvarargs(ce[1]);
1622#else
1623 if (!ce[1]->getArray()->a.empty()) {
1624 throw FlatZinc::Error("Registry",
1625 "Blackbox propagator cannot use floating point values when Gecode is compiled without floating point decision variable support.");
1626 }
1627#endif
1628 IntArgs flat_reason = s.arg2intargs(ce[2]);
1629 std::vector<int> reason(flat_reason.size());
1630 for (int i = 0; i < flat_reason.size(); i++) {
1631 reason[i] = flat_reason[i];
1632 }
1635fvar,
1636#endif
1637 mode, target, args, reason);
1638 }
1639
1640
1641 // Relation codes are documented in gecode_fzn.mzn.
1642 IntRelType int_relation(AST::Node* arg) {
1643 switch (arg->getInt()) {
1644 case 1: return IRT_EQ;
1645 case 2: return IRT_NQ;
1646 case 3: return IRT_LQ;
1647 case 4: return IRT_LE;
1648 case 5: return IRT_GQ;
1649 case 6: return IRT_GR;
1650 default: throw FlatZinc::Error("Registry", "invalid integer relation");
1651 }
1652 }
1653
1654 void p_inter_distance(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1655 IntVarArgs x = s.arg2intvarargs(ce[0]);
1656 if (ce[1]->isIntVar()) {
1657 // The native propagator rejects aliases between x and the distance.
1658 x << s.arg2IntVar(ce[1]);
1659 unshare(s, x);
1660 inter_distance(s, x.slice(0,1,x.size()-1), x[x.size()-1],
1661 s.ann2ipl(ann));
1662 } else {
1663 if (ce[1]->getInt() < 0) {
1664 s.fail();
1665 return;
1666 }
1667 unshare(s, x);
1668 inter_distance(s, x, ce[1]->getInt(), s.ann2ipl(ann));
1669 }
1670 }
1671
1672 void p_distinct_optional(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1673 IntVarArgs x = s.arg2intvarargs(ce[0]);
1674 BoolVarArgs present = s.arg2boolvarargs(ce[1]);
1675 if (x.size() != present.size())
1676 throw FlatZinc::Error("Registry", "optional distinct arrays must have equal lengths");
1677 int lo = Int::Limits::max, hi = Int::Limits::min, n = 0;
1678 bool mandatory = true;
1679 for (int i=0; i<x.size(); i++)
1680 if (!present[i].zero()) {
1681 lo = std::min(lo,x[i].min());
1682 hi = std::max(hi,x[i].max());
1683 n++;
1684 mandatory = mandatory && present[i].one();
1685 }
1686 if (n < 2)
1687 return;
1688 // Native optional distinct needs unused values outside the active domains.
1689 if ((hi < Int::Limits::max-n) || (lo > Int::Limits::min+n)) {
1690 unshare(s, x);
1691 distinct(s, present, x, s.ann2ipl(ann));
1692 } else if (mandatory) {
1693 IntVarArgs active;
1694 for (int i=0; i<x.size(); i++)
1695 if (present[i].one()) active << x[i];
1696 unshare(s, active);
1697 distinct(s, active, s.ann2ipl(ann));
1698 } else {
1699 for (int i=0; i<x.size(); i++)
1700 for (int j=i+1; j<x.size(); j++)
1701 rel(s, x[i], IRT_NQ, x[j],
1702 Reify(expr(s, present[i] && present[j]), RM_IMP), s.ann2ipl(ann));
1703 }
1704 }
1705 void p_distinct_except(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1706 IntVarArgs x = s.arg2intvarargs(ce[0]);
1707 int c = ce[1]->getInt();
1708 // An excluded value outside the variable limits cannot occur in x.
1709 if ((c < Int::Limits::min) || (c > Int::Limits::max)) {
1710 unshare(s, x);
1711 distinct(s, x, s.ann2ipl(ann));
1712 return;
1713 }
1714 int lo = Int::Limits::max, hi = Int::Limits::min, n = 0;
1715 for (int i=0; i<x.size(); i++)
1716 if (!(x[i].assigned() && (x[i].val() == c))) {
1717 lo = std::min(lo,x[i].min());
1718 hi = std::max(hi,x[i].max());
1719 n++;
1720 }
1721 if (n < 2)
1722 return;
1723 // The native propagator needs unused values outside the active domains.
1724 if ((hi < Int::Limits::max-n) || (lo > Int::Limits::min+n)) {
1725 unshare(s, x);
1726 distinct(s, x, c, s.ann2ipl(ann));
1727 } else {
1728 for (int i=0; i<x.size(); i++)
1729 for (int j=i+1; j<x.size(); j++)
1730 rel(s, x[i], IRT_NQ, x[j],
1731 Reify(expr(s, (x[i] != c) && (x[j] != c)), RM_IMP), s.ann2ipl(ann));
1732 }
1733 }
1734 void p_bool_int_channel(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1735 BoolVarArgs x = s.arg2boolvarargs(ce[0]);
1736 unshare(s, x);
1737 channel(s, x, s.arg2IntVar(ce[1]), ce[2]->getInt(), s.ann2ipl(ann));
1738 }
1739 void p_sort_permutation(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1740 IntVarArgs x = s.arg2intvarargs(ce[0]);
1741 IntVarArgs y = s.arg2intvarargs(ce[1]);
1742 IntVarArgs z = s.arg2intvarargs(ce[2]);
1743 if ((x.size() != y.size()) || (x.size() != z.size()))
1744 throw FlatZinc::Error("Registry", "sort arrays must have equal lengths");
1745 int offset = ce[3]->getInt();
1746 for (int i=0; i<z.size(); i++)
1747 z[i] = expr(s, z[i]-offset);
1748 IntVarArgs xyz;
1749 xyz << x << y << z;
1750 unshare(s, xyz);
1751 sorted(s, xyz.slice(0,1,x.size()), xyz.slice(x.size(),1,y.size()),
1752 xyz.slice(x.size()+y.size()), s.ann2ipl(ann));
1753 }
1754
1755 void p_count_int(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1756 count(s, s.arg2intvarargs(ce[0]), s.arg2IntVar(ce[1]),
1757 int_relation(ce[2]), s.arg2IntVar(ce[3]), s.ann2ipl(ann));
1758 }
1759 void p_count_matches(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1760 IntVarArgs x = s.arg2intvarargs(ce[0]);
1761 IntArgs y = s.arg2intargs(ce[1]);
1762 IntRelType irt = int_relation(ce[2]);
1763 IntVar n = s.arg2IntVar(ce[3]);
1764 IntPropLevel ipl = s.ann2ipl(ann);
1765 if (x.size() != y.size())
1766 throw Int::ArgumentSizeMismatch("Int::count");
1767 // Native matching counts use offset views for x[i]-y[i].
1768 bool safe = true;
1769 for (int i=0; i<x.size(); i++)
1770 if ((y[i] < Int::Limits::min) || (y[i] > Int::Limits::max) ||
1771 (static_cast<long long>(x[i].min())-y[i] < Int::Limits::min) ||
1772 (static_cast<long long>(x[i].max())-y[i] > Int::Limits::max)) {
1773 safe = false;
1774 break;
1775 }
1776 if (safe) {
1777 count(s, x, y, irt, n, ipl);
1778 } else {
1779 BoolVarArgs matches(x.size());
1780 for (int i=0; i<x.size(); i++) {
1781 if (x[i].in(y[i])) {
1782 matches[i] = BoolVar(s,0,1);
1783 rel(s, x[i], IRT_EQ, y[i], Reify(matches[i]), ipl);
1784 } else {
1785 matches[i] = BoolVar(s,0,0);
1786 }
1787 }
1788 linear(s, matches, irt, n, ipl);
1789 }
1790 }
1791 void p_array_int_ne(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1792 rel(s, s.arg2intvarargs(ce[0]), IRT_NQ,
1793 s.arg2intvarargs(ce[1]), s.ann2ipl(ann));
1794 }
1795 void p_array_bool_ne(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1796 rel(s, s.arg2boolvarargs(ce[0]), IRT_NQ,
1797 s.arg2boolvarargs(ce[1]), s.ann2ipl(ann));
1798 }
1799 void p_not_all_equal_int(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1800 rel(s, s.arg2intvarargs(ce[0]), IRT_NQ, s.ann2ipl(ann));
1801 }
1802 void p_int_ite(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1803 ite(s, s.arg2BoolVar(ce[0]), s.arg2IntVar(ce[1]), s.arg2IntVar(ce[2]),
1804 s.arg2IntVar(ce[3]), s.ann2ipl(ann));
1805 }
1806 void p_bool_ite(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1807 ite(s, s.arg2BoolVar(ce[0]), s.arg2BoolVar(ce[1]), s.arg2BoolVar(ce[2]),
1808 s.arg2BoolVar(ce[3]), s.ann2ipl(ann));
1809 }
1810 void p_gcd(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1811 gcd(s, s.arg2IntVar(ce[0]), s.arg2IntVar(ce[1]), s.arg2IntVar(ce[2]),
1812 s.ann2ipl(ann));
1813 }
1814 template<ReifyMode mode>
1815 void p_gcd_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1816 gcd(s, s.arg2IntVar(ce[0]), s.arg2IntVar(ce[1]), s.arg2IntVar(ce[2]),
1817 Reify(s.arg2BoolVar(ce[3]), mode), s.ann2ipl(ann));
1818 }
1819 void p_divides(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1820 divides(s, s.arg2IntVar(ce[0]), s.arg2IntVar(ce[1]),
1821 Reify(BoolVar(s,1,1),RM_EQV), s.ann2ipl(ann));
1822 }
1823 template<ReifyMode mode>
1824 void p_divides_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1825 divides(s, s.arg2IntVar(ce[0]), s.arg2IntVar(ce[1]),
1826 Reify(s.arg2BoolVar(ce[2]),mode), s.ann2ipl(ann));
1827 }
1828 void p_product(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1829 product(s, s.arg2intvarargs(ce[0]), s.arg2IntVar(ce[1]), s.ann2ipl(ann));
1830 }
1831 template<ReifyMode mode>
1832 void p_product_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1833 product(s, s.arg2intvarargs(ce[0]), s.arg2IntVar(ce[1]),
1834 Reify(s.arg2BoolVar(ce[2]),mode), s.ann2ipl(ann));
1835 }
1836 template<bool fixed>
1837 void p_product_mod(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1838 IntVarArgs x = s.arg2intvarargs(ce[0]);
1839 IntVar y = s.arg2IntVar(ce[2]);
1840 if (fixed)
1841 product_mod(s,x,ce[1]->getInt(),y,s.ann2ipl(ann));
1842 else
1843 product_mod(s,x,s.arg2IntVar(ce[1]),y,s.ann2ipl(ann));
1844 }
1845 template<bool fixed, ReifyMode mode>
1846 void p_product_mod_reif(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1847 IntVarArgs x = s.arg2intvarargs(ce[0]);
1848 IntVar y = s.arg2IntVar(ce[2]);
1849 Reify r(s.arg2BoolVar(ce[3]),mode);
1850 if (fixed)
1851 product_mod(s,x,ce[1]->getInt(),y,r,s.ann2ipl(ann));
1852 else
1853 product_mod(s,x,s.arg2IntVar(ce[1]),y,r,s.ann2ipl(ann));
1854 }
1855 void p_minimum_distance(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1856 IntVarArgs x = s.arg2intvarargs(ce[0]);
1857 IntDistance d(ce[1]->getInt(),s.arg2intargs(ce[2]));
1858 MinDistancePropKind kind = ann && ann->hasAtom("gecode_decomposed_propagation")
1860 if (ce.size() == 5)
1861 minimum_distance(s,x,s.arg2IntVar(ce[3]),d,
1862 s.arg2intargs(ce[4]),s.ann2ipl(ann),kind);
1863 else
1864 minimum_distance(s,x,s.arg2IntVar(ce[3]),d,s.ann2ipl(ann),kind);
1865 }
1866
1867 void p_int_nroot(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1868 nroot(s, s.arg2IntVar(ce[0]), ce[1]->getInt(), s.arg2IntVar(ce[2]),
1869 s.ann2ipl(ann));
1870 }
1871
1872 void p_nooverlap_optional(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1873 nooverlap(s, s.arg2intvarargs(ce[0]), s.arg2intargs(ce[1]),
1874 s.arg2intvarargs(ce[2]), s.arg2intargs(ce[3]),
1875 s.arg2boolvarargs(ce[4]), s.ann2ipl(ann));
1876 }
1877 void p_nooverlap_flex(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1878 nooverlap(s, s.arg2intvarargs(ce[0]), s.arg2intvarargs(ce[1]),
1879 s.arg2intvarargs(ce[2]), s.arg2intvarargs(ce[3]),
1880 s.arg2intvarargs(ce[4]), s.arg2intvarargs(ce[5]),
1881 s.arg2boolvarargs(ce[6]), s.ann2ipl(ann));
1882 }
1883
1884 void p_arg_min_int(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1885 IntVarArgs xy = s.arg2intvarargs(ce[0]);
1886 xy << s.arg2IntVar(ce[2]);
1887 unshare(s, xy);
1888 argmin(s, xy.slice(0,1,xy.size()-1), ce[1]->getInt(),
1889 xy[xy.size()-1], ce[3]->getBool(), s.ann2ipl(ann));
1890 }
1891
1892 void p_arg_max_int(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1893 IntVarArgs xy = s.arg2intvarargs(ce[0]);
1894 xy << s.arg2IntVar(ce[2]);
1895 unshare(s, xy);
1896 argmax(s, xy.slice(0,1,xy.size()-1), ce[1]->getInt(),
1897 xy[xy.size()-1], ce[3]->getBool(), s.ann2ipl(ann));
1898 }
1899
1900 void p_arg_min_bool(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1901 BoolVarArgs x = s.arg2boolvarargs(ce[0]);
1902 argmin(s, x, ce[1]->getInt(), s.arg2IntVar(ce[2]),
1903 ce[3]->getBool(), s.ann2ipl(ann));
1904 }
1905
1906 void p_arg_max_bool(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1907 BoolVarArgs x = s.arg2boolvarargs(ce[0]);
1908 argmax(s, x, ce[1]->getInt(), s.arg2IntVar(ce[2]),
1909 ce[3]->getBool(), s.ann2ipl(ann));
1910 }
1911
1912 void p_unary_flex(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1913 IntVarArgs start = s.arg2intvarargs(ce[0]);
1914 unshare(s, start);
1915 unary(s, start, s.arg2intvarargs(ce[1]), s.arg2intvarargs(ce[2]),
1916 s.ann2ipl(ann));
1917 }
1918
1919 void p_cumulative_flex(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1920 IntVarArgs start = s.arg2intvarargs(ce[0]);
1921 unshare(s, start);
1922 cumulative(s, s.arg2IntVar(ce[4]), start,
1923 s.arg2intvarargs(ce[1]), s.arg2intvarargs(ce[2]),
1924 s.arg2intargs(ce[3]), s.ann2ipl(ann));
1925 }
1926
1927 void p_unary_flex_optional(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1928 IntVarArgs start = s.arg2intvarargs(ce[0]);
1929 unshare(s, start);
1930 unary(s, start, s.arg2intvarargs(ce[1]), s.arg2intvarargs(ce[2]),
1931 s.arg2boolvarargs(ce[3]), s.ann2ipl(ann));
1932 }
1933
1934
1935 void p_cumulative_flex_optional(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann) {
1936 IntVarArgs start = s.arg2intvarargs(ce[0]);
1937 unshare(s, start);
1938 cumulative(s, s.arg2IntVar(ce[4]), start, s.arg2intvarargs(ce[1]),
1939 s.arg2intvarargs(ce[2]), s.arg2intargs(ce[3]),
1940 s.arg2boolvarargs(ce[5]), s.ann2ipl(ann));
1941 }
1942
1943 class BuiltinPosters {
1944 public:
1945 BuiltinPosters(void) {
1946 registry().add("all_different_int", &p_distinct);
1947 registry().add("all_different_offset", &p_distinctOffset);
1948 registry().add("gecode_all_different_offset_fzn", &p_distinctOffset);
1949 registry().add("all_equal_int", &p_all_equal);
1950 registry().add("int_eq", &p_int_eq);
1951 registry().add("int_ne", &p_int_ne);
1952 registry().add("int_ge", &p_int_ge);
1953 registry().add("int_gt", &p_int_gt);
1954 registry().add("int_le", &p_int_le);
1955 registry().add("int_lt", &p_int_lt);
1956 registry().add("int_eq_reif", &p_int_eq_reif);
1957 registry().add("int_ne_reif", &p_int_ne_reif);
1958 registry().add("int_ge_reif", &p_int_ge_reif);
1959 registry().add("int_gt_reif", &p_int_gt_reif);
1960 registry().add("int_le_reif", &p_int_le_reif);
1961 registry().add("int_lt_reif", &p_int_lt_reif);
1962 registry().add("int_eq_imp", &p_int_eq_imp);
1963 registry().add("int_ne_imp", &p_int_ne_imp);
1964 registry().add("int_ge_imp", &p_int_ge_imp);
1965 registry().add("int_gt_imp", &p_int_gt_imp);
1966 registry().add("int_le_imp", &p_int_le_imp);
1967 registry().add("int_lt_imp", &p_int_lt_imp);
1968 registry().add("int_lin_eq", &p_int_lin_eq);
1969 registry().add("int_lin_eq_reif", &p_int_lin_eq_reif);
1970 registry().add("int_lin_eq_imp", &p_int_lin_eq_imp);
1971 registry().add("int_lin_ne", &p_int_lin_ne);
1972 registry().add("int_lin_ne_reif", &p_int_lin_ne_reif);
1973 registry().add("int_lin_ne_imp", &p_int_lin_ne_imp);
1974 registry().add("int_lin_le", &p_int_lin_le);
1975 registry().add("int_lin_le_reif", &p_int_lin_le_reif);
1976 registry().add("int_lin_le_imp", &p_int_lin_le_imp);
1977 registry().add("int_lin_lt", &p_int_lin_lt);
1978 registry().add("int_lin_lt_reif", &p_int_lin_lt_reif);
1979 registry().add("int_lin_lt_imp", &p_int_lin_lt_imp);
1980 registry().add("int_lin_ge", &p_int_lin_ge);
1981 registry().add("int_lin_ge_reif", &p_int_lin_ge_reif);
1982 registry().add("int_lin_ge_imp", &p_int_lin_ge_imp);
1983 registry().add("int_lin_gt", &p_int_lin_gt);
1984 registry().add("int_lin_gt_reif", &p_int_lin_gt_reif);
1985 registry().add("int_lin_gt_imp", &p_int_lin_gt_imp);
1986 registry().add("int_plus", &p_int_plus);
1987 registry().add("int_minus", &p_int_minus);
1988 registry().add("int_times", &p_int_times);
1989 registry().add("gecode_int_pow", &p_int_pow);
1990 registry().add("int_div", &p_int_div);
1991 registry().add("int_mod", &p_int_mod);
1992 registry().add("int_min", &p_int_min);
1993 registry().add("int_max", &p_int_max);
1994 registry().add("int_abs", &p_abs);
1995 registry().add("int_negate", &p_int_negate);
1996 registry().add("bool_eq", &p_bool_eq);
1997 registry().add("bool_eq_reif", &p_bool_eq_reif);
1998 registry().add("bool_eq_imp", &p_bool_eq_imp);
1999 registry().add("bool_ne", &p_bool_ne);
2000 registry().add("bool_ne_reif", &p_bool_ne_reif);
2001 registry().add("bool_ne_imp", &p_bool_ne_imp);
2002 registry().add("bool_ge", &p_bool_ge);
2003 registry().add("bool_ge_reif", &p_bool_ge_reif);
2004 registry().add("bool_ge_imp", &p_bool_ge_imp);
2005 registry().add("bool_le", &p_bool_le);
2006 registry().add("bool_le_reif", &p_bool_le_reif);
2007 registry().add("bool_le_imp", &p_bool_le_imp);
2008 registry().add("bool_gt", &p_bool_gt);
2009 registry().add("bool_gt_reif", &p_bool_gt_reif);
2010 registry().add("bool_gt_imp", &p_bool_gt_imp);
2011 registry().add("bool_lt", &p_bool_lt);
2012 registry().add("bool_lt_reif", &p_bool_lt_reif);
2013 registry().add("bool_lt_imp", &p_bool_lt_imp);
2014 registry().add("bool_or", &p_bool_or);
2015 registry().add("bool_or_imp", &p_bool_or_imp);
2016 registry().add("bool_and", &p_bool_and);
2017 registry().add("bool_and_imp", &p_bool_and_imp);
2018 registry().add("bool_xor", &p_bool_xor);
2019 registry().add("bool_xor_imp", &p_bool_xor_imp);
2020 registry().add("array_bool_and", &p_array_bool_and);
2021 registry().add("array_bool_and_imp", &p_array_bool_and_imp);
2022 registry().add("array_bool_or", &p_array_bool_or);
2023 registry().add("array_bool_or_imp", &p_array_bool_or_imp);
2024 registry().add("array_bool_xor", &p_array_bool_xor);
2025 registry().add("array_bool_xor_imp", &p_array_bool_xor_imp);
2026 registry().add("bool_clause", &p_array_bool_clause);
2027 registry().add("bool_clause_reif", &p_array_bool_clause_reif);
2028 registry().add("bool_clause_imp", &p_array_bool_clause_imp);
2029 registry().add("bool_left_imp", &p_bool_l_imp);
2030 registry().add("bool_right_imp", &p_bool_r_imp);
2031 registry().add("bool_not", &p_bool_not);
2032 registry().add("array_int_element", &p_array_int_element);
2033 registry().add("array_var_int_element", &p_array_int_element);
2034 registry().add("gecode_int_element", &p_array_int_element_offset);
2035 registry().add("gecode_var_int_element", &p_array_int_element_offset);
2036 registry().add("gecode_int_element2d", &p_array_int_element2d);
2037 registry().add("array_bool_element", &p_array_bool_element);
2038 registry().add("array_var_bool_element", &p_array_bool_element);
2039 registry().add("gecode_bool_element", &p_array_bool_element_offset);
2040 registry().add("gecode_var_bool_element", &p_array_bool_element_offset);
2041 registry().add("gecode_bool_element2d", &p_array_bool_element2d);
2042 registry().add("bool2int", &p_bool2int);
2043 registry().add("int_in", &p_int_in);
2046#ifndef GECODE_HAS_SET_VARS
2047 registry().add("set_in", &p_int_in);
2050#endif
2051
2052 registry().add("array_int_lt", &p_array_int_lt);
2053 registry().add("array_int_lq", &p_array_int_lq);
2054 registry().add("array_bool_lt", &p_array_bool_lt);
2055 registry().add("array_bool_lq", &p_array_bool_lq);
2056 registry().add("count", &p_count);
2057 registry().add("count_reif", &p_count_reif);
2058 registry().add("count_imp", &p_count_imp);
2059 registry().add("count_eq", &p_count);
2060 registry().add("count_eq_reif", &p_count_reif);
2061 registry().add("count_eq_imp", &p_count_imp);
2062 registry().add("at_least_int", &p_at_least);
2063 registry().add("at_most_int", &p_at_most);
2064 registry().add("gecode_bin_packing_load", &p_bin_packing_load);
2065 registry().add("gecode_global_cardinality", &p_global_cardinality);
2066 registry().add("gecode_global_cardinality_closed",
2067 &p_global_cardinality_closed);
2068 registry().add("global_cardinality_low_up",
2069 &p_global_cardinality_low_up);
2070 registry().add("global_cardinality_low_up_closed",
2071 &p_global_cardinality_low_up_closed);
2072 registry().add("array_int_minimum", &p_minimum);
2073 registry().add("array_int_maximum", &p_maximum);
2074 registry().add("gecode_minimum_arg_int_offset", &p_minimum_arg);
2075 registry().add("gecode_maximum_arg_int_offset", &p_maximum_arg);
2076 registry().add("gecode_minimum_arg_bool_offset", &p_minimum_arg_bool);
2077 registry().add("gecode_maximum_arg_bool_offset", &p_maximum_arg_bool);
2078 registry().add("array_int_maximum", &p_maximum);
2079 registry().add("gecode_regular", &p_regular);
2080 registry().add("gecode_regular_set", &p_regular_set);
2081 registry().add("sort", &p_sort);
2082 registry().add("inverse_offsets", &p_inverse_offsets);
2083 registry().add("increasing_int", &p_increasing_int);
2084 registry().add("increasing_bool", &p_increasing_bool);
2085 registry().add("decreasing_int", &p_decreasing_int);
2086 registry().add("decreasing_bool", &p_decreasing_bool);
2087 registry().add("gecode_table_int", &p_table_int);
2088 registry().add("gecode_table_int_reif", &p_table_int_reif);
2089 registry().add("gecode_table_int_imp", &p_table_int_imp);
2090 registry().add("gecode_table_bool", &p_table_bool);
2091 registry().add("gecode_table_bool_reif", &p_table_bool_reif);
2092 registry().add("gecode_table_bool_imp", &p_table_bool_imp);
2094 registry().add("gecode_among_seq_int", &p_among_seq_int);
2095 registry().add("gecode_among_seq_bool", &p_among_seq_bool);
2096
2097 registry().add("bool_lin_eq", &p_bool_lin_eq);
2098 registry().add("bool_lin_ne", &p_bool_lin_ne);
2099 registry().add("bool_lin_le", &p_bool_lin_le);
2100 registry().add("bool_lin_lt", &p_bool_lin_lt);
2101 registry().add("bool_lin_ge", &p_bool_lin_ge);
2102 registry().add("bool_lin_gt", &p_bool_lin_gt);
2103
2104 registry().add("bool_lin_eq_reif", &p_bool_lin_eq_reif);
2105 registry().add("bool_lin_eq_imp", &p_bool_lin_eq_imp);
2106 registry().add("bool_lin_ne_reif", &p_bool_lin_ne_reif);
2107 registry().add("bool_lin_ne_imp", &p_bool_lin_ne_imp);
2108 registry().add("bool_lin_le_reif", &p_bool_lin_le_reif);
2109 registry().add("bool_lin_le_imp", &p_bool_lin_le_imp);
2110 registry().add("bool_lin_lt_reif", &p_bool_lin_lt_reif);
2111 registry().add("bool_lin_lt_imp", &p_bool_lin_lt_imp);
2112 registry().add("bool_lin_ge_reif", &p_bool_lin_ge_reif);
2113 registry().add("bool_lin_ge_imp", &p_bool_lin_ge_imp);
2114 registry().add("bool_lin_gt_reif", &p_bool_lin_gt_reif);
2115 registry().add("bool_lin_gt_imp", &p_bool_lin_gt_imp);
2116
2117 registry().add("gecode_schedule_unary", &p_schedule_unary);
2118 registry().add("gecode_schedule_unary_optional", &p_schedule_unary_optional);
2119 registry().add("gecode_schedule_cumulative_optional", &p_cumulative_opt);
2120
2121 registry().add("gecode_circuit", &p_circuit);
2122 registry().add("gecode_circuit_cost_array", &p_circuit_cost_array);
2123 registry().add("gecode_circuit_cost", &p_circuit_cost);
2124 registry().add("gecode_nooverlap", &p_nooverlap);
2125 registry().add("gecode_nooverlap_fzn", &p_nooverlap);
2126 registry().add("gecode_precede", &p_precede);
2127 registry().add("nvalue",&p_nvalue);
2128 registry().add("among",&p_among);
2129 registry().add("member_int",&p_member_int);
2130 registry().add("gecode_member_int_reif",&p_member_int_reif);
2131 registry().add("member_bool",&p_member_bool);
2132 registry().add("gecode_member_bool_reif",&p_member_bool_reif);
2133
2134 registry().add("gecode_unary_flex", &p_unary_flex);
2135 registry().add("gecode_cumulative_flex", &p_cumulative_flex);
2136 registry().add("gecode_cumulatives_flex", &RegistryDetail::post_cumulatives);
2137 registry().add("gecode_unary_flex_optional", &p_unary_flex_optional);
2138 registry().add("gecode_cumulative_flex_optional", &p_cumulative_flex_optional);
2139 registry().add("gecode_array_int_ne", &p_array_int_ne);
2140 registry().add("gecode_not_all_equal_int", &p_not_all_equal_int);
2141 registry().add("gecode_array_bool_ne", &p_array_bool_ne);
2142 registry().add("gecode_inter_distance", &p_inter_distance);
2143 registry().add("gecode_inter_distance_fzn", &p_inter_distance);
2144 registry().add("gecode_bool_int_channel", &p_bool_int_channel);
2145 registry().add("gecode_sort_permutation", &p_sort_permutation);
2146 registry().add("gecode_count_int_fzn", &p_count_int);
2147 registry().add("gecode_count_matches_fzn", &p_count_matches);
2148 registry().add("gecode_int_ite", &p_int_ite);
2149 registry().add("gecode_bool_ite", &p_bool_ite);
2150 registry().add("gecode_gcd_int", &p_gcd);
2151 registry().add("gecode_gcd_int_reif", &p_gcd_reif<RM_EQV>);
2152 registry().add("gecode_gcd_int_imp", &p_gcd_reif<RM_IMP>);
2153 registry().add("gecode_divides_int", &p_divides);
2154 registry().add("gecode_divides_int_reif", &p_divides_reif<RM_EQV>);
2155 registry().add("gecode_divides_int_imp", &p_divides_reif<RM_IMP>);
2156 registry().add("gecode_product_int", &p_product);
2157 registry().add("gecode_product_int_reif", &p_product_reif<RM_EQV>);
2158 registry().add("gecode_product_int_imp", &p_product_reif<RM_IMP>);
2159 registry().add("gecode_product_mod_fixed_fzn", &p_product_mod<true>);
2160 registry().add("gecode_product_mod_fixed_fzn_reif", &p_product_mod_reif<true,RM_EQV>);
2161 registry().add("gecode_product_mod_fixed_fzn_imp", &p_product_mod_reif<true,RM_IMP>);
2162 registry().add("gecode_product_mod_var_fzn", &p_product_mod<false>);
2163 registry().add("gecode_product_mod_var_fzn_reif", &p_product_mod_reif<false,RM_EQV>);
2164 registry().add("gecode_product_mod_var_fzn_imp", &p_product_mod_reif<false,RM_IMP>);
2165 registry().add("gecode_minimum_distance_fzn", &p_minimum_distance);
2166 registry().add("gecode_minimum_distance_required_fzn", &p_minimum_distance);
2167 registry().add("gecode_int_nroot", &p_int_nroot);
2168 registry().add("gecode_nooverlap_optional", &p_nooverlap_optional);
2169 registry().add("gecode_all_different_optional", &p_distinct_optional);
2170 registry().add("gecode_all_different_except", &p_distinct_except);
2171 registry().add("gecode_regular_nfa_int_fzn", &p_regular_nfa_int);
2172 registry().add("gecode_nooverlap_flex_optional", &p_nooverlap_flex);
2173 registry().add("gecode_arg_min_int", &p_arg_min_int);
2174 registry().add("gecode_arg_max_int", &p_arg_max_int);
2175 registry().add("gecode_arg_min_bool", &p_arg_min_bool);
2176 registry().add("gecode_arg_max_bool", &p_arg_max_bool);
2177
2178 registry().add("gecode_blackbox", &p_blackbox);
2179 registry().add("gecode_blackbox_bounds", &p_blackbox_bounds);
2180
2181#ifdef GECODE_HAS_SET_VARS
2183#endif
2184#ifdef GECODE_HAS_FLOAT_VARS
2186#endif
2187 }
2188 };
2189 BuiltinPosters builtin_posters;
2190
2191
2192 }
2193}}
2194
2195// STATISTICS: flatzinc-any
T * a
Element array.
Definition array.hpp:548
iterator end(void)
Return an iterator past the end of the array.
Definition array.hpp:1638
int size(void) const
Return size of array (number of elements).
Definition array.hpp:1606
static DFA nfa(int s, Transition t[], int f[])
Construct a nondeterministic finite automaton.
Definition dfa.cpp:545
std::vector< Node * > a
Definition ast.hh:233
Node representing a function call
Definition ast.hh:255
A node in a FlatZinc abstract syntax tree.
Definition ast.hh:67
Set literal node
Definition ast.hh:171
static BlackBoxContextHandle & context(FlatZincSpace &s)
Definition flatzinc.cpp:878
Abstract representation of a constraint.
Definition conexpr.hh:43
std::string id
Identifier for the constraint.
Definition conexpr.hh:46
AST::Array * ann
Constraint annotations.
Definition conexpr.hh:50
Exception class for FlatZinc errors
Definition flatzinc.hh:727
A space that can be initialized with a FlatZinc model.
Definition flatzinc.hh:424
IntVarArgs arg2intvarargs(AST::Node *arg, int offset=0)
Convert arg to IntVarArgs.
IntVar arg2IntVar(AST::Node *n)
Convert n to IntVar.
IntSet arg2intset(AST::Node *n)
Convert n to IntSet.
IntPropLevel ann2ipl(AST::Node *ann)
Convert ann to integer propagation level.
BoolVar arg2BoolVar(AST::Node *n)
Convert n to BoolVar.
Map from constraint identifier to constraint posting functions.
Definition registry.hh:44
void(* poster)(FlatZincSpace &, const ConExpr &, AST::Node *)
Type of constraint posting function.
Definition registry.hh:47
void add(const std::string &id, poster p)
Add posting function p with identifier id.
Definition registry.cpp:67
void post(FlatZincSpace &s, const ConExpr &ce)
Post constraint specified by ce.
Definition registry.cpp:57
FloatNum size(void) const
Return size of float value (distance between maximum and minimum).
Definition val.hpp:78
void * ralloc(size_t s)
Allocate s bytes from heap.
Definition heap.hpp:361
Passing integer arguments.
Definition int.hh:653
Range iterator for integer sets.
Definition int.hh:311
Integer sets.
Definition int.hh:179
int min(int i) const
Return minimum of range at position i.
int max(int i) const
Return maximum of range at position i.
unsigned int size(void) const
Return size (cardinality) of set.
Passing integer variables.
Definition int.hh:681
Integer variables.
Definition int.hh:390
Range iterator for computing intersection (binary).
Range iterator for singleton range.
Reification specification.
Definition int.hh:1176
Heap heap
The single global heap.
Definition heap.cpp:44
void linear(Home home, const FloatVarArgs &x, FloatRelType frt, FloatVal c)
Post propagator for .
Definition linear.cpp:41
void rel(Home home, FloatVar x0, FloatRelType frt, FloatVar x1)
Post propagator for .
Definition rel.cpp:68
void ite(Home home, BoolVar b, FloatVar x, FloatVar y, FloatVar z)
Post propagator for if-then-else constraint.
Definition bool.cpp:39
void binpacking(Home home, const IntVarArgs &l, const IntVarArgs &b, const IntArgs &s, IntPropLevel ipl=IPL_DEF)
Post propagator for bin packing.
void extensional(Home home, const IntVarArgs &x, DFA d, IntPropLevel ipl=IPL_DEF)
Post domain consistent propagator for extensional constraint described by a DFA.
void nooverlap(Home home, const IntVarArgs &x, const IntArgs &w, const IntVarArgs &y, const IntArgs &h, IntPropLevel ipl=IPL_DEF)
Post propagator for rectangle packing.
void precede(Home home, const IntVarArgs &x, int s, int t, IntPropLevel=IPL_DEF)
Post propagator that s precedes t in x.
Definition precede.cpp:43
void clause(Home home, BoolOpType o, const BoolVarArgs &x, const BoolVarArgs &y, BoolVar z, IntPropLevel ipl=IPL_DEF)
Post domain consistent propagator for Boolean clause with positive variables x and negative variables...
Definition bool.cpp:955
void product(Home home, const IntVarArgs &x, IntVar y, IntPropLevel ipl=IPL_DEF)
Constrain y to the exact product of the variables in x.
IntRelType
Relation types for integers.
Definition int.hh:1225
ReifyMode
Mode for reification.
Definition int.hh:1148
void product_mod(Home home, const IntVarArgs &x, int m, IntVar y, IntPropLevel ipl=IPL_DEF)
Constrain y to the product of x modulo m.
IntPropLevel
Propagation levels for integer propagators.
Definition int.hh:1274
@ IRT_EQ
Equality ( ).
Definition int.hh:1226
@ IRT_NQ
Disequality ( ).
Definition int.hh:1227
@ IRT_GQ
Greater or equal ( ).
Definition int.hh:1230
@ IRT_LE
Less ( ).
Definition int.hh:1229
@ IRT_GR
Greater ( ).
Definition int.hh:1231
@ IRT_LQ
Less or equal ( ).
Definition int.hh:1228
@ RM_IMP
Implication for reification.
Definition int.hh:1162
@ RM_EQV
Equivalence for reification (default).
Definition int.hh:1155
@ BOT_OR
Disjunction.
Definition int.hh:1252
@ BOT_IMP
Implication.
Definition int.hh:1253
@ BOT_XOR
Exclusive or.
Definition int.hh:1255
@ BOT_AND
Conjunction.
Definition int.hh:1251
@ IPL_DOM
Domain propagation Options: basic versus advanced propagation.
Definition int.hh:1279
@ IPL_DEF
Simple propagation levels.
Definition int.hh:1276
@ IPL_BND
Bounds propagation.
Definition int.hh:1278
void post_int_in_imp(FlatZincSpace &s, const ConExpr &ce, AST::Node *ann)
Definition registry.cpp:882
void post_int_in_reif(FlatZincSpace &s, const ConExpr &ce, AST::Node *ann)
Definition registry.cpp:862
void post_cumulatives(FlatZincSpace &s, const ConExpr &ce, AST::Node *ann)
Interpreter for the FlatZinc language.
Registry & registry(void)
Return global registry object.
Definition registry.cpp:51
void blackbox_bounds(Home home, BlackBoxContextHandle &context, const IntVarArgs &ivar, const FloatVarArgs &fvar, const std::string &mode, const std::string &target, const std::vector< std::string > &args, const std::vector< int > &reason)
void blackbox(Home home, BlackBoxContextHandle &context, const IntVarArgs &int_in, const IntVarArgs &int_out, const FloatVarArgs &float_in, const FloatVarArgs &float_out, const std::string &mode, const std::string &target, const std::vector< std::string > &args)
const int min
Smallest allowed integer value.
Definition int.hh:123
const int max
Largest allowed integer value.
Definition int.hh:121
ExecStatus assigned(Space &home, const ViewArray< IntView > &x, IntView z, const IntDistance &d, const IntSharedArray &r)
Validate and bind a complete assignment.
Definition prop.hpp:77
ExecStatus zero(Space &home, const ViewArray< IntView > &x, const IntDistance &d, const IntSharedArray &r, bool &changed, bool &realized)
Enforce an actual zero-distance witness when the objective is zero.
Definition prop.hpp:93
Gecode toplevel namespace
ArgArray< IntSet > IntSetArgs
Passing set arguments.
Definition int.hh:644
void count(Home home, const IntVarArgs &x, int n, IntRelType irt, int m, IntPropLevel ipl=IPL_DEF)
Post propagator for .
Definition count.cpp:40
void channel(Home home, FloatVar x0, IntVar x1)
Post propagator for channeling a float and an integer variable .
Definition channel.cpp:41
void mod(Home home, IntVar x0, IntVar x1, IntVar x2, IntPropLevel ipl=IPL_DEF)
Post propagator for .
void sequence(Home home, const IntVarArgs &x, const IntSet &s, int q, int l, int u, IntPropLevel ipl=IPL_DEF)
Post propagator for .
Definition sequence.cpp:47
SharedArray< int > IntSharedArray
Arrays of integers that can be shared among several element constraints.
Definition int.hh:1813
IntVar expr(Home home, const LinIntExpr &e, const IntPropLevels &ipls=IntPropLevels::def)
Post linear expression and return its value.
Definition int-expr.cpp:988
void sorted(Home home, const IntVarArgs &x, const IntVarArgs &y, IntPropLevel ipl=IPL_DEF)
Post propagator that y is x sorted in increasing order.
Definition sorted.cpp:58
void divides(Home home, IntVar divisor, IntVar dividend, Reify r, IntPropLevel ipl=IPL_DEF)
Reify whether divisor divides dividend.
void distinct(Home home, const IntVarArgs &x, IntPropLevel ipl=IPL_DEF)
Post propagator for for all .
Definition distinct.cpp:46
void min(Home home, FloatVar x0, FloatVar x1, FloatVar x2)
Post propagator for .
IntRelType neg(IntRelType irt)
Return negated relation type of irt.
Definition irt.hpp:52
void dom(Home home, FloatVar x, FloatVal n)
Propagates .
Definition dom.cpp:40
void abs(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
void div(Home home, FloatVar x0, FloatVar x1, FloatVar x2)
Post propagator for .
void element(Home home, IntSharedArray n, IntVar x0, IntVar x1, IntPropLevel ipl=IPL_DEF)
Post domain consistent propagator for .
Definition element.cpp:39
void argmax(Home home, const IntVarArgs &x, IntVar y, bool tiebreak=true, IntPropLevel ipl=IPL_DEF)
Post propagator for .
void mult(Home home, FloatVar x0, FloatVar x1, FloatVar x2)
Post propagator for .
IntRelType swap(IntRelType irt)
Return swapped relation type of irt.
Definition irt.hpp:37
void cumulative(Home home, int c, const TaskTypeArgs &t, const IntVarArgs &flex, const IntArgs &fix, const IntArgs &u, IntPropLevel ipl=IPL_DEF)
Post propagators for scheduling tasks on cumulative resources.
void inter_distance(Home home, const IntVarArgs &x, int p, IntPropLevel ipl=IPL_DEF)
Post bounds-consistent propagator for for all .
void minimum_distance(Home home, const IntVarArgs &x, IntVar z, const IntDistance &d, IntPropLevel ipl=IPL_DEF, MinDistancePropKind kind=MDP_SINGLE)
Post .
void unshare(Home home, IntVarArgs &x, IntPropLevel ipl=IPL_DEF)
Replace multiple variable occurrences in x by fresh variables.
Definition unshare.cpp:136
void max(Home home, FloatVar x0, FloatVar x1, FloatVar x2)
Post propagator for .
MinDistancePropKind
Organization of forward-bound minimum-distance propagation.
Definition int.hh:3395
@ MDP_SINGLE
One propagator with advisors and cached pair maxima.
Definition int.hh:3397
@ MDP_DECOMPOSED
One propagator per selected-position pair.
Definition int.hh:3396
void argmin(Home home, const IntVarArgs &x, IntVar y, bool tiebreak=true, IntPropLevel ipl=IPL_DEF)
Post propagator for .
void nvalues(Home home, const IntVarArgs &x, IntRelType irt, int y, IntPropLevel ipl=IPL_DEF)
Post propagator for .
Definition nvalues.cpp:40
void unary(Home home, const IntVarArgs &s, const IntArgs &p, IntPropLevel ipl=IPL_DEF)
Post propagators for scheduling tasks on unary resources.
Definition unary.cpp:44
void member(Home home, const IntVarArgs &x, IntVar y, IntPropLevel ipl=IPL_DEF)
Post domain consistent propagator for .
Definition member.cpp:39
void pow(Home home, FloatVar x0, int n, FloatVar x1)
Post propagator for for .
void circuit(Home home, const IntVarArgs &x, IntPropLevel ipl=IPL_DEF)
Post propagator such that x forms a circuit.
Definition circuit.cpp:73
void nroot(Home home, FloatVar x0, int n, FloatVar x1)
Post propagator for for .
void gcd(Home home, IntVar x0, IntVar x1, IntVar x2, IntPropLevel ipl=IPL_DEF)
Post propagator for .
Gecode::FloatVal b(9, 12)
Gecode::FloatVal a(-8, 5)
bool one(const Gecode::FloatValArgs &a)
Check whether has only one coefficients.
Definition linear.cpp:46
Gecode::IntArgs i({1, 2, 3, 4})
Gecode::IntSet d(v, 7)
const int r[4][2]
Definition dom.cpp:152
Options opt
The options.
Definition test.cpp:163
#define BOOL_ARRAY_OP(op)
Definition registry.cpp:576
#define BOOL_OP(op)
Definition registry.cpp:567
#define GECODE_HAS_FLOAT_VARS
Definition config.hpp:75