Generated on Tue Feb 11 2025 17:33:26 for Gecode by doxygen 1.12.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.org>
5 * Christian Schulte <schulte@gecode.org>
6 * Vincent Barichard <Vincent.Barichard@univ-angers.fr>
7 *
8 * Copyright:
9 * Guido Tack, 2004
10 * Christian Schulte, 2004
11 * Vincent Barichard, 2012
12 *
13 * This file is part of Gecode, the generic constraint
14 * development environment:
15 * http://www.gecode.org
16 *
17 * Permission is hereby granted, free of charge, to any person obtaining
18 * a copy of this software and associated documentation files (the
19 * "Software"), to deal in the Software without restriction, including
20 * without limitation the rights to use, copy, modify, merge, publish,
21 * distribute, sublicense, and/or sell copies of the Software, and to
22 * permit persons to whom the Software is furnished to do so, subject to
23 * the following conditions:
24 *
25 * The above copyright notice and this permission notice shall be
26 * included in all copies or substantial portions of the Software.
27 *
28 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
29 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
30 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
31 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
32 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
33 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
34 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
35 *
36 */
37
38#include <gecode/minimodel.hh>
39
40namespace Gecode {
41
44 public:
46 unsigned int use;
48 int same;
52 Node *l, *r;
57#ifdef GECODE_HAS_FLOAT_VARS
60#endif
61#ifdef GECODE_HAS_SET_VARS
64#endif
67
69 Node(void);
71 ~Node(void);
74 bool decrement(void);
76 static void* operator new(size_t size);
78 static void operator delete(void* p, size_t size);
79 };
80
81
82 /*
83 * Operations for nodes
84 *
85 */
87 : use(1), l(nullptr), r(nullptr), m(nullptr) {}
88
90 delete m;
91 }
92
93 void*
94 BoolExpr::Node::operator new(size_t size) {
95 return heap.ralloc(size);
96 }
97 void
98 BoolExpr::Node::operator delete(void* p, size_t) {
99 heap.rfree(p);
100 }
101
102 bool
104 if (--use == 0) {
105 if ((l != nullptr) && l->decrement())
106 delete l;
107 if ((r != nullptr) && r->decrement())
108 delete r;
109 return true;
110 }
111 return false;
112 }
113
114 BoolExpr::BoolExpr(void) : n(new Node) {}
115
117 n->use++;
118 }
119
121 n->same = 1;
122 n->t = NT_VAR;
123 n->l = nullptr;
124 n->r = nullptr;
125 n->x = x;
126 }
127
129 : n(new Node) {
130 int ls = ((l.n->t == t) || (l.n->t == NT_VAR)) ? l.n->same : 1;
131 int rs = ((r.n->t == t) || (r.n->t == NT_VAR)) ? r.n->same : 1;
132 n->same = ls+rs;
133 n->t = t;
134 n->l = l.n;
135 n->l->use++;
136 n->r = r.n;
137 n->r->use++;
138 }
139
141 (void) t;
142 assert(t == NT_NOT);
143 if (l.n->t == NT_NOT) {
144 n = l.n->l;
145 n->use++;
146 } else {
147 n = new Node;
148 n->same = 1;
149 n->t = NT_NOT;
150 n->l = l.n;
151 n->l->use++;
152 n->r = nullptr;
153 }
154 }
155
157 : n(new Node) {
158 n->same = 1;
159 n->t = NT_RLIN;
160 n->l = nullptr;
161 n->r = nullptr;
162 n->rl = rl;
163 }
164
165#ifdef GECODE_HAS_FLOAT_VARS
167 : n(new Node) {
168 n->same = 1;
169 n->t = NT_RLINFLOAT;
170 n->l = nullptr;
171 n->r = nullptr;
172 n->rfl = rfl;
173 }
174#endif
175
176#ifdef GECODE_HAS_SET_VARS
178 : n(new Node) {
179 n->same = 1;
180 n->t = NT_RSET;
181 n->l = nullptr;
182 n->r = nullptr;
183 n->rs = rs;
184 }
185
187 : n(new Node) {
188 n->same = 1;
189 n->t = NT_RSET;
190 n->l = nullptr;
191 n->r = nullptr;
192 n->rs = rs;
193 }
194#endif
195
197 : n(new Node) {
198 n->same = 1;
199 n->t = NT_MISC;
200 n->l = nullptr;
201 n->r = nullptr;
202 n->m = m;
203 }
204
205 const BoolExpr&
207 if (this != &e) {
208 if (n->decrement())
209 delete n;
210 n = e.n;
211 n->use++;
212 }
213 return *this;
214 }
215
217
219 if (n->decrement())
220 delete n;
221 }
222
223 namespace {
225 class NNF {
226 public:
227 typedef BoolExpr::NodeType NodeType;
228 typedef BoolExpr::Node Node;
230 NodeType t;
232 int p;
234 int n;
236 union {
238 struct {
240 NNF* l;
242 NNF* r;
243 } b;
245 struct {
247 bool neg;
249 Node* x;
250 } a;
251 } u;
253 static NNF* nnf(Region& r, Node* n, bool neg);
256 void post(Home home, NodeType t,
257 BoolVarArgs& bp, BoolVarArgs& bn,
258 int& ip, int& in,
259 const IntPropLevels& ipls) const;
262 BoolVar expr(Home home, const IntPropLevels& ipls) const;
265 void rel(Home home, const IntPropLevels& ipls) const;
267 static void* operator new(size_t s, Region& r);
269 static void operator delete(void*);
271 static void operator delete(void*, Region&);
272 };
273
274 /*
275 * Operations for negation normalform
276 *
277 */
278 forceinline void
279 NNF::operator delete(void*) {}
280
281 forceinline void
282 NNF::operator delete(void*, Region&) {}
283
284 forceinline void*
285 NNF::operator new(size_t s, Region& r) {
286 return r.ralloc(s);
287 }
288
289 BoolVar
290 NNF::expr(Home home, const IntPropLevels& ipls) const {
291 if ((t == BoolExpr::NT_VAR) && !u.a.neg)
292 return u.a.x->x;
293 BoolVar b(home,0,1);
294 switch (t) {
295 case BoolExpr::NT_VAR:
296 assert(u.a.neg);
297 Gecode::rel(home, u.a.x->x, IRT_NQ, b);
298 break;
300 u.a.x->rl.post(home, b, !u.a.neg, ipls);
301 break;
302#ifdef GECODE_HAS_FLOAT_VARS
304 u.a.x->rfl.post(home, b, !u.a.neg);
305 break;
306#endif
307#ifdef GECODE_HAS_SET_VARS
309 u.a.x->rs.post(home, b, !u.a.neg);
310 break;
311#endif
313 u.a.x->m->post(home, b, u.a.neg, ipls);
314 break;
315 case BoolExpr::NT_AND:
316 {
317 BoolVarArgs bp(p), bn(n);
318 int ip=0, in=0;
319 post(home, BoolExpr::NT_AND, bp, bn, ip, in, ipls);
320 clause(home, BOT_AND, bp, bn, b);
321 }
322 break;
323 case BoolExpr::NT_OR:
324 {
325 BoolVarArgs bp(p), bn(n);
326 int ip=0, in=0;
327 post(home, BoolExpr::NT_OR, bp, bn, ip, in, ipls);
328 clause(home, BOT_OR, bp, bn, b);
329 }
330 break;
331 case BoolExpr::NT_EQV:
332 {
333 bool n = false;
334 BoolVar l;
335 if (u.b.l->t == BoolExpr::NT_VAR) {
336 l = u.b.l->u.a.x->x;
337 if (u.b.l->u.a.neg) n = !n;
338 } else {
339 l = u.b.l->expr(home,ipls);
340 }
341 BoolVar r;
342 if (u.b.r->t == BoolExpr::NT_VAR) {
343 r = u.b.r->u.a.x->x;
344 if (u.b.r->u.a.neg) n = !n;
345 } else {
346 r = u.b.r->expr(home,ipls);
347 }
348 Gecode::rel(home, l, n ? BOT_XOR : BOT_EQV, r, b);
349 }
350 break;
351 default:
353 }
354 return b;
355 }
356
357 void
358 NNF::post(Home home, NodeType t,
359 BoolVarArgs& bp, BoolVarArgs& bn,
360 int& ip, int& in,
361 const IntPropLevels& ipls) const {
362 if (this->t != t) {
363 switch (this->t) {
364 case BoolExpr::NT_VAR:
365 if (u.a.neg) {
366 bn[in++]=u.a.x->x;
367 } else {
368 bp[ip++]=u.a.x->x;
369 }
370 break;
372 {
373 BoolVar b(home,0,1);
374 u.a.x->rl.post(home, b, !u.a.neg, ipls);
375 bp[ip++]=b;
376 }
377 break;
378#ifdef GECODE_HAS_FLOAT_VARS
380 {
381 BoolVar b(home,0,1);
382 u.a.x->rfl.post(home, b, !u.a.neg);
383 bp[ip++]=b;
384 }
385 break;
386#endif
387#ifdef GECODE_HAS_SET_VARS
389 {
390 BoolVar b(home,0,1);
391 u.a.x->rs.post(home, b, !u.a.neg);
392 bp[ip++]=b;
393 }
394 break;
395#endif
397 {
398 BoolVar b(home,0,1);
399 u.a.x->m->post(home, b, u.a.neg, ipls);
400 bp[ip++]=b;
401 }
402 break;
403 default:
404 bp[ip++] = expr(home, ipls);
405 break;
406 }
407 } else {
408 u.b.l->post(home, t, bp, bn, ip, in, ipls);
409 u.b.r->post(home, t, bp, bn, ip, in, ipls);
410 }
411 }
412
413 void
414 NNF::rel(Home home, const IntPropLevels& ipls) const {
415 switch (t) {
416 case BoolExpr::NT_VAR:
417 Gecode::rel(home, u.a.x->x, IRT_EQ, u.a.neg ? 0 : 1);
418 break;
420 u.a.x->rl.post(home, !u.a.neg, ipls);
421 break;
422#ifdef GECODE_HAS_FLOAT_VARS
424 u.a.x->rfl.post(home, !u.a.neg);
425 break;
426#endif
427#ifdef GECODE_HAS_SET_VARS
429 u.a.x->rs.post(home, !u.a.neg);
430 break;
431#endif
433 {
434 BoolVar b(home,!u.a.neg,!u.a.neg);
435 u.a.x->m->post(home, b, false, ipls);
436 }
437 break;
438 case BoolExpr::NT_AND:
439 u.b.l->rel(home, ipls);
440 u.b.r->rel(home, ipls);
441 break;
442 case BoolExpr::NT_OR:
443 {
444 BoolVarArgs bp(p), bn(n);
445 int ip=0, in=0;
446 post(home, BoolExpr::NT_OR, bp, bn, ip, in, ipls);
447 clause(home, BOT_OR, bp, bn, 1);
448 }
449 break;
450 case BoolExpr::NT_EQV:
451 if (u.b.l->t==BoolExpr::NT_VAR &&
452 u.b.r->t==BoolExpr::NT_RLIN) {
453 u.b.r->u.a.x->rl.post(home, u.b.l->u.a.x->x,
454 u.b.l->u.a.neg==u.b.r->u.a.neg, ipls);
455 } else if (u.b.r->t==BoolExpr::NT_VAR &&
456 u.b.l->t==BoolExpr::NT_RLIN) {
457 u.b.l->u.a.x->rl.post(home, u.b.r->u.a.x->x,
458 u.b.l->u.a.neg==u.b.r->u.a.neg, ipls);
459 } else if (u.b.l->t==BoolExpr::NT_RLIN) {
460 u.b.l->u.a.x->rl.post(home, u.b.r->expr(home,ipls),
461 !u.b.l->u.a.neg,ipls);
462 } else if (u.b.r->t==BoolExpr::NT_RLIN) {
463 u.b.r->u.a.x->rl.post(home, u.b.l->expr(home,ipls),
464 !u.b.r->u.a.neg,ipls);
465#ifdef GECODE_HAS_FLOAT_VARS
466 } else if (u.b.l->t==BoolExpr::NT_VAR &&
467 u.b.r->t==BoolExpr::NT_RLINFLOAT) {
468 u.b.r->u.a.x->rfl.post(home, u.b.l->u.a.x->x,
469 u.b.l->u.a.neg==u.b.r->u.a.neg);
470 } else if (u.b.r->t==BoolExpr::NT_VAR &&
471 u.b.l->t==BoolExpr::NT_RLINFLOAT) {
472 u.b.l->u.a.x->rfl.post(home, u.b.r->u.a.x->x,
473 u.b.l->u.a.neg==u.b.r->u.a.neg);
474 } else if (u.b.l->t==BoolExpr::NT_RLINFLOAT) {
475 u.b.l->u.a.x->rfl.post(home, u.b.r->expr(home,ipls),
476 !u.b.l->u.a.neg);
477 } else if (u.b.r->t==BoolExpr::NT_RLINFLOAT) {
478 u.b.r->u.a.x->rfl.post(home, u.b.l->expr(home,ipls),
479 !u.b.r->u.a.neg);
480#endif
481#ifdef GECODE_HAS_SET_VARS
482 } else if (u.b.l->t==BoolExpr::NT_VAR &&
483 u.b.r->t==BoolExpr::NT_RSET) {
484 u.b.r->u.a.x->rs.post(home, u.b.l->u.a.x->x,
485 u.b.l->u.a.neg==u.b.r->u.a.neg);
486 } else if (u.b.r->t==BoolExpr::NT_VAR &&
487 u.b.l->t==BoolExpr::NT_RSET) {
488 u.b.l->u.a.x->rs.post(home, u.b.r->u.a.x->x,
489 u.b.l->u.a.neg==u.b.r->u.a.neg);
490 } else if (u.b.l->t==BoolExpr::NT_RSET) {
491 u.b.l->u.a.x->rs.post(home, u.b.r->expr(home,ipls),
492 !u.b.l->u.a.neg);
493 } else if (u.b.r->t==BoolExpr::NT_RSET) {
494 u.b.r->u.a.x->rs.post(home, u.b.l->expr(home,ipls),
495 !u.b.r->u.a.neg);
496#endif
497 } else {
498 Gecode::rel(home, expr(home, ipls), IRT_EQ, 1);
499 }
500 break;
501 default:
503 }
504 }
505
506 NNF*
507 NNF::nnf(Region& r, Node* n, bool neg) {
508 switch (n->t) {
509 case BoolExpr::NT_VAR:
512 #ifdef GECODE_HAS_FLOAT_VARS
514 #endif
515 #ifdef GECODE_HAS_SET_VARS
517 #endif
518 {
519 NNF* x = new (r) NNF;
520 x->t = n->t; x->u.a.neg = neg; x->u.a.x = n;
521 if (neg) {
522 x->p = 0; x->n = 1;
523 } else {
524 x->p = 1; x->n = 0;
525 }
526 return x;
527 }
528 case BoolExpr::NT_NOT:
529 return nnf(r,n->l,!neg);
531 {
532 NodeType t = ((n->t == BoolExpr::NT_AND) == neg) ?
534 NNF* x = new (r) NNF;
535 x->t = t;
536 x->u.b.l = nnf(r,n->l,neg);
537 x->u.b.r = nnf(r,n->r,neg);
538 int p_l, n_l;
539 if ((x->u.b.l->t == t) ||
540 (x->u.b.l->t == BoolExpr::NT_VAR)) {
541 p_l=x->u.b.l->p; n_l=x->u.b.l->n;
542 } else {
543 p_l=1; n_l=0;
544 }
545 int p_r, n_r;
546 if ((x->u.b.r->t == t) ||
547 (x->u.b.r->t == BoolExpr::NT_VAR)) {
548 p_r=x->u.b.r->p; n_r=x->u.b.r->n;
549 } else {
550 p_r=1; n_r=0;
551 }
552 x->p = p_l+p_r;
553 x->n = n_l+n_r;
554 return x;
555 }
556 case BoolExpr::NT_EQV:
557 {
558 NNF* x = new (r) NNF;
559 x->t = BoolExpr::NT_EQV;
560 x->u.b.l = nnf(r,n->l,neg);
561 x->u.b.r = nnf(r,n->r,false);
562 x->p = 2; x->n = 0;
563 return x;
564 }
565 default:
567 }
569 return nullptr;
570 }
571 }
572
573 BoolVar
574 BoolExpr::expr(Home home, const IntPropLevels& ipls) const {
575 Region r;
576 return NNF::nnf(r,n,false)->expr(home,ipls);
577 }
578
579 void
580 BoolExpr::rel(Home home, const IntPropLevels& ipls) const {
581 Region r;
582 return NNF::nnf(r,n,false)->rel(home,ipls);
583 }
584
585
587 operator &&(const BoolExpr& l, const BoolExpr& r) {
589 }
591 operator ||(const BoolExpr& l, const BoolExpr& r) {
592 return BoolExpr(l,BoolExpr::NT_OR,r);
593 }
598
601 return BoolExpr(e,BoolExpr::NT_NOT);
602 }
603
605 operator !=(const BoolExpr& l, const BoolExpr& r) {
606 return !BoolExpr(l, BoolExpr::NT_EQV, r);
607 }
609 operator ==(const BoolExpr& l, const BoolExpr& r) {
610 return BoolExpr(l, BoolExpr::NT_EQV, r);
611 }
613 operator >>(const BoolExpr& l, const BoolExpr& r) {
616 }
618 operator <<(const BoolExpr& l, const BoolExpr& r) {
621 }
622
623
624 /*
625 * Posting Boolean expressions and relations
626 *
627 */
628 BoolVar
629 expr(Home home, const BoolExpr& e, const IntPropLevels& ipls) {
630 PostInfo pi(home);
631 if (!home.failed())
632 return e.expr(home,ipls);
633 BoolVar x(home,0,1);
634 return x;
635 }
636
637 void
638 rel(Home home, const BoolExpr& e, const IntPropLevels& ipls) {
640 e.rel(home,ipls);
641 }
642
643 /*
644 * Boolean element constraints
645 *
646 */
647
650 protected:
654 int n;
657 public:
659 BElementExpr(const BoolVarArgs& b, const LinIntExpr& idx);
661 virtual ~BElementExpr(void);
663 virtual void post(Home home, BoolVar b, bool neg,
664 const IntPropLevels& ipls);
665 };
666
668 : a(static_cast<BoolExpr*>(heap.ralloc(sizeof(BoolExpr)*b.size()))), n(b.size()), idx(idx) {
669 for (int i=b.size(); i--;)
670 new (&a[i]) BoolExpr(b[i]);
671 }
672
676
677 void
679 const IntPropLevels& ipls) {
680 IntVar z = idx.post(home, ipls);
681 if (z.assigned() && (z.val() >= 0) && (z.val() < n)) {
682 BoolExpr be = neg ? (a[z.val()] == !b) : (a[z.val()] == b);
683 be.rel(home,ipls);
684 } else {
685 BoolVarArgs x(n);
686 for (int i=n; i--;)
687 x[i] = a[i].expr(home,ipls);
688 BoolVar res = neg ? (!b).expr(home,ipls) : b;
689 element(home, x, z, res, ipls.element());
690 }
691 }
692
694 element(const BoolVarArgs& b, const LinIntExpr& idx) {
695 return BoolExpr(new BElementExpr(b,idx));
696 }
697
698}
699
700// STATISTICS: minimodel-any
NNF * l
Left subtree.
struct Gecode::@603::NNF::@65::@66 b
For binary nodes (and, or, eqv)
union Gecode::@603::NNF::@65 u
Union depending on nodetype t.
NodeType t
Type of node.
int p
Number of positive literals for node type.
int n
Number of negative literals for node type.
struct Gecode::@603::NNF::@65::@67 a
For atomic nodes.
Node * x
Pointer to corresponding Boolean expression node.
NNF * r
Right subtree.
bool neg
Is atomic formula negative.
int size(void) const
Return size of array (number of elements)
Definition array.hpp:1607
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:43
BoolVar x
Possibly a variable.
Definition bool-expr.cpp:54
~Node(void)
Destructor.
Definition bool-expr.cpp:89
NodeType t
Type of expression.
Definition bool-expr.cpp:50
Node(void)
Default constructor.
Definition bool-expr.cpp:86
LinFloatRel rfl
Possibly a reified float linear relation.
Definition bool-expr.cpp:59
LinIntRel rl
Possibly a reified linear relation.
Definition bool-expr.cpp:56
Node * l
Subexpressions.
Definition bool-expr.cpp:52
SetRel rs
Possibly a reified set relation.
Definition bool-expr.cpp:63
bool decrement(void)
Decrement reference count and possibly free memory.
Misc * m
Possibly a misc Boolean expression.
Definition bool-expr.cpp:66
unsigned int use
Nodes are reference counted.
Definition bool-expr.cpp:46
int same
Number of variables in subtree with same type (for AND and OR)
Definition bool-expr.cpp:48
Boolean expressions.
BoolExpr(void)
Default constructor.
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_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:712
Boolean integer variables.
Definition int.hh:512
void free(T *b, long unsigned int n)
Delete n objects starting at b.
Definition heap.hpp:457
void rfree(void *p)
Free memory block starting at p.
Definition heap.hpp:371
void * ralloc(size_t s)
Allocate s bytes from heap.
Definition heap.hpp:357
Home class for posting propagators
Definition core.hpp:856
bool failed(void) const
Check whether corresponding space is failed.
Definition core.hpp:4048
Class for specifying integer propagation levels used by minimodel.
Definition minimodel.hh:101
IntPropLevel element(void) const
Return integer propagation level for element constraints.
Definition ipl.hpp:164
Integer variables.
Definition int.hh:371
Linear relations.
Definition minimodel.hh:896
Linear expressions over integer variables.
Definition minimodel.hh:245
void post(Home home, IntRelType irt, const IntPropLevels &ipls) const
Post propagator.
Definition int-expr.cpp:156
Linear relations over integer variables.
Definition minimodel.hh:335
Class to set group information when a post function is executed.
Definition core.hpp:948
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
VarImp * x
Pointer to variable implementation.
Definition var.hpp:50
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:926
@ IRT_NQ
Disequality ( )
Definition int.hh:927
@ BOT_OR
Disjunction.
Definition int.hh:952
@ BOT_EQV
Equivalence.
Definition int.hh:954
@ BOT_XOR
Exclusive or.
Definition int.hh:955
@ BOT_AND
Conjunction.
Definition int.hh:951
#define GECODE_MINIMODEL_EXPORT
Definition minimodel.hh:78
Gecode toplevel namespace
Post propagator for SetVar SetOpType SetVar SetRelType r
Definition set.hh:767
SetRel operator||(const SetExpr &, const SetExpr &)
Disjointness of set expressions.
Definition set-rel.cpp:71
IntVar expr(Home home, const LinIntExpr &e, const IntPropLevels &ipls=IntPropLevels::def)
Post linear expression and return its value.
Definition int-expr.cpp:915
Archive & operator<<(Archive &e, FloatNumBranch nl)
Definition val-sel.hpp:39
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.
Post propagator for SetVar SetOpType SetVar SetRelType SetVar z
Definition set.hh:767
BoolExpr operator^(const BoolExpr &, const BoolExpr &)
Exclusive-or of Boolean expressions.
BoolExpr operator&&(const BoolExpr &, const BoolExpr &)
Conjunction 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
Post propagator for SetVar x
Definition set.hh:767
bool operator==(const FloatVal &x, const FloatVal &y)
Definition val.hpp:294
bool operator!=(const FloatVal &x, const FloatVal &y)
Definition val.hpp:317
#define forceinline
Definition config.hpp:187
#define GECODE_NEVER
Assert that this command is never executed.
Definition macros.hpp:56