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) {
134 int ls = ((l.n->
t ==
t) || (l.n->
t ==
NT_VAR)) ? l.n->
same : 1;
135 int rs = ((r.n->
t == t) || (r.n->
t ==
NT_VAR)) ? r.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);
261 void post(Home home, NodeType t,
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--;)
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.
struct Gecode::@554::NNF::@60::@62 a
For atomic nodes.
int p
Number of positive literals for node type.
Gecode::IntArgs i(4, 1, 2, 3, 4)
int n
Number of negative literals for node type.
union Gecode::@554::NNF::@60 u
Union depending on nodetype t.
BoolVar x
Possibly a variable.
Class to set group information when a post function is executed.
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.
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)
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.
Boolean integer variables.
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.
Node * x
Pointer to corresponding Boolean expression node.
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.
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.
struct Gecode::@554::NNF::@60::@61 b
For binary nodes (and, or, eqv)
#define GECODE_POST
Check for failure in a constraint post function.
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.
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.
bool neg
Is atomic formula negative.
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.