Go to the documentation of this file.
61 #ifdef GECODE_HAS_FLOAT_VARS
65 #ifdef GECODE_HAS_SET_VARS
80 static void*
operator new(
size_t size);
82 static void operator delete(
void*
p,
size_t size);
91 : use(1),
l(NULL),
r(NULL), m(NULL) {}
98 BoolExpr::Node::operator
new(
size_t size) {
102 BoolExpr::Node::operator
delete(
void*
p, size_t) {
109 if ((
l != NULL) &&
l->decrement())
111 if ((
r != NULL) &&
r->decrement())
134 int ls = ((
l.n->t ==
t) || (
l.n->t ==
NT_VAR)) ?
l.n->same : 1;
169 #ifdef GECODE_HAS_FLOAT_VARS
180 #ifdef GECODE_HAS_SET_VARS
258 static NNF* nnf(Region&
r, Node* n,
bool neg);
262 BoolVarArgs& bp, BoolVarArgs& bn,
272 static void*
operator new(
size_t s, Region&
r);
274 static void operator delete(
void*);
276 static void operator delete(
void*, Region&);
284 NNF::operator
delete(
void*) {}
287 NNF::operator
delete(
void*, Region&) {}
290 NNF::operator
new(
size_t s, Region&
r) {
305 u.a.x->rl.post(home,
b, !
u.a.neg, ipl);
307 #ifdef GECODE_HAS_FLOAT_VARS
309 u.a.x->rfl.post(home,
b, !
u.a.neg);
312 #ifdef GECODE_HAS_SET_VARS
314 u.a.x->rs.post(home,
b, !
u.a.neg);
318 u.a.x->m->post(home,
b,
u.a.neg, ipl);
322 BoolVarArgs bp(
p), bn(n);
330 BoolVarArgs bp(
p), bn(n);
342 if (
u.b.l->u.a.neg)
n = !
n;
344 l =
u.b.l->expr(home,ipl);
349 if (
u.b.r->u.a.neg)
n = !
n;
351 r =
u.b.r->expr(home,ipl);
364 BoolVarArgs& bp, BoolVarArgs& bn,
379 u.a.x->rl.post(home,
b, !
u.a.neg, ipl);
383 #ifdef GECODE_HAS_FLOAT_VARS
387 u.a.x->rfl.post(home,
b, !
u.a.neg);
392 #ifdef GECODE_HAS_SET_VARS
396 u.a.x->rs.post(home,
b, !
u.a.neg);
404 u.a.x->m->post(home,
b,
u.a.neg, ipl);
409 bp[ip++] =
expr(home, ipl);
413 u.b.l->post(home,
t, bp, bn, ip, in, ipl);
414 u.b.r->post(home,
t, bp, bn, ip, in, ipl);
425 u.a.x->rl.post(home, !
u.a.neg, ipl);
427 #ifdef GECODE_HAS_FLOAT_VARS
429 u.a.x->rfl.post(home, !
u.a.neg);
432 #ifdef GECODE_HAS_SET_VARS
434 u.a.x->rs.post(home, !
u.a.neg);
439 BoolVar
b(home,!
u.a.neg,!
u.a.neg);
440 u.a.x->m->post(home,
b,
false, ipl);
444 u.b.l->rel(home, ipl);
445 u.b.r->rel(home, ipl);
449 BoolVarArgs bp(
p), bn(n);
458 u.b.r->u.a.x->rl.post(home,
u.b.l->u.a.x->x,
459 u.b.l->u.a.neg==
u.b.r->u.a.neg, ipl);
462 u.b.l->u.a.x->rl.post(home,
u.b.r->u.a.x->x,
463 u.b.l->u.a.neg==
u.b.r->u.a.neg, ipl);
465 u.b.l->u.a.x->rl.post(home,
u.b.r->expr(home,ipl),
466 !
u.b.l->u.a.neg,ipl);
468 u.b.r->u.a.x->rl.post(home,
u.b.l->expr(home,ipl),
469 !
u.b.r->u.a.neg,ipl);
470 #ifdef GECODE_HAS_FLOAT_VARS
473 u.b.r->u.a.x->rfl.post(home,
u.b.l->u.a.x->x,
474 u.b.l->u.a.neg==
u.b.r->u.a.neg);
477 u.b.l->u.a.x->rfl.post(home,
u.b.r->u.a.x->x,
478 u.b.l->u.a.neg==
u.b.r->u.a.neg);
480 u.b.l->u.a.x->rfl.post(home,
u.b.r->expr(home,ipl),
483 u.b.r->u.a.x->rfl.post(home,
u.b.l->expr(home,ipl),
486 #ifdef GECODE_HAS_SET_VARS
489 u.b.r->u.a.x->rs.post(home,
u.b.l->u.a.x->x,
490 u.b.l->u.a.neg==
u.b.r->u.a.neg);
493 u.b.l->u.a.x->rs.post(home,
u.b.r->u.a.x->x,
494 u.b.l->u.a.neg==
u.b.r->u.a.neg);
496 u.b.l->u.a.x->rs.post(home,
u.b.r->expr(home,ipl),
499 u.b.r->u.a.x->rs.post(home,
u.b.l->expr(home,ipl),
512 NNF::nnf(Region&
r, Node* n,
bool neg) {
517 #ifdef GECODE_HAS_FLOAT_VARS
520 #ifdef GECODE_HAS_SET_VARS
524 NNF*
x =
new (
r) NNF;
525 x->t =
n->t;
x->u.a.neg =
neg;
x->u.a.
x =
n;
534 return nnf(
r,
n->l,!
neg);
539 NNF*
x =
new (
r) NNF;
541 x->u.b.l = nnf(
r,
n->l,
neg);
542 x->u.b.r = nnf(
r,
n->r,
neg);
544 if ((
x->u.b.l->t ==
t) ||
546 p_l=
x->u.b.l->p; n_l=
x->u.b.l->n;
551 if ((
x->u.b.r->t ==
t) ||
553 p_r=
x->u.b.r->p; n_r=
x->u.b.r->n;
563 NNF*
x =
new (
r) NNF;
565 x->u.b.l = nnf(
r,
n->l,
neg);
566 x->u.b.r = nnf(
r,
n->r,
false);
581 return NNF::nnf(
r,
n,
false)->expr(home,ipl);
587 return NNF::nnf(
r,
n,
false)->rel(home,ipl);
635 return e.
expr(home,ipl);
643 if (home.
failed())
return;
672 for (
int i=
b.size();
i--;)
int n
The number of Boolean expressions.
Post propagator for SetVar x
Archive & operator>>(Archive &e, FloatNumBranch &nl)
BoolVar expr(Home home, const BoolExpr &e, IntPropLevel ipl)
Post Boolean expression and return its value.
void element(Home home, IntSharedArray c, IntVar x0, IntVar x1, IntPropLevel)
Post domain consistent propagator for .
unsigned int size(I &i)
Size of all ranges of range iterator i.
void post(Home home, Term *t, int n, FloatRelType frt, FloatVal c)
Post propagator for linear constraint over floats.
Comparison relation (for two-sided comparisons)
@ NT_MISC
Other Boolean expression.
Post propagator for SetVar SetOpType SetVar SetRelType SetVar z
Gecode::IntArgs i(4, 1, 2, 3, 4)
virtual ~BElementExpr(void)
Destructor.
bool same(const VarImpVar< VarImp > &y) const
Test whether variable is the same as y.
void * ralloc(size_t s)
Allocate s bytes from heap.
@ NT_RLIN
Reified linear relation.
LinIntRel rl
Possibly a reified linear relation.
BElementExpr(const BoolVarArgs &b, const LinIntExpr &idx)
Constructor.
Linear expressions over integer variables.
bool decrement(void)
Decrement reference count and possibly free memory.
IntPropLevel
Propagation levels for integer propagators.
LinFloatRel rfl
Possibly a reified float linear relation.
bool assigned(void) const
Test whether view is assigned.
NodeType t
Type of expression.
union Gecode::@579::NNF::@61 u
Union depending on nodetype t.
BoolExpr operator^(const BoolExpr &l, const BoolExpr &r)
Exclusive-or of Boolean expressions.
Node(void)
Default constructor.
BoolVar x
Possibly a variable.
~BoolExpr(void)
Destructor.
Gecode toplevel namespace
Misc * m
Possibly a misc Boolean expression.
VarImp * x
Pointer to variable implementation.
Boolean element expressions.
@ NT_RLINFLOAT
Reified linear relation.
BoolExpr operator!(const BoolExpr &e)
Negated Boolean expression.
Passing Boolean variables.
void rel(Home home, IntPropLevel ipl) const
Post propagators for relation.
Home class for posting propagators
struct Gecode::@579::NNF::@61::@63 a
For atomic nodes.
struct Gecode::@579::NNF::@61::@62 b
For binary nodes (and, or, eqv)
Linear relations over integer variables.
Post propagator for SetVar SetOpType SetVar SetRelType r
LinIntExpr idx
The linear expression for the index.
Boolean integer variables.
virtual ~Misc(void)
Destructor.
TFE post(PropagatorGroup g)
Only post functions (but not propagators) from g are considered.
BoolExpr operator&&(const BoolExpr &l, const BoolExpr &r)
Conjunction of Boolean expressions.
NodeType
Type of Boolean expression.
Class to set group information when a post function is executed.
#define GECODE_NEVER
Assert that this command is never executed.
bool operator!=(const FloatVal &x, const FloatVal &y)
Heap heap
The single global heap.
IntRelType neg(IntRelType irt)
Return negated relation type of irt.
void post(Home home, IntRelType irt, IntPropLevel ipl) const
Post propagator.
BoolVar expr(Home home, IntPropLevel ipl) const
Post propagators for expression.
unsigned int use
Nodes are reference counted.
bool failed(void) const
Check whether corresponding space is failed.
void rel(Home home, FloatVar x0, FloatRelType frt, FloatVal n)
Propagates .
BoolExpr * a
The Boolean expressions.
int same
Number of variables in subtree with same type (for AND and OR)
Node for Boolean expression
void free(T *b, long unsigned int n)
Delete n objects starting at b.
#define GECODE_POST
Check for failure in a constraint post function.
#define GECODE_MINIMODEL_EXPORT
Miscealloneous Boolean expressions.
const BoolExpr & operator=(const BoolExpr &e)
Assignment operator.
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 operator||(const BoolExpr &l, const BoolExpr &r)
Disjunction of Boolean expressions.
BoolExpr(void)
Default constructor.
int n
Number of negative literals for node type.
void rfree(void *p)
Free memory block starting at p.
void rel(Home home, const BoolExpr &e, IntPropLevel ipl)
Post Boolean relation.
int p
Number of positive literals for node type.
SetRel rs
Possibly a reified set relation.
Archive & operator<<(Archive &e, FloatNumBranch nl)
@ NT_RSET
Reified set relation.
bool operator==(const FloatVal &x, const FloatVal &y)
virtual void post(Home home, BoolVar b, bool neg, IntPropLevel ipl)
Constrain b to be equivalent to the expression (negated if neg)