Generated on for Gecode by doxygen 1.17.0
bool-expr.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 * Christian Schulte <schulte@gecode.dev>
6 * Vincent Barichard <Vincent.Barichard@univ-angers.fr>
7 *
8 * Contributing authors:
9 * Alexander Shepil <alexander.shepil@sap.com>
10 * Mikael Zayenz Lagerkvist <lagerkvist@gecode.dev>
11 *
12 * Copyright:
13 * Guido Tack, 2004
14 * Christian Schulte, 2004
15 * Alexander Shepil, 2024
16 * Mikael Zayenz Lagerkvist, 2026
17 * Vincent Barichard, 2012
18 *
19 * This file is part of Gecode, the generic constraint
20 * development environment:
21 * http://www.gecode.dev
22 *
23 * Permission is hereby granted, free of charge, to any person obtaining
24 * a copy of this software and associated documentation files (the
25 * "Software"), to deal in the Software without restriction, including
26 * without limitation the rights to use, copy, modify, merge, publish,
27 * distribute, sublicense, and/or sell copies of the Software, and to
28 * permit persons to whom the Software is furnished to do so, subject to
29 * the following conditions:
30 *
31 * The above copyright notice and this permission notice shall be
32 * included in all copies or substantial portions of the Software.
33 *
34 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
35 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
36 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
37 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
38 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
39 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
40 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
41 *
42 */
43
44#include <gecode/minimodel.hh>
45
46namespace Gecode {
47
50 public:
52 unsigned int use;
54 int same;
58 bool value;
60 Node *l, *r;
65#ifdef GECODE_HAS_FLOAT_VARS
68#endif
69#ifdef GECODE_HAS_SET_VARS
72#endif
75
77 Node(void);
79 ~Node(void);
82 bool decrement(void);
84 static void* operator new(size_t size);
86 static void operator delete(void* p, size_t size);
87 };
88
89
90 /*
91 * Operations for nodes
92 *
93 */
95 : use(1), same(0), t(NT_AND), l(nullptr), r(nullptr), m(nullptr) {}
96
98 delete m;
99 }
100
101 void*
102 BoolExpr::Node::operator new(size_t size) {
103 return heap.ralloc(size);
104 }
105 void
106 BoolExpr::Node::operator delete(void* p, size_t) {
107 heap.rfree(p);
108 }
109
110 bool
112 if (--use == 0) {
113 if ((l != nullptr) && l->decrement())
114 delete l;
115 if ((r != nullptr) && r->decrement())
116 delete r;
117 return true;
118 }
119 return false;
120 }
121
123 BoolExpr::constant(bool value) {
124 Node* n = new Node;
125 n->same = 1;
126 n->t = NT_CONST;
127 n->value = value;
128 return n;
129 }
130
131 BoolExpr::BoolExpr(void) : n(new Node) {}
132
133 BoolExpr::BoolExpr(const BoolExpr& e) : n(e.n) {
134 n->use++;
135 }
136
137 BoolExpr::BoolExpr(const BoolVar& x) : n(new Node) {
138 n->same = 1;
139 n->t = NT_VAR;
140 n->l = nullptr;
141 n->r = nullptr;
142 n->x = x;
143 }
144
145 BoolExpr::BoolExpr(const BoolExpr& l, NodeType t, const BoolExpr& r)
146 : BoolExpr(l,t,r,false) {}
147
148 BoolExpr::BoolExpr(const BoolExpr& l, NodeType t, const BoolExpr& r,
149 bool accumulator) {
150 if (accumulator && ((t == NT_AND) || (t == NT_OR)) &&
151 (l.n->same == 0)) {
152 n = r.n;
153 n->use++;
154 return;
155 }
156 if (accumulator && ((t == NT_AND) || (t == NT_OR)) &&
157 (r.n->same == 0)) {
158 n = l.n;
159 n->use++;
160 return;
161 }
162 n = new Node;
163 int ls = ((l.n->t == t) || (l.n->t == NT_VAR)) ? l.n->same : 1;
164 int rs = ((r.n->t == t) || (r.n->t == NT_VAR)) ? r.n->same : 1;
165 n->same = ls+rs;
166 n->t = t;
167 n->l = l.n;
168 n->l->use++;
169 n->r = r.n;
170 n->r->use++;
171 }
172
173 BoolExpr::BoolExpr(const BoolExpr& l, NodeType t) {
174 (void) t;
175 assert(t == NT_NOT);
176 if (l.n->t == NT_NOT) {
177 n = l.n->l;
178 n->use++;
179 } else {
180 n = new Node;
181 n->same = 1;
182 n->t = NT_NOT;
183 n->l = l.n;
184 n->l->use++;
185 n->r = nullptr;
186 }
187 }
188
190 : n(new Node) {
191 n->same = 1;
192 n->t = NT_RLIN;
193 n->l = nullptr;
194 n->r = nullptr;
195 n->rl = rl;
196 }
197
198#ifdef GECODE_HAS_FLOAT_VARS
200 : n(new Node) {
201 n->same = 1;
202 n->t = NT_RLINFLOAT;
203 n->l = nullptr;
204 n->r = nullptr;
205 n->rfl = rfl;
206 }
207#endif
208
209#ifdef GECODE_HAS_SET_VARS
211 : n(new Node) {
212 n->same = 1;
213 n->t = NT_RSET;
214 n->l = nullptr;
215 n->r = nullptr;
216 n->rs = rs;
217 }
218
220 : n(new Node) {
221 n->same = 1;
222 n->t = NT_RSET;
223 n->l = nullptr;
224 n->r = nullptr;
225 n->rs = rs;
226 }
227#endif
228
230 : n(nullptr) {
231 try {
232 n = new Node;
233 } catch (...) {
234 delete m;
235 throw;
236 }
237 n->same = 1;
238 n->t = NT_MISC;
239 n->l = nullptr;
240 n->r = nullptr;
241 n->m = m;
242 }
243
244 const BoolExpr&
245 BoolExpr::operator =(const BoolExpr& e) {
246 if (this != &e) {
247 if (n->decrement())
248 delete n;
249 n = e.n;
250 n->use++;
251 }
252 return *this;
253 }
254
256
258 if (n->decrement())
259 delete n;
260 }
261
262 namespace {
264 class NNF {
265 public:
266 typedef BoolExpr::NodeType NodeType;
267 typedef BoolExpr::Node Node;
269 NodeType t;
271 int p;
273 int n;
275 union {
277 struct {
279 NNF* l;
281 NNF* r;
282 } b;
284 struct {
286 bool neg;
288 Node* x;
289 } a;
290 } u;
292 static NNF* nnf(Region& r, Node* n, bool neg);
295 void post(Home home, NodeType t,
296 BoolVarArgs& bp, BoolVarArgs& bn,
297 int& ip, int& in,
298 const IntPropLevels& ipls) const;
301 BoolVar expr(Home home, const IntPropLevels& ipls) const;
304 void rel(Home home, const IntPropLevels& ipls) const;
306 static void* operator new(size_t s, Region& r);
308 static void operator delete(void*);
310 static void operator delete(void*, Region&);
311 };
312
313 /*
314 * Operations for negation normalform
315 *
316 */
317 forceinline void
318 NNF::operator delete(void*) {}
319
320 forceinline void
321 NNF::operator delete(void*, Region&) {}
322
323 forceinline void*
324 NNF::operator new(size_t s, Region& r) {
325 return r.ralloc(s);
326 }
327
328 BoolVar
329 NNF::expr(Home home, const IntPropLevels& ipls) const {
330 if ((t == BoolExpr::NT_VAR) && !u.a.neg)
331 return u.a.x->x;
332 if (t == BoolExpr::NT_CONST) {
333 bool value = u.a.x->value != u.a.neg;
334 return BoolVar(home,value,value);
335 }
336 BoolVar b(home,0,1);
337 switch (t) {
338 case BoolExpr::NT_VAR:
339 assert(u.a.neg);
340 Gecode::rel(home, u.a.x->x, IRT_NQ, b);
341 break;
343 u.a.x->rl.post(home, b, !u.a.neg, ipls);
344 break;
345#ifdef GECODE_HAS_FLOAT_VARS
347 u.a.x->rfl.post(home, b, !u.a.neg);
348 break;
349#endif
350#ifdef GECODE_HAS_SET_VARS
352 u.a.x->rs.post(home, b, !u.a.neg);
353 break;
354#endif
356 u.a.x->m->post(home, b, u.a.neg, ipls);
357 break;
358 case BoolExpr::NT_AND:
359 {
360 BoolVarArgs bp(p), bn(n);
361 int ip=0, in=0;
362 post(home, BoolExpr::NT_AND, bp, bn, ip, in, ipls);
363 clause(home, BOT_AND, bp, bn, b);
364 }
365 break;
366 case BoolExpr::NT_OR:
367 {
368 BoolVarArgs bp(p), bn(n);
369 int ip=0, in=0;
370 post(home, BoolExpr::NT_OR, bp, bn, ip, in, ipls);
371 clause(home, BOT_OR, bp, bn, b);
372 }
373 break;
374 case BoolExpr::NT_EQV:
375 {
376 bool n = false;
377 BoolVar l;
378 if (u.b.l->t == BoolExpr::NT_VAR) {
379 l = u.b.l->u.a.x->x;
380 if (u.b.l->u.a.neg) n = !n;
381 } else {
382 l = u.b.l->expr(home,ipls);
383 }
384 BoolVar r;
385 if (u.b.r->t == BoolExpr::NT_VAR) {
386 r = u.b.r->u.a.x->x;
387 if (u.b.r->u.a.neg) n = !n;
388 } else {
389 r = u.b.r->expr(home,ipls);
390 }
391 Gecode::rel(home, l, n ? BOT_XOR : BOT_EQV, r, b);
392 }
393 break;
394 default:
396 }
397 return b;
398 }
399
400 void
401 NNF::post(Home home, NodeType t,
402 BoolVarArgs& bp, BoolVarArgs& bn,
403 int& ip, int& in,
404 const IntPropLevels& ipls) const {
405 if (this->t != t) {
406 switch (this->t) {
407 case BoolExpr::NT_VAR:
408 if (u.a.neg) {
409 bn[in++]=u.a.x->x;
410 } else {
411 bp[ip++]=u.a.x->x;
412 }
413 break;
415 {
416 BoolVar b(home,0,1);
417 u.a.x->rl.post(home, b, !u.a.neg, ipls);
418 bp[ip++]=b;
419 }
420 break;
421#ifdef GECODE_HAS_FLOAT_VARS
423 {
424 BoolVar b(home,0,1);
425 u.a.x->rfl.post(home, b, !u.a.neg);
426 bp[ip++]=b;
427 }
428 break;
429#endif
430#ifdef GECODE_HAS_SET_VARS
432 {
433 BoolVar b(home,0,1);
434 u.a.x->rs.post(home, b, !u.a.neg);
435 bp[ip++]=b;
436 }
437 break;
438#endif
440 {
441 BoolVar b(home,0,1);
442 u.a.x->m->post(home, b, u.a.neg, ipls);
443 bp[ip++]=b;
444 }
445 break;
446 default:
447 bp[ip++] = expr(home, ipls);
448 break;
449 }
450 } else {
451 u.b.l->post(home, t, bp, bn, ip, in, ipls);
452 u.b.r->post(home, t, bp, bn, ip, in, ipls);
453 }
454 }
455
456 void
457 NNF::rel(Home home, const IntPropLevels& ipls) const {
458 switch (t) {
460 if (u.a.x->value == u.a.neg)
461 home.fail();
462 break;
463 case BoolExpr::NT_VAR:
464 Gecode::rel(home, u.a.x->x, IRT_EQ, u.a.neg ? 0 : 1);
465 break;
467 u.a.x->rl.post(home, !u.a.neg, ipls);
468 break;
469#ifdef GECODE_HAS_FLOAT_VARS
471 u.a.x->rfl.post(home, !u.a.neg);
472 break;
473#endif
474#ifdef GECODE_HAS_SET_VARS
476 u.a.x->rs.post(home, !u.a.neg);
477 break;
478#endif
480 {
481 BoolVar b(home,!u.a.neg,!u.a.neg);
482 u.a.x->m->post(home, b, false, ipls);
483 }
484 break;
485 case BoolExpr::NT_AND:
486 u.b.l->rel(home, ipls);
487 u.b.r->rel(home, ipls);
488 break;
489 case BoolExpr::NT_OR:
490 {
491 BoolVarArgs bp(p), bn(n);
492 int ip=0, in=0;
493 post(home, BoolExpr::NT_OR, bp, bn, ip, in, ipls);
494 clause(home, BOT_OR, bp, bn, 1);
495 }
496 break;
497 case BoolExpr::NT_EQV:
498 if (u.b.l->t==BoolExpr::NT_VAR &&
499 u.b.r->t==BoolExpr::NT_RLIN) {
500 u.b.r->u.a.x->rl.post(home, u.b.l->u.a.x->x,
501 u.b.l->u.a.neg==u.b.r->u.a.neg, ipls);
502 } else if (u.b.r->t==BoolExpr::NT_VAR &&
503 u.b.l->t==BoolExpr::NT_RLIN) {
504 u.b.l->u.a.x->rl.post(home, u.b.r->u.a.x->x,
505 u.b.l->u.a.neg==u.b.r->u.a.neg, ipls);
506 } else if (u.b.l->t==BoolExpr::NT_RLIN) {
507 u.b.l->u.a.x->rl.post(home, u.b.r->expr(home,ipls),
508 !u.b.l->u.a.neg,ipls);
509 } else if (u.b.r->t==BoolExpr::NT_RLIN) {
510 u.b.r->u.a.x->rl.post(home, u.b.l->expr(home,ipls),
511 !u.b.r->u.a.neg,ipls);
512#ifdef GECODE_HAS_FLOAT_VARS
513 } else if (u.b.l->t==BoolExpr::NT_VAR &&
514 u.b.r->t==BoolExpr::NT_RLINFLOAT) {
515 u.b.r->u.a.x->rfl.post(home, u.b.l->u.a.x->x,
516 u.b.l->u.a.neg==u.b.r->u.a.neg);
517 } else if (u.b.r->t==BoolExpr::NT_VAR &&
518 u.b.l->t==BoolExpr::NT_RLINFLOAT) {
519 u.b.l->u.a.x->rfl.post(home, u.b.r->u.a.x->x,
520 u.b.l->u.a.neg==u.b.r->u.a.neg);
521 } else if (u.b.l->t==BoolExpr::NT_RLINFLOAT) {
522 u.b.l->u.a.x->rfl.post(home, u.b.r->expr(home,ipls),
523 !u.b.l->u.a.neg);
524 } else if (u.b.r->t==BoolExpr::NT_RLINFLOAT) {
525 u.b.r->u.a.x->rfl.post(home, u.b.l->expr(home,ipls),
526 !u.b.r->u.a.neg);
527#endif
528#ifdef GECODE_HAS_SET_VARS
529 } else if (u.b.l->t==BoolExpr::NT_VAR &&
530 u.b.r->t==BoolExpr::NT_RSET) {
531 u.b.r->u.a.x->rs.post(home, u.b.l->u.a.x->x,
532 u.b.l->u.a.neg==u.b.r->u.a.neg);
533 } else if (u.b.r->t==BoolExpr::NT_VAR &&
534 u.b.l->t==BoolExpr::NT_RSET) {
535 u.b.l->u.a.x->rs.post(home, u.b.r->u.a.x->x,
536 u.b.l->u.a.neg==u.b.r->u.a.neg);
537 } else if (u.b.l->t==BoolExpr::NT_RSET) {
538 u.b.l->u.a.x->rs.post(home, u.b.r->expr(home,ipls),
539 !u.b.l->u.a.neg);
540 } else if (u.b.r->t==BoolExpr::NT_RSET) {
541 u.b.r->u.a.x->rs.post(home, u.b.l->expr(home,ipls),
542 !u.b.r->u.a.neg);
543#endif
544 } else {
545 Gecode::rel(home, expr(home, ipls), IRT_EQ, 1);
546 }
547 break;
548 default:
550 }
551 }
552
553 NNF*
554 NNF::nnf(Region& r, Node* n, bool neg) {
555 if (n->same == 0)
556 throw MiniModel::TooFewArguments("BoolExpr");
557 switch (n->t) {
559 case BoolExpr::NT_VAR:
562 #ifdef GECODE_HAS_FLOAT_VARS
564 #endif
565 #ifdef GECODE_HAS_SET_VARS
567 #endif
568 {
569 NNF* x = new (r) NNF;
570 x->t = n->t; x->u.a.neg = neg; x->u.a.x = n;
571 if (neg) {
572 x->p = 0; x->n = 1;
573 } else {
574 x->p = 1; x->n = 0;
575 }
576 return x;
577 }
578 case BoolExpr::NT_NOT:
579 return nnf(r,n->l,!neg);
581 {
582 NodeType t = ((n->t == BoolExpr::NT_AND) == neg) ?
583 BoolExpr::NT_OR : BoolExpr::NT_AND;
584 NNF* x = new (r) NNF;
585 x->t = t;
586 x->u.b.l = nnf(r,n->l,neg);
587 x->u.b.r = nnf(r,n->r,neg);
588 int p_l, n_l;
589 if ((x->u.b.l->t == t) ||
590 (x->u.b.l->t == BoolExpr::NT_VAR)) {
591 p_l=x->u.b.l->p; n_l=x->u.b.l->n;
592 } else {
593 p_l=1; n_l=0;
594 }
595 int p_r, n_r;
596 if ((x->u.b.r->t == t) ||
597 (x->u.b.r->t == BoolExpr::NT_VAR)) {
598 p_r=x->u.b.r->p; n_r=x->u.b.r->n;
599 } else {
600 p_r=1; n_r=0;
601 }
602 x->p = p_l+p_r;
603 x->n = n_l+n_r;
604 return x;
605 }
606 case BoolExpr::NT_EQV:
607 {
608 NNF* x = new (r) NNF;
609 x->t = BoolExpr::NT_EQV;
610 x->u.b.l = nnf(r,n->l,neg);
611 x->u.b.r = nnf(r,n->r,false);
612 x->p = 2; x->n = 0;
613 return x;
614 }
615 default:
617 }
619 return nullptr;
620 }
621 }
622
623 BoolVar
624 BoolExpr::expr(Home home, const IntPropLevels& ipls) const {
625 Region r;
626 return NNF::nnf(r,n,false)->expr(home,ipls);
627 }
628
629 void
630 BoolExpr::rel(Home home, const IntPropLevels& ipls) const {
631 Region r;
632 return NNF::nnf(r,n,false)->rel(home,ipls);
633 }
634
635
637 operator &&(const BoolExpr& l, const BoolExpr& r) {
638 return BoolExpr(l,BoolExpr::NT_AND,r,true);
639 }
641 operator ||(const BoolExpr& l, const BoolExpr& r) {
642 return BoolExpr(l,BoolExpr::NT_OR,r,true);
643 }
645 operator ^(const BoolExpr& l, const BoolExpr& r) {
647 }
648
651 return BoolExpr(e,BoolExpr::NT_NOT);
652 }
653
655 operator !=(const BoolExpr& l, const BoolExpr& r) {
656 return !BoolExpr(l, BoolExpr::NT_EQV, r);
657 }
659 operator ==(const BoolExpr& l, const BoolExpr& r) {
660 return BoolExpr(l, BoolExpr::NT_EQV, r);
661 }
663 operator >>(const BoolExpr& l, const BoolExpr& r) {
666 }
668 operator <<(const BoolExpr& l, const BoolExpr& r) {
671 }
672
673
674 /*
675 * Posting Boolean expressions and relations
676 *
677 */
678 BoolVar
679 expr(Home home, const BoolExpr& e, const IntPropLevels& ipls) {
680 PostInfo pi(home);
681 if (!home.failed())
682 return e.expr(home,ipls);
683 BoolVar x(home,0,1);
684 return x;
685 }
686
687 void
688 rel(Home home, const BoolExpr& e, const IntPropLevels& ipls) {
690 e.rel(home,ipls);
691 }
692
693 /*
694 * Boolean element constraints
695 *
696 */
697
700 protected:
704 int n;
707 public:
709 BElementExpr(const BoolVarArgs& b, const LinIntExpr& idx);
711 virtual ~BElementExpr(void);
713 virtual void post(Home home, BoolVar b, bool neg,
714 const IntPropLevels& ipls);
715 };
716
718 : a(static_cast<BoolExpr*>(heap.ralloc(sizeof(BoolExpr)*b.size()))), n(b.size()), idx(idx) {
719 for (int i=b.size(); i--;)
720 new (&a[i]) BoolExpr(b[i]);
721 }
722
724 heap.free<BoolExpr>(a,n);
725 }
726
727 void
729 const IntPropLevels& ipls) {
730 IntVar z = idx.post(home, ipls);
731 if (z.assigned() && (z.val() >= 0) && (z.val() < n)) {
732 BoolExpr be = neg ? (a[z.val()] == !b) : (a[z.val()] == b);
733 be.rel(home,ipls);
734 } else {
735 BoolVarArgs x(n);
736 for (int i=n; i--;)
737 x[i] = a[i].expr(home,ipls);
738 BoolVar res = neg ? (!b).expr(home,ipls) : b;
739 element(home, x, z, res, ipls.element());
740 }
741 }
742
744 element(const BoolVarArgs& b, const LinIntExpr& idx) {
745 return BoolExpr(new BElementExpr(b,idx));
746 }
747
748}
749
750// STATISTICS: minimodel-any
Boolean element expressions.
LinIntExpr idx
The linear expression for the index.
int n
The number of Boolean expressions.
virtual void post(Home home, BoolVar b, bool neg, const IntPropLevels &ipls)
Constrain b to be equivalent to the expression (negated if neg).
virtual ~BElementExpr(void)
Destructor.
BElementExpr(const BoolVarArgs &b, const LinIntExpr &idx)
Constructor.
BoolExpr * a
The Boolean expressions.
Miscealloneous Boolean expressions.
virtual ~Misc(void)
Destructor.
Node for Boolean expression
Definition bool-expr.cpp:49
BoolVar x
Possibly a variable.
Definition bool-expr.cpp:62
~Node(void)
Destructor.
Definition bool-expr.cpp:97
NodeType t
Type of expression.
Definition bool-expr.cpp:56
bool value
Possibly a Boolean constant.
Definition bool-expr.cpp:58
Node(void)
Default constructor.
Definition bool-expr.cpp:94
LinFloatRel rfl
Possibly a reified float linear relation.
Definition bool-expr.cpp:67
LinIntRel rl
Possibly a reified linear relation.
Definition bool-expr.cpp:64
Node * l
Subexpressions.
Definition bool-expr.cpp:60
SetRel rs
Possibly a reified set relation.
Definition bool-expr.cpp:71
bool decrement(void)
Decrement reference count and possibly free memory.
Misc * m
Possibly a misc Boolean expression.
Definition bool-expr.cpp:74
unsigned int use
Nodes are reference counted.
Definition bool-expr.cpp:52
int same
Number of variables in subtree with same type (for AND and OR).
Definition bool-expr.cpp:54
Boolean expressions.
friend BoolExpr operator||(const BoolExpr &, const BoolExpr &)
friend BoolExpr operator&&(const BoolExpr &, const BoolExpr &)
NodeType
Type of Boolean expression.
@ NT_RLINFLOAT
Reified linear relation.
@ NT_AND
Conjunction.
@ NT_EQV
Equivalence.
@ NT_RLIN
Reified linear relation.
@ NT_VAR
Variable.
@ NT_CONST
Boolean constant.
@ NT_OR
Disjunction.
@ NT_MISC
Other Boolean expression.
@ NT_NOT
Negation.
@ NT_RSET
Reified set relation.
const BoolExpr & operator=(const BoolExpr &e)
Assignment operator.
BoolVar expr(Home home, const IntPropLevels &ipls) const
Post propagators for expression.
~BoolExpr(void)
Destructor.
void rel(Home home, const IntPropLevels &ipls) const
Post propagators for relation.
Passing Boolean variables.
Definition int.hh:739
Boolean integer variables.
Definition int.hh:534
FloatNum size(void) const
Return size of float value (distance between maximum and minimum).
Definition val.hpp:78
Home class for posting propagators
Definition core.hpp:863
bool failed(void) const
Check whether corresponding space is failed.
Definition core.hpp:4293
Class for specifying integer propagation levels used by minimodel.
Definition minimodel.hh:110
IntPropLevel element(void) const
Return integer propagation level for element constraints.
Definition ipl.hpp:164
Integer variables.
Definition int.hh:390
int val(void) const
Return assigned value.
Definition int.hpp:56
Linear relations.
Definition minimodel.hh:920
Linear expressions over integer variables.
Definition minimodel.hh:258
Linear relations over integer variables.
Definition minimodel.hh:359
Class to set group information when a post function is executed.
Definition core.hpp:957
Handle to region.
Definition region.hpp:55
Comparison relation (for two-sided comparisons).
Set relations
bool assigned(void) const
Test whether view is assigned.
Definition var.hpp:111
const int * pi[]
Definition photo.cpp:14262
void post(Home home, Term *t, int n, FloatRelType frt, FloatVal c)
Post propagator for linear constraint over floats.
Definition post.cpp:238
Heap heap
The single global heap.
Definition heap.cpp:44
#define GECODE_POST
Check for failure in a constraint post function.
Definition macros.hpp:40
void rel(Home home, FloatVar x0, FloatRelType frt, FloatVar x1)
Post propagator for .
Definition rel.cpp:68
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
@ IRT_EQ
Equality ( ).
Definition int.hh:1226
@ IRT_NQ
Disequality ( ).
Definition int.hh:1227
@ BOT_OR
Disjunction.
Definition int.hh:1252
@ BOT_EQV
Equivalence.
Definition int.hh:1254
@ BOT_XOR
Exclusive or.
Definition int.hh:1255
@ BOT_AND
Conjunction.
Definition int.hh:1251
#define GECODE_MINIMODEL_EXPORT
Definition minimodel.hh:87
Gecode toplevel namespace
IntVar expr(Home home, const LinIntExpr &e, const IntPropLevels &ipls=IntPropLevels::def)
Post linear expression and return its value.
Definition int-expr.cpp:988
Archive & operator<<(Archive &e, FloatNumBranch nl)
Definition val-sel.hpp:39
IntRelType neg(IntRelType irt)
Return negated relation type of irt.
Definition irt.hpp:52
void element(Home home, IntSharedArray n, IntVar x0, IntVar x1, IntPropLevel ipl=IPL_DEF)
Post domain consistent propagator for .
Definition element.cpp:39
BoolExpr operator!(const BoolExpr &)
Negated Boolean expression.
BoolExpr operator^(const BoolExpr &, const BoolExpr &)
Exclusive-or of Boolean expressions.
TFE post(PropagatorGroup g)
Only post functions (but not propagators) from g are considered.
Definition filter.cpp:138
Archive & operator>>(Archive &e, FloatNumBranch &nl)
Definition val-sel.hpp:44
bool operator==(const FloatVal &x, const FloatVal &y)
Definition val.hpp:295
bool operator!=(const FloatVal &x, const FloatVal &y)
Definition val.hpp:318
Gecode::FloatVal b(9, 12)
Gecode::FloatVal a(-8, 5)
const int r[4][2]
Definition dom.cpp:152
#define forceinline
Definition config.hpp:144
#define GECODE_NEVER
Assert that this command is never executed.
Definition macros.hpp:56