Generated on Sat Jun 2 2018 07:17:44 for Gecode by doxygen 1.8.13
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 
40 namespace 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
62  SetRel rs;
64 #endif
65  Misc* m;
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(NULL), r(NULL), m(NULL) {}
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 != NULL) && l->decrement())
106  delete l;
107  if ((r != NULL) && r->decrement())
108  delete r;
109  return true;
110  }
111  return false;
112  }
113 
114  BoolExpr::BoolExpr(void) : n(new Node) {}
115 
116  BoolExpr::BoolExpr(const BoolExpr& e) : n(e.n) {
117  n->use++;
118  }
119 
120  BoolExpr::BoolExpr(const BoolVar& x) : n(new Node) {
121  n->same = 1;
122  n->t = NT_VAR;
123  n->l = NULL;
124  n->r = NULL;
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 = NULL;
153  }
154  }
155 
157  : n(new Node) {
158  n->same = 1;
159  n->t = NT_RLIN;
160  n->l = NULL;
161  n->r = NULL;
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 = NULL;
171  n->r = NULL;
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 = NULL;
182  n->r = NULL;
183  n->rs = rs;
184  }
185 
187  : n(new Node) {
188  n->same = 1;
189  n->t = NT_RSET;
190  n->l = NULL;
191  n->r = NULL;
192  n->rs = rs;
193  }
194 #endif
195 
197  : n(new Node) {
198  n->same = 1;
199  n->t = NT_MISC;
200  n->l = NULL;
201  n->r = NULL;
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:
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;
254  static NNF* nnf(Region& r, Node* n, bool neg);
257  void post(Home home, NodeType t,
258  BoolVarArgs& bp, BoolVarArgs& bn,
259  int& ip, int& in,
260  IntPropLevel ipl) const;
263  BoolVar expr(Home home, IntPropLevel ipl) const;
266  void rel(Home home, IntPropLevel ipl) const;
268  static void* operator new(size_t s, Region& r);
270  static void operator delete(void*);
272  static void operator delete(void*, Region&);
273  };
274 
275  /*
276  * Operations for negation normalform
277  *
278  */
279  forceinline void
280  NNF::operator delete(void*) {}
281 
282  forceinline void
283  NNF::operator delete(void*, Region&) {}
284 
285  forceinline void*
286  NNF::operator new(size_t s, Region& r) {
287  return r.ralloc(s);
288  }
289 
290  BoolVar
291  NNF::expr(Home home, IntPropLevel ipl) const {
292  if ((t == BoolExpr::NT_VAR) && !u.a.neg)
293  return u.a.x->x;
294  BoolVar b(home,0,1);
295  switch (t) {
296  case BoolExpr::NT_VAR:
297  assert(u.a.neg);
298  Gecode::rel(home, u.a.x->x, IRT_NQ, b);
299  break;
300  case BoolExpr::NT_RLIN:
301  u.a.x->rl.post(home, b, !u.a.neg, ipl);
302  break;
303 #ifdef GECODE_HAS_FLOAT_VARS
305  u.a.x->rfl.post(home, b, !u.a.neg);
306  break;
307 #endif
308 #ifdef GECODE_HAS_SET_VARS
309  case BoolExpr::NT_RSET:
310  u.a.x->rs.post(home, b, !u.a.neg);
311  break;
312 #endif
313  case BoolExpr::NT_MISC:
314  u.a.x->m->post(home, b, u.a.neg, ipl);
315  break;
316  case BoolExpr::NT_AND:
317  {
318  BoolVarArgs bp(p), bn(n);
319  int ip=0, in=0;
320  post(home, BoolExpr::NT_AND, bp, bn, ip, in, ipl);
321  clause(home, BOT_AND, bp, bn, b);
322  }
323  break;
324  case BoolExpr::NT_OR:
325  {
326  BoolVarArgs bp(p), bn(n);
327  int ip=0, in=0;
328  post(home, BoolExpr::NT_OR, bp, bn, ip, in, ipl);
329  clause(home, BOT_OR, bp, bn, b);
330  }
331  break;
332  case BoolExpr::NT_EQV:
333  {
334  bool n = false;
335  BoolVar l;
336  if (u.b.l->t == BoolExpr::NT_VAR) {
337  l = u.b.l->u.a.x->x;
338  if (u.b.l->u.a.neg) n = !n;
339  } else {
340  l = u.b.l->expr(home,ipl);
341  }
342  BoolVar r;
343  if (u.b.r->t == BoolExpr::NT_VAR) {
344  r = u.b.r->u.a.x->x;
345  if (u.b.r->u.a.neg) n = !n;
346  } else {
347  r = u.b.r->expr(home,ipl);
348  }
349  Gecode::rel(home, l, n ? BOT_XOR : BOT_EQV, r, b, ipl);
350  }
351  break;
352  default:
353  GECODE_NEVER;
354  }
355  return b;
356  }
357 
358  void
359  NNF::post(Home home, NodeType t,
360  BoolVarArgs& bp, BoolVarArgs& bn,
361  int& ip, int& in,
362  IntPropLevel ipl) const {
363  if (this->t != t) {
364  switch (this->t) {
365  case BoolExpr::NT_VAR:
366  if (u.a.neg) {
367  bn[in++]=u.a.x->x;
368  } else {
369  bp[ip++]=u.a.x->x;
370  }
371  break;
372  case BoolExpr::NT_RLIN:
373  {
374  BoolVar b(home,0,1);
375  u.a.x->rl.post(home, b, !u.a.neg, ipl);
376  bp[ip++]=b;
377  }
378  break;
379 #ifdef GECODE_HAS_FLOAT_VARS
381  {
382  BoolVar b(home,0,1);
383  u.a.x->rfl.post(home, b, !u.a.neg);
384  bp[ip++]=b;
385  }
386  break;
387 #endif
388 #ifdef GECODE_HAS_SET_VARS
389  case BoolExpr::NT_RSET:
390  {
391  BoolVar b(home,0,1);
392  u.a.x->rs.post(home, b, !u.a.neg);
393  bp[ip++]=b;
394  }
395  break;
396 #endif
397  case BoolExpr::NT_MISC:
398  {
399  BoolVar b(home,0,1);
400  u.a.x->m->post(home, b, u.a.neg, ipl);
401  bp[ip++]=b;
402  }
403  break;
404  default:
405  bp[ip++] = expr(home, ipl);
406  break;
407  }
408  } else {
409  u.b.l->post(home, t, bp, bn, ip, in, ipl);
410  u.b.r->post(home, t, bp, bn, ip, in, ipl);
411  }
412  }
413 
414  void
415  NNF::rel(Home home, IntPropLevel ipl) const {
416  switch (t) {
417  case BoolExpr::NT_VAR:
418  Gecode::rel(home, u.a.x->x, IRT_EQ, u.a.neg ? 0 : 1);
419  break;
420  case BoolExpr::NT_RLIN:
421  u.a.x->rl.post(home, !u.a.neg, ipl);
422  break;
423 #ifdef GECODE_HAS_FLOAT_VARS
425  u.a.x->rfl.post(home, !u.a.neg);
426  break;
427 #endif
428 #ifdef GECODE_HAS_SET_VARS
429  case BoolExpr::NT_RSET:
430  u.a.x->rs.post(home, !u.a.neg);
431  break;
432 #endif
433  case BoolExpr::NT_MISC:
434  {
435  BoolVar b(home,!u.a.neg,!u.a.neg);
436  u.a.x->m->post(home, b, false, ipl);
437  }
438  break;
439  case BoolExpr::NT_AND:
440  u.b.l->rel(home, ipl);
441  u.b.r->rel(home, ipl);
442  break;
443  case BoolExpr::NT_OR:
444  {
445  BoolVarArgs bp(p), bn(n);
446  int ip=0, in=0;
447  post(home, BoolExpr::NT_OR, bp, bn, ip, in, ipl);
448  clause(home, BOT_OR, bp, bn, 1);
449  }
450  break;
451  case BoolExpr::NT_EQV:
452  if (u.b.l->t==BoolExpr::NT_VAR &&
453  u.b.r->t==BoolExpr::NT_RLIN) {
454  u.b.r->u.a.x->rl.post(home, u.b.l->u.a.x->x,
455  u.b.l->u.a.neg==u.b.r->u.a.neg, ipl);
456  } else if (u.b.r->t==BoolExpr::NT_VAR &&
457  u.b.l->t==BoolExpr::NT_RLIN) {
458  u.b.l->u.a.x->rl.post(home, u.b.r->u.a.x->x,
459  u.b.l->u.a.neg==u.b.r->u.a.neg, ipl);
460  } else if (u.b.l->t==BoolExpr::NT_RLIN) {
461  u.b.l->u.a.x->rl.post(home, u.b.r->expr(home,ipl),
462  !u.b.l->u.a.neg,ipl);
463  } else if (u.b.r->t==BoolExpr::NT_RLIN) {
464  u.b.r->u.a.x->rl.post(home, u.b.l->expr(home,ipl),
465  !u.b.r->u.a.neg,ipl);
466 #ifdef GECODE_HAS_FLOAT_VARS
467  } else if (u.b.l->t==BoolExpr::NT_VAR &&
468  u.b.r->t==BoolExpr::NT_RLINFLOAT) {
469  u.b.r->u.a.x->rfl.post(home, u.b.l->u.a.x->x,
470  u.b.l->u.a.neg==u.b.r->u.a.neg);
471  } else if (u.b.r->t==BoolExpr::NT_VAR &&
472  u.b.l->t==BoolExpr::NT_RLINFLOAT) {
473  u.b.l->u.a.x->rfl.post(home, u.b.r->u.a.x->x,
474  u.b.l->u.a.neg==u.b.r->u.a.neg);
475  } else if (u.b.l->t==BoolExpr::NT_RLINFLOAT) {
476  u.b.l->u.a.x->rfl.post(home, u.b.r->expr(home,ipl),
477  !u.b.l->u.a.neg);
478  } else if (u.b.r->t==BoolExpr::NT_RLINFLOAT) {
479  u.b.r->u.a.x->rfl.post(home, u.b.l->expr(home,ipl),
480  !u.b.r->u.a.neg);
481 #endif
482 #ifdef GECODE_HAS_SET_VARS
483  } else if (u.b.l->t==BoolExpr::NT_VAR &&
484  u.b.r->t==BoolExpr::NT_RSET) {
485  u.b.r->u.a.x->rs.post(home, u.b.l->u.a.x->x,
486  u.b.l->u.a.neg==u.b.r->u.a.neg);
487  } else if (u.b.r->t==BoolExpr::NT_VAR &&
488  u.b.l->t==BoolExpr::NT_RSET) {
489  u.b.l->u.a.x->rs.post(home, u.b.r->u.a.x->x,
490  u.b.l->u.a.neg==u.b.r->u.a.neg);
491  } else if (u.b.l->t==BoolExpr::NT_RSET) {
492  u.b.l->u.a.x->rs.post(home, u.b.r->expr(home,ipl),
493  !u.b.l->u.a.neg);
494  } else if (u.b.r->t==BoolExpr::NT_RSET) {
495  u.b.r->u.a.x->rs.post(home, u.b.l->expr(home,ipl),
496  !u.b.r->u.a.neg);
497 #endif
498  } else {
499  Gecode::rel(home, expr(home, ipl), IRT_EQ, 1);
500  }
501  break;
502  default:
503  GECODE_NEVER;
504  }
505  }
506 
507  NNF*
508  NNF::nnf(Region& r, Node* n, bool neg) {
509  switch (n->t) {
510  case BoolExpr::NT_VAR:
511  case BoolExpr::NT_RLIN:
512  case BoolExpr::NT_MISC:
513  #ifdef GECODE_HAS_FLOAT_VARS
515  #endif
516  #ifdef GECODE_HAS_SET_VARS
517  case BoolExpr::NT_RSET:
518  #endif
519  {
520  NNF* x = new (r) NNF;
521  x->t = n->t; x->u.a.neg = neg; x->u.a.x = n;
522  if (neg) {
523  x->p = 0; x->n = 1;
524  } else {
525  x->p = 1; x->n = 0;
526  }
527  return x;
528  }
529  case BoolExpr::NT_NOT:
530  return nnf(r,n->l,!neg);
532  {
533  NodeType t = ((n->t == BoolExpr::NT_AND) == neg) ?
535  NNF* x = new (r) NNF;
536  x->t = t;
537  x->u.b.l = nnf(r,n->l,neg);
538  x->u.b.r = nnf(r,n->r,neg);
539  int p_l, n_l;
540  if ((x->u.b.l->t == t) ||
541  (x->u.b.l->t == BoolExpr::NT_VAR)) {
542  p_l=x->u.b.l->p; n_l=x->u.b.l->n;
543  } else {
544  p_l=1; n_l=0;
545  }
546  int p_r, n_r;
547  if ((x->u.b.r->t == t) ||
548  (x->u.b.r->t == BoolExpr::NT_VAR)) {
549  p_r=x->u.b.r->p; n_r=x->u.b.r->n;
550  } else {
551  p_r=1; n_r=0;
552  }
553  x->p = p_l+p_r;
554  x->n = n_l+n_r;
555  return x;
556  }
557  case BoolExpr::NT_EQV:
558  {
559  NNF* x = new (r) NNF;
560  x->t = BoolExpr::NT_EQV;
561  x->u.b.l = nnf(r,n->l,neg);
562  x->u.b.r = nnf(r,n->r,false);
563  x->p = 2; x->n = 0;
564  return x;
565  }
566  default:
567  GECODE_NEVER;
568  }
569  GECODE_NEVER;
570  return NULL;
571  }
572  }
573 
574  BoolVar
575  BoolExpr::expr(Home home, IntPropLevel ipl) const {
576  Region r;
577  return NNF::nnf(r,n,false)->expr(home,ipl);
578  }
579 
580  void
581  BoolExpr::rel(Home home, IntPropLevel ipl) const {
582  Region r;
583  return NNF::nnf(r,n,false)->rel(home,ipl);
584  }
585 
586 
587  BoolExpr
588  operator &&(const BoolExpr& l, const BoolExpr& r) {
589  return BoolExpr(l,BoolExpr::NT_AND,r);
590  }
591  BoolExpr
592  operator ||(const BoolExpr& l, const BoolExpr& r) {
593  return BoolExpr(l,BoolExpr::NT_OR,r);
594  }
595  BoolExpr
596  operator ^(const BoolExpr& l, const BoolExpr& r) {
598  }
599 
600  BoolExpr
601  operator !(const BoolExpr& e) {
602  return BoolExpr(e,BoolExpr::NT_NOT);
603  }
604 
605  BoolExpr
606  operator !=(const BoolExpr& l, const BoolExpr& r) {
607  return !BoolExpr(l, BoolExpr::NT_EQV, r);
608  }
609  BoolExpr
610  operator ==(const BoolExpr& l, const BoolExpr& r) {
611  return BoolExpr(l, BoolExpr::NT_EQV, r);
612  }
613  BoolExpr
614  operator >>(const BoolExpr& l, const BoolExpr& r) {
616  BoolExpr::NT_OR,r);
617  }
618  BoolExpr
619  operator <<(const BoolExpr& l, const BoolExpr& r) {
621  BoolExpr::NT_OR,l);
622  }
623  /*
624  * Posting Boolean expressions and relations
625  *
626  */
627  BoolVar
628  expr(Home home, const BoolExpr& e, IntPropLevel ipl) {
629  PostInfo pi(home);
630  if (!home.failed())
631  return e.expr(home,ipl);
632  BoolVar x(home,0,1);
633  return x;
634  }
635 
636  void
637  rel(Home home, const BoolExpr& e, IntPropLevel ipl) {
638  GECODE_POST;
639  if (home.failed()) return;
640  e.rel(home,ipl);
641  }
642 
643  /*
644  * Boolean element constraints
645  *
646  */
647 
649  class BElementExpr : public BoolExpr::Misc {
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, IntPropLevel ipl);
664  };
665 
667  : a(static_cast<BoolExpr*>(heap.ralloc(sizeof(BoolExpr)*b.size()))), n(b.size()), idx(idx) {
668  for (int i=b.size(); i--;)
669  new (&a[i]) BoolExpr(b[i]);
670  }
671 
673  heap.free<BoolExpr>(a,n);
674  }
675 
676  void
677  BElementExpr::post(Home home, BoolVar b, bool neg, IntPropLevel ipl) {
678  IntVar z = idx.post(home, ipl);
679  if (z.assigned() && (z.val() >= 0) && (z.val() < n)) {
680  BoolExpr be = neg ? (a[z.val()] == !b) : (a[z.val()] == b);
681  be.rel(home,ipl);
682  } else {
683  BoolVarArgs x(n);
684  for (int i=n; i--;)
685  x[i] = a[i].expr(home,ipl);
686  BoolVar res = neg ? (!b).expr(home,ipl) : b;
687  element(home, x, z, res, ipl);
688  }
689  }
690 
691  BoolExpr
692  element(const BoolVarArgs& b, const LinIntExpr& idx) {
693  return BoolExpr(new BElementExpr(b,idx));
694  }
695 
696 }
697 
698 // STATISTICS: minimodel-any
const BoolExpr & operator=(const BoolExpr &e)
Assignment operator.
Definition: bool-expr.cpp:206
NodeType t
Type of node.
Definition: bool-expr.cpp:230
NNF * l
Left subtree.
Definition: bool-expr.cpp:240
int size(void) const
Return size of array (number of elements)
Definition: array.hpp:1653
void post(Home home, Term *t, int n, FloatRelType frt, FloatVal c)
Post propagator for linear constraint over floats.
Definition: post.cpp:238
Set relations
Definition: minimodel.hh:1130
void rfree(void *p)
Free memory block starting at p.
Definition: heap.hpp:371
LinIntExpr idx
The linear expression for the index.
Definition: bool-expr.cpp:656
int same
Number of variables in subtree with same type (for AND and OR)
Definition: bool-expr.cpp:48
Reified linear relation.
Definition: minimodel.hh:1235
Misc * m
Possibly a misc Boolean expression.
Definition: bool-expr.cpp:66
bool assigned(void) const
Test whether view is assigned.
Definition: var.hpp:119
Node for Boolean expression
Definition: bool-expr.cpp:43
Linear relations over integer variables.
Definition: minimodel.hh:230
Conjunction.
Definition: int.hh:926
Node * l
Subexpressions.
Definition: bool-expr.cpp:52
void * ralloc(size_t s)
Allocate s bytes from heap.
Definition: heap.hpp:357
BoolExpr * a
The Boolean expressions.
Definition: bool-expr.cpp:652
~BoolExpr(void)
Destructor.
Definition: bool-expr.cpp:218
Handle to region.
Definition: region.hpp:53
#define forceinline
Definition: config.hpp:185
Comparison relation (for two-sided comparisons)
Definition: minimodel.hh:1117
Exclusive or.
Definition: int.hh:930
BoolExpr operator^(const BoolExpr &l, const BoolExpr &r)
Exclusive-or of Boolean expressions.
Definition: bool-expr.cpp:596
Reified linear relation.
Definition: minimodel.hh:1234
void rel(Home home, IntPropLevel ipl) const
Post propagators for relation.
Definition: bool-expr.cpp:581
BoolExpr operator&&(const BoolExpr &l, const BoolExpr &r)
Conjunction of Boolean expressions.
Definition: bool-expr.cpp:588
Miscealloneous Boolean expressions.
Definition: minimodel.hh:1240
int p
Number of positive literals for node type.
Definition: bool-expr.cpp:232
Gecode::IntArgs i(4, 1, 2, 3, 4)
IntRelType neg(IntRelType irt)
Return negated relation type of irt.
Definition: irt.hpp:52
int n
Number of negative literals for node type.
Definition: bool-expr.cpp:234
Equality ( )
Definition: int.hh:901
BoolVar x
Possibly a variable.
Definition: bool-expr.cpp:54
Linear relations.
Definition: minimodel.hh:792
Class to set group information when a post function is executed.
Definition: core.hpp:945
bool operator!=(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:317
int val(void) const
Return assigned value.
Definition: int.hpp:56
bool failed(void) const
Check whether corresponding space is failed.
Definition: core.hpp:3967
unsigned int size(I &i)
Size of all ranges of range iterator i.
Reified set relation.
Definition: minimodel.hh:1236
union Gecode::@585::NNF::@62 u
Union depending on nodetype t.
void post(Home home, IntRelType irt, IntPropLevel ipl) const
Post propagator.
Definition: int-expr.cpp:156
const int * pi[]
Definition: photo.cpp:14262
virtual void post(Home home, BoolVar b, bool neg, IntPropLevel ipl)
Constrain b to be equivalent to the expression (negated if neg)
Definition: bool-expr.cpp:677
Post propagator for SetVar SetOpType SetVar SetRelType SetVar z
Definition: set.hh:765
SetRel rs
Possibly a reified set relation.
Definition: bool-expr.cpp:63
Disjunction.
Definition: int.hh:927
Boolean expressions.
Definition: minimodel.hh:1225
NodeType t
Type of expression.
Definition: bool-expr.cpp:50
Passing Boolean variables.
Definition: int.hh:687
BoolVar expr(Home home, const BoolExpr &e, IntPropLevel ipl)
Post Boolean expression and return its value.
Definition: bool-expr.cpp:628
Other Boolean expression.
Definition: minimodel.hh:1237
Boolean integer variables.
Definition: int.hh:488
Post propagator for SetVar SetOpType SetVar SetRelType r
Definition: set.hh:765
Archive & operator>>(Archive &e, FloatNumBranch &nl)
Definition: val-sel.hpp:44
IntPropLevel
Propagation levels for integer propagators.
Definition: int.hh:949
struct Gecode::@585::NNF::@62::@63 b
For binary nodes (and, or, eqv)
NodeType
Type of Boolean expression.
Definition: minimodel.hh:1228
int n
The number of Boolean expressions.
Definition: bool-expr.cpp:654
void free(T *b, long unsigned int n)
Delete n objects starting at b.
Definition: heap.hpp:457
BElementExpr(const BoolVarArgs &b, const LinIntExpr &idx)
Constructor.
Definition: bool-expr.cpp:666
struct Gecode::@585::NNF::@62::@64 a
For atomic nodes.
Linear expressions over integer variables.
Definition: minimodel.hh:140
Boolean element expressions.
Definition: bool-expr.cpp:649
~Node(void)
Destructor.
Definition: bool-expr.cpp:89
LinFloatRel rfl
Possibly a reified float linear relation.
Definition: bool-expr.cpp:59
Integer variables.
Definition: int.hh:347
Heap heap
The single global heap.
Definition: heap.cpp:44
void rel(Home home, FloatVar x0, FloatRelType frt, FloatVal n)
Propagates .
Definition: rel.cpp:43
Equivalence.
Definition: int.hh:929
BoolExpr operator!(const BoolExpr &e)
Negated Boolean expression.
Definition: bool-expr.cpp:601
Node(void)
Default constructor.
Definition: bool-expr.cpp:86
void rel(Home home, const BoolExpr &e, IntPropLevel ipl)
Post Boolean relation.
Definition: bool-expr.cpp:637
Post propagator for SetVar x
Definition: set.hh:765
Archive & operator<<(Archive &e, FloatNumBranch nl)
Definition: val-sel.hpp:39
#define GECODE_MINIMODEL_EXPORT
Definition: minimodel.hh:78
virtual ~BElementExpr(void)
Destructor.
Definition: bool-expr.cpp:672
bool operator==(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:294
Gecode toplevel namespace
Disequality ( )
Definition: int.hh:902
BoolVar expr(Home home, IntPropLevel ipl) const
Post propagators for expression.
Definition: bool-expr.cpp:575
LinIntRel rl
Possibly a reified linear relation.
Definition: bool-expr.cpp:56
#define GECODE_POST
Check for failure in a constraint post function.
Definition: macros.hpp:40
Home class for posting propagators
Definition: core.hpp:853
bool decrement(void)
Decrement reference count and possibly free memory.
Definition: bool-expr.cpp:103
virtual ~Misc(void)
Destructor.
Definition: bool-expr.cpp:216
#define GECODE_NEVER
Assert that this command is never executed.
Definition: macros.hpp:56
void element(Home home, IntSharedArray c, IntVar x0, IntVar x1, IntPropLevel)
Post domain consistent propagator for .
Definition: element.cpp:39
BoolExpr operator||(const BoolExpr &l, const BoolExpr &r)
Disjunction of Boolean expressions.
Definition: bool-expr.cpp:592
TFE post(PropagatorGroup g)
Only post functions (but not propagators) from g are considered.
Definition: filter.cpp:138
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...
Definition: bool.cpp:906
BoolExpr(void)
Default constructor.
Definition: bool-expr.cpp:114
unsigned int use
Nodes are reference counted.
Definition: bool-expr.cpp:46