57 #ifdef GECODE_HAS_FLOAT_VARS 61 #ifdef GECODE_HAS_SET_VARS 76 static void*
operator new(
size_t size);
78 static void operator delete(
void*
p,
size_t size);
87 :
use(1),
l(NULL),
r(NULL),
m(NULL) {}
94 BoolExpr::Node::operator
new(
size_t size) {
98 BoolExpr::Node::operator
delete(
void*
p, size_t) {
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;
165 #ifdef GECODE_HAS_FLOAT_VARS 176 #ifdef GECODE_HAS_SET_VARS 253 static NNF* nnf(Region&
r, Node* n,
bool neg);
256 void post(Home home, NodeType t,
257 BoolVarArgs& bp, BoolVarArgs& bn,
267 static void*
operator new(
size_t s, Region&
r);
269 static void operator delete(
void*);
271 static void operator delete(
void*, Region&);
279 NNF::operator
delete(
void*) {}
282 NNF::operator
delete(
void*, Region&) {}
285 NNF::operator
new(
size_t s, Region&
r) {
300 u.a.x->rl.post(home,
b, !
u.a.neg, ipl);
302 #ifdef GECODE_HAS_FLOAT_VARS 304 u.a.x->rfl.post(home,
b, !
u.a.neg);
307 #ifdef GECODE_HAS_SET_VARS 309 u.a.x->rs.post(home,
b, !
u.a.neg);
313 u.a.x->m->post(home,
b,
u.a.neg, ipl);
317 BoolVarArgs bp(p), bn(n);
325 BoolVarArgs bp(p), bn(n);
337 if (
u.b.l->u.a.neg) n = !n;
339 l =
u.b.l->expr(home,ipl);
344 if (
u.b.r->u.a.neg) n = !n;
346 r =
u.b.r->expr(home,ipl);
359 BoolVarArgs& bp, BoolVarArgs& bn,
374 u.a.x->rl.post(home,
b, !
u.a.neg, ipl);
378 #ifdef GECODE_HAS_FLOAT_VARS 382 u.a.x->rfl.post(home,
b, !
u.a.neg);
387 #ifdef GECODE_HAS_SET_VARS 391 u.a.x->rs.post(home,
b, !
u.a.neg);
399 u.a.x->m->post(home,
b,
u.a.neg, ipl);
404 bp[ip++] =
expr(home, ipl);
408 u.b.l->post(home, t, bp, bn, ip, in, ipl);
409 u.b.r->post(home, t, bp, bn, ip, in, ipl);
420 u.a.x->rl.post(home, !
u.a.neg, ipl);
422 #ifdef GECODE_HAS_FLOAT_VARS 424 u.a.x->rfl.post(home, !
u.a.neg);
427 #ifdef GECODE_HAS_SET_VARS 429 u.a.x->rs.post(home, !
u.a.neg);
434 BoolVar
b(home,!
u.a.neg,!
u.a.neg);
435 u.a.x->m->post(home,
b,
false, ipl);
439 u.b.l->rel(home, ipl);
440 u.b.r->rel(home, ipl);
444 BoolVarArgs bp(p), bn(n);
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, ipl);
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, ipl);
460 u.b.l->u.a.x->rl.post(home,
u.b.r->expr(home,ipl),
461 !
u.b.l->u.a.neg,ipl);
463 u.b.r->u.a.x->rl.post(home,
u.b.l->expr(home,ipl),
464 !
u.b.r->u.a.neg,ipl);
465 #ifdef GECODE_HAS_FLOAT_VARS 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);
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);
475 u.b.l->u.a.x->rfl.post(home,
u.b.r->expr(home,ipl),
478 u.b.r->u.a.x->rfl.post(home,
u.b.l->expr(home,ipl),
481 #ifdef GECODE_HAS_SET_VARS 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);
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);
491 u.b.l->u.a.x->rs.post(home,
u.b.r->expr(home,ipl),
494 u.b.r->u.a.x->rs.post(home,
u.b.l->expr(home,ipl),
507 NNF::nnf(Region& r, Node* n,
bool neg) {
512 #ifdef GECODE_HAS_FLOAT_VARS 515 #ifdef GECODE_HAS_SET_VARS 519 NNF*
x =
new (
r) NNF;
520 x->t = n->t; x->u.a.neg =
neg; x->u.a.x = n;
529 return nnf(r,n->l,!neg);
534 NNF* x =
new (
r) NNF;
536 x->u.b.l = nnf(r,n->l,neg);
537 x->u.b.r = nnf(r,n->r,neg);
539 if ((x->u.b.l->t == t) ||
541 p_l=x->u.b.l->p; n_l=x->u.b.l->n;
546 if ((x->u.b.r->t == t) ||
548 p_r=x->u.b.r->p; n_r=x->u.b.r->n;
558 NNF* x =
new (
r) NNF;
560 x->u.b.l = nnf(r,n->l,neg);
561 x->u.b.r = nnf(r,n->r,
false);
576 return NNF::nnf(r,n,
false)->expr(home,ipl);
582 return NNF::nnf(r,n,
false)->rel(home,ipl);
629 return e.
expr(home,ipl);
636 if (home.
failed())
return;
665 for (
int i=b.
size();
i--;)
const BoolExpr & operator=(const BoolExpr &e)
Assignment operator.
int size(void) const
Return size of array (number of elements)
void post(Home home, Term *t, int n, FloatRelType frt, FloatVal c)
Post propagator for linear constraint over floats.
void rfree(void *p)
Free memory block starting at p.
LinIntExpr idx
The linear expression for the index.
int same
Number of variables in subtree with same type (for AND and OR)
Misc * m
Possibly a misc Boolean expression.
bool assigned(void) const
Test whether view is assigned.
Node for Boolean expression
Linear relations over integer variables.
void * ralloc(size_t s)
Allocate s bytes from heap.
BoolExpr * a
The Boolean expressions.
~BoolExpr(void)
Destructor.
Comparison relation (for two-sided comparisons)
BoolExpr operator^(const BoolExpr &l, const BoolExpr &r)
Exclusive-or of Boolean expressions.
void rel(Home home, IntPropLevel ipl) const
Post propagators for relation.
BoolExpr operator&&(const BoolExpr &l, const BoolExpr &r)
Conjunction of Boolean expressions.
Miscealloneous Boolean expressions.
int p
Number of positive literals for node type.
IntRelType neg(IntRelType irt)
Return negated relation type of irt.
int n
Number of negative literals for node type.
Gecode::IntArgs i({1, 2, 3, 4})
BoolVar x
Possibly a variable.
bool operator!=(const FloatVal &x, const FloatVal &y)
int val(void) const
Return assigned value.
bool failed(void) const
Check whether corresponding space is failed.
struct Gecode::@593::NNF::@62::@63 b
For binary nodes (and, or, eqv)
unsigned int size(I &i)
Size of all ranges of range iterator i.
void post(Home home, IntRelType irt, IntPropLevel ipl) const
Post propagator.
virtual void post(Home home, BoolVar b, bool neg, IntPropLevel ipl)
Constrain b to be equivalent to the expression (negated if neg)
Post propagator for SetVar SetOpType SetVar SetRelType SetVar z
SetRel rs
Possibly a reified set relation.
NodeType t
Type of expression.
Passing Boolean variables.
BoolVar expr(Home home, const BoolExpr &e, IntPropLevel ipl)
Post Boolean expression and return its value.
Other Boolean expression.
union Gecode::@593::NNF::@62 u
Union depending on nodetype t.
Boolean integer variables.
Post propagator for SetVar SetOpType SetVar SetRelType r
Archive & operator>>(Archive &e, FloatNumBranch &nl)
IntPropLevel
Propagation levels for integer propagators.
NodeType
Type of Boolean expression.
int n
The number of Boolean expressions.
void free(T *b, long unsigned int n)
Delete n objects starting at b.
BElementExpr(const BoolVarArgs &b, const LinIntExpr &idx)
Constructor.
Linear expressions over integer variables.
Boolean element expressions.
LinFloatRel rfl
Possibly a reified float linear relation.
Heap heap
The single global heap.
void rel(Home home, FloatVar x0, FloatRelType frt, FloatVal n)
Propagates .
BoolExpr operator!(const BoolExpr &e)
Negated Boolean expression.
Node(void)
Default constructor.
void rel(Home home, const BoolExpr &e, IntPropLevel ipl)
Post Boolean relation.
Post propagator for SetVar x
Archive & operator<<(Archive &e, FloatNumBranch nl)
#define GECODE_MINIMODEL_EXPORT
virtual ~BElementExpr(void)
Destructor.
bool operator==(const FloatVal &x, const FloatVal &y)
Gecode toplevel namespace
BoolVar expr(Home home, IntPropLevel ipl) const
Post propagators for expression.
LinIntRel rl
Possibly a reified linear relation.
Home class for posting propagators
bool decrement(void)
Decrement reference count and possibly free memory.
virtual ~Misc(void)
Destructor.
#define GECODE_NEVER
Assert that this command is never executed.
struct Gecode::@593::NNF::@62::@64 a
For atomic nodes.
void element(Home home, IntSharedArray c, IntVar x0, IntVar x1, IntPropLevel)
Post domain consistent propagator for .
BoolExpr operator||(const BoolExpr &l, const BoolExpr &r)
Disjunction of Boolean expressions.
TFE post(PropagatorGroup g)
Only post functions (but not propagators) from g are considered.
void clause(Home home, BoolOpType o, const BoolVarArgs &x, const BoolVarArgs &y, int n, IntPropLevel)
Post domain consistent propagator for Boolean clause with positive variables x and negative variables...
BoolExpr(void)
Default constructor.
unsigned int use
Nodes are reference counted.