Generated on Thu Jan 20 2022 00:00:00 for Gecode by doxygen 1.9.1
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
64 #endif
66  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(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 
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 = 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:
228  typedef BoolExpr::Node Node;
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;
299  case BoolExpr::NT_RLIN:
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
308  case BoolExpr::NT_RSET:
309  u.a.x->rs.post(home, b, !u.a.neg);
310  break;
311 #endif
312  case BoolExpr::NT_MISC:
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:
352  GECODE_NEVER;
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;
371  case BoolExpr::NT_RLIN:
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
388  case BoolExpr::NT_RSET:
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
396  case BoolExpr::NT_MISC:
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;
419  case BoolExpr::NT_RLIN:
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
428  case BoolExpr::NT_RSET:
429  u.a.x->rs.post(home, !u.a.neg);
430  break;
431 #endif
432  case BoolExpr::NT_MISC:
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:
502  GECODE_NEVER;
503  }
504  }
505 
506  NNF*
507  NNF::nnf(Region& r, Node* n, bool neg) {
508  switch (n->t) {
509  case BoolExpr::NT_VAR:
510  case BoolExpr::NT_RLIN:
511  case BoolExpr::NT_MISC:
512  #ifdef GECODE_HAS_FLOAT_VARS
514  #endif
515  #ifdef GECODE_HAS_SET_VARS
516  case BoolExpr::NT_RSET:
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:
566  GECODE_NEVER;
567  }
568  GECODE_NEVER;
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 
586  BoolExpr
587  operator &&(const BoolExpr& l, const BoolExpr& r) {
588  return BoolExpr(l,BoolExpr::NT_AND,r);
589  }
590  BoolExpr
591  operator ||(const BoolExpr& l, const BoolExpr& r) {
592  return BoolExpr(l,BoolExpr::NT_OR,r);
593  }
594  BoolExpr
595  operator ^(const BoolExpr& l, const BoolExpr& r) {
597  }
598 
599  BoolExpr
600  operator !(const BoolExpr& e) {
601  return BoolExpr(e,BoolExpr::NT_NOT);
602  }
603 
604  BoolExpr
605  operator !=(const BoolExpr& l, const BoolExpr& r) {
606  return !BoolExpr(l, BoolExpr::NT_EQV, r);
607  }
608  BoolExpr
609  operator ==(const BoolExpr& l, const BoolExpr& r) {
610  return BoolExpr(l, BoolExpr::NT_EQV, r);
611  }
612  BoolExpr
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) {
639  GECODE_POST;
640  e.rel(home,ipls);
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,
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 
674  heap.free<BoolExpr>(a,n);
675  }
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 
693  BoolExpr
694  element(const BoolVarArgs& b, const LinIntExpr& idx) {
695  return BoolExpr(new BElementExpr(b,idx));
696  }
697 
698 }
699 
700 // STATISTICS: minimodel-any
struct Gecode::@602::NNF::@65::@66 b
For binary nodes (and, or, eqv)
NNF * l
Left subtree.
Definition: bool-expr.cpp:240
NodeType t
Type of node.
Definition: bool-expr.cpp:230
int p
Number of positive literals for node type.
Definition: bool-expr.cpp:232
union Gecode::@602::NNF::@65 u
Union depending on nodetype t.
BoolVar expr(Home home, const BoolExpr &e, const IntPropLevels &ipls)
Post Boolean expression and return its value.
Definition: bool-expr.cpp:629
int n
Number of negative literals for node type.
Definition: bool-expr.cpp:234
Node * x
Pointer to corresponding Boolean expression node.
Definition: bool-expr.cpp:249
struct Gecode::@602::NNF::@65::@67 a
For atomic nodes.
NNF * r
Right subtree.
Definition: bool-expr.cpp:242
bool neg
Is atomic formula negative.
Definition: bool-expr.cpp:247
Boolean element expressions.
Definition: bool-expr.cpp:649
LinIntExpr idx
The linear expression for the index.
Definition: bool-expr.cpp:656
int n
The number of Boolean expressions.
Definition: bool-expr.cpp:654
virtual void post(Home home, BoolVar b, bool neg, const IntPropLevels &ipls)
Constrain b to be equivalent to the expression (negated if neg)
Definition: bool-expr.cpp:678
virtual ~BElementExpr(void)
Destructor.
Definition: bool-expr.cpp:673
BElementExpr(const BoolVarArgs &b, const LinIntExpr &idx)
Constructor.
Definition: bool-expr.cpp:667
BoolExpr * a
The Boolean expressions.
Definition: bool-expr.cpp:652
Miscealloneous Boolean expressions.
Definition: minimodel.hh:1344
virtual ~Misc(void)
Destructor.
Definition: bool-expr.cpp:216
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.
Definition: bool-expr.cpp:103
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.
Definition: minimodel.hh:1329
BoolExpr(void)
Default constructor.
Definition: bool-expr.cpp:114
NodeType
Type of Boolean expression.
Definition: minimodel.hh:1332
@ NT_RLINFLOAT
Reified linear relation.
Definition: minimodel.hh:1339
@ NT_AND
Conjunction.
Definition: minimodel.hh:1335
@ NT_EQV
Equivalence.
Definition: minimodel.hh:1337
@ NT_RLIN
Reified linear relation.
Definition: minimodel.hh:1338
@ NT_VAR
Variable.
Definition: minimodel.hh:1333
@ NT_OR
Disjunction.
Definition: minimodel.hh:1336
@ NT_MISC
Other Boolean expression.
Definition: minimodel.hh:1341
@ NT_NOT
Negation.
Definition: minimodel.hh:1334
@ NT_RSET
Reified set relation.
Definition: minimodel.hh:1340
const BoolExpr & operator=(const BoolExpr &e)
Assignment operator.
Definition: bool-expr.cpp:206
BoolVar expr(Home home, const IntPropLevels &ipls) const
Post propagators for expression.
Definition: bool-expr.cpp:574
~BoolExpr(void)
Destructor.
Definition: bool-expr.cpp:218
void rel(Home home, const IntPropLevels &ipls) const
Post propagators for relation.
Definition: bool-expr.cpp:580
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)
Definition: minimodel.hh:1221
Set relations
Definition: minimodel.hh:1234
bool assigned(void) const
Test whether view is assigned.
Definition: var.hpp:111
const int * pi[]
Definition: photo.cpp:14262
void element(Home home, IntSharedArray c, IntVar x0, IntVar x1, IntPropLevel)
Post domain consistent propagator for .
Definition: element.cpp:39
Post propagator for SetVar SetOpType SetVar SetRelType SetVar z
Definition: set.hh:767
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, FloatVal n)
Propagates .
Definition: rel.cpp:43
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:904
@ 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
unsigned int size(I &i)
Size of all ranges of range iterator i.
Gecode::IntArgs i({1, 2, 3, 4})
#define forceinline
Definition: config.hpp:194
#define GECODE_NEVER
Assert that this command is never executed.
Definition: macros.hpp:56