Generated on Sat Feb 7 2015 02:01:24 for Gecode by doxygen 1.8.9.1
bool-post.cpp
Go to the documentation of this file.
1 /* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
2 /*
3  * Main authors:
4  * Christian Schulte <schulte@gecode.org>
5  * Tias Guns <tias.guns@cs.kuleuven.be>
6  *
7  * Copyright:
8  * Christian Schulte, 2002
9  * Tias Guns, 2009
10  *
11  * Last modified:
12  * $Date: 2013-02-14 16:29:11 +0100 (Thu, 14 Feb 2013) $ by $Author: schulte $
13  * $Revision: 13292 $
14  *
15  * This file is part of Gecode, the generic constraint
16  * development environment:
17  * http://www.gecode.org
18  *
19  * Permission is hereby granted, free of charge, to any person obtaining
20  * a copy of this software and associated documentation files (the
21  * "Software"), to deal in the Software without restriction, including
22  * without limitation the rights to use, copy, modify, merge, publish,
23  * distribute, sublicense, and/or sell copies of the Software, and to
24  * permit persons to whom the Software is furnished to do so, subject to
25  * the following conditions:
26  *
27  * The above copyright notice and this permission notice shall be
28  * included in all copies or substantial portions of the Software.
29  *
30  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
31  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
32  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
33  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
34  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
35  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
36  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
37  *
38  */
39 
40 #include <gecode/int/linear.hh>
41 #include <gecode/int/div.hh>
42 
43 namespace Gecode { namespace Int { namespace Linear {
44 
47  inverse(const IntRelType irt) {
48  switch (irt) {
49  case IRT_EQ: return IRT_NQ; break;
50  case IRT_NQ: return IRT_EQ; break;
51  case IRT_GQ: return IRT_LE; break;
52  case IRT_LQ: return IRT_GR; break;
53  case IRT_LE: return IRT_GQ; break;
54  case IRT_GR: return IRT_LQ; break;
55  default: GECODE_NEVER;
56  }
57  return IRT_EQ; // Avoid compiler warnings
58  }
59 
61  forceinline void
62  eliminate(Term<BoolView>* t, int &n, long long int& d) {
63  for (int i=n; i--; )
64  if (t[i].x.one()) {
65  d -= t[i].a; t[i]=t[--n];
66  } else if (t[i].x.zero()) {
67  t[i]=t[--n];
68  }
69  Limits::check(d,"Int::linear");
70  }
71 
73  forceinline void
74  rewrite(IntRelType &r, long long int &d) {
75  switch (r) {
76  case IRT_EQ: case IRT_NQ: case IRT_LQ: case IRT_GQ:
77  break;
78  case IRT_LE:
79  d--; r = IRT_LQ; break;
80  case IRT_GR:
81  d++; r = IRT_GQ; break;
82  default:
83  throw UnknownRelation("Int::linear");
84  }
85  }
86 
87  forceinline void
89  Term<BoolView>* t_p, int n_p,
90  IntRelType irt, IntView y, int c) {
91  switch (irt) {
92  case IRT_EQ:
93  {
94  ViewArray<BoolView> x(home,n_p);
95  for (int i=n_p; i--; )
96  x[i]=t_p[i].x;
98  ::post(home,x,y,c)));
99  }
100  break;
101  case IRT_NQ:
102  {
103  ViewArray<BoolView> x(home,n_p);
104  for (int i=n_p; i--; )
105  x[i]=t_p[i].x;
107  ::post(home,x,y,c)));
108  }
109  break;
110  case IRT_GQ:
111  {
112  ViewArray<BoolView> x(home,n_p);
113  for (int i=n_p; i--; )
114  x[i]=t_p[i].x;
116  ::post(home,x,y,c)));
117  }
118  break;
119  case IRT_LQ:
120  {
121  ViewArray<NegBoolView> x(home,n_p);
122  for (int i=n_p; i--; )
123  x[i]=NegBoolView(t_p[i].x);
124  MinusView z(y);
126  ::post(home,x,z,n_p-c)));
127  }
128  break;
129  default: GECODE_NEVER;
130  }
131  }
132 
133  forceinline void
135  Term<BoolView>* t_p, int n_p,
136  IntRelType irt, ZeroIntView, int c) {
137  switch (irt) {
138  case IRT_EQ:
139  {
140  ViewArray<BoolView> x(home,n_p);
141  for (int i=n_p; i--; )
142  x[i]=t_p[i].x;
144  }
145  break;
146  case IRT_NQ:
147  {
148  ViewArray<BoolView> x(home,n_p);
149  for (int i=n_p; i--; )
150  x[i]=t_p[i].x;
152  }
153  break;
154  case IRT_GQ:
155  {
156  ViewArray<BoolView> x(home,n_p);
157  for (int i=n_p; i--; )
158  x[i]=t_p[i].x;
160  }
161  break;
162  case IRT_LQ:
163  {
164  ViewArray<NegBoolView> x(home,n_p);
165  for (int i=n_p; i--; )
166  x[i]=NegBoolView(t_p[i].x);
168  }
169  break;
170  default: GECODE_NEVER;
171  }
172  }
173 
174  forceinline void
176  Term<BoolView>* t_p, int n_p,
177  IntRelType irt, int c, Reify r,
178  IntConLevel) {
179  switch (irt) {
180  case IRT_EQ:
181  {
182  ViewArray<BoolView> x(home,n_p);
183  for (int i=n_p; i--; )
184  x[i]=t_p[i].x;
185  switch (r.mode()) {
186  case RM_EQV:
188  post(home,x,c,r.var())));
189  break;
190  case RM_IMP:
192  post(home,x,c,r.var())));
193  break;
194  case RM_PMI:
196  post(home,x,c,r.var())));
197  break;
198  default: GECODE_NEVER;
199  }
200  }
201  break;
202  case IRT_NQ:
203  {
204  ViewArray<BoolView> x(home,n_p);
205  for (int i=n_p; i--; )
206  x[i]=t_p[i].x;
207  NegBoolView nb(r.var());
208  switch (r.mode()) {
209  case RM_EQV:
211  post(home,x,c,nb)));
212  break;
213  case RM_IMP:
215  post(home,x,c,nb)));
216  break;
217  case RM_PMI:
219  post(home,x,c,nb)));
220  break;
221  default: GECODE_NEVER;
222  }
223  }
224  break;
225  case IRT_GQ:
226  {
227  ViewArray<BoolView> x(home,n_p);
228  for (int i=n_p; i--; )
229  x[i]=t_p[i].x;
230  switch (r.mode()) {
231  case RM_EQV:
233  post(home,x,c,r.var())));
234  break;
235  case RM_IMP:
237  post(home,x,c,r.var())));
238  break;
239  case RM_PMI:
241  post(home,x,c,r.var())));
242  break;
243  default: GECODE_NEVER;
244  }
245  }
246  break;
247  case IRT_LQ:
248  {
249  ViewArray<NegBoolView> x(home,n_p);
250  for (int i=n_p; i--; )
251  x[i]=NegBoolView(t_p[i].x);
252  switch (r.mode()) {
253  case RM_EQV:
255  post(home,x,n_p-c,r.var())));
256  break;
257  case RM_IMP:
259  post(home,x,n_p-c,r.var())));
260  break;
261  case RM_PMI:
263  post(home,x,n_p-c,r.var())));
264  break;
265  default: GECODE_NEVER;
266  }
267  }
268  break;
269  default: GECODE_NEVER;
270  }
271  }
272 
273  forceinline void
275  Term<BoolView>* t_n, int n_n,
276  IntRelType irt, IntView y, int c) {
277  switch (irt) {
278  case IRT_EQ:
279  {
280  ViewArray<BoolView> x(home,n_n);
281  for (int i=n_n; i--; )
282  x[i]=t_n[i].x;
283  MinusView z(y);
285  ::post(home,x,z,-c)));
286  }
287  break;
288  case IRT_NQ:
289  {
290  ViewArray<BoolView> x(home,n_n);
291  for (int i=n_n; i--; )
292  x[i]=t_n[i].x;
293  MinusView z(y);
295  ::post(home,x,z,-c)));
296  }
297  break;
298  case IRT_GQ:
299  {
300  ViewArray<NegBoolView> x(home,n_n);
301  for (int i=n_n; i--; )
302  x[i]=NegBoolView(t_n[i].x);
304  ::post(home,x,y,n_n+c)));
305  }
306  break;
307  case IRT_LQ:
308  {
309  ViewArray<BoolView> x(home,n_n);
310  for (int i=n_n; i--; )
311  x[i]=t_n[i].x;
312  MinusView z(y);
314  ::post(home,x,z,-c)));
315  }
316  break;
317  default: GECODE_NEVER;
318  }
319  }
320 
321  forceinline void
323  Term<BoolView>* t_n, int n_n,
324  IntRelType irt, ZeroIntView, int c) {
325  switch (irt) {
326  case IRT_EQ:
327  {
328  ViewArray<BoolView> x(home,n_n);
329  for (int i=n_n; i--; )
330  x[i]=t_n[i].x;
332  }
333  break;
334  case IRT_NQ:
335  {
336  ViewArray<BoolView> x(home,n_n);
337  for (int i=n_n; i--; )
338  x[i]=t_n[i].x;
340  }
341  break;
342  case IRT_GQ:
343  {
344  ViewArray<NegBoolView> x(home,n_n);
345  for (int i=n_n; i--; )
346  x[i]=NegBoolView(t_n[i].x);
348  }
349  break;
350  case IRT_LQ:
351  {
352  ViewArray<BoolView> x(home,n_n);
353  for (int i=n_n; i--; )
354  x[i]=t_n[i].x;
356  }
357  break;
358  default: GECODE_NEVER;
359  }
360  }
361 
362  forceinline void
364  Term<BoolView>* t_n, int n_n,
365  IntRelType irt, int c, Reify r,
366  IntConLevel) {
367  switch (irt) {
368  case IRT_EQ:
369  {
370  ViewArray<BoolView> x(home,n_n);
371  for (int i=n_n; i--; )
372  x[i]=t_n[i].x;
373  switch (r.mode()) {
374  case RM_EQV:
376  post(home,x,-c,r.var())));
377  break;
378  case RM_IMP:
380  post(home,x,-c,r.var())));
381  break;
382  case RM_PMI:
384  post(home,x,-c,r.var())));
385  break;
386  default: GECODE_NEVER;
387  }
388  }
389  break;
390  case IRT_NQ:
391  {
392  ViewArray<BoolView> x(home,n_n);
393  for (int i=n_n; i--; )
394  x[i]=t_n[i].x;
395  NegBoolView nb(r.var());
396  switch (r.mode()) {
397  case RM_EQV:
399  post(home,x,-c,nb)));
400  break;
401  case RM_IMP:
403  post(home,x,-c,nb)));
404  break;
405  case RM_PMI:
407  post(home,x,-c,nb)));
408  break;
409  default: GECODE_NEVER;
410  }
411  }
412  break;
413  case IRT_GQ:
414  {
415  ViewArray<NegBoolView> x(home,n_n);
416  for (int i=n_n; i--; )
417  x[i]=NegBoolView(t_n[i].x);
418  switch (r.mode()) {
419  case RM_EQV:
421  post(home,x,n_n+c,r.var())));
422  break;
423  case RM_IMP:
425  post(home,x,n_n+c,r.var())));
426  break;
427  case RM_PMI:
429  post(home,x,n_n+c,r.var())));
430  break;
431  default: GECODE_NEVER;
432  }
433  }
434  break;
435  case IRT_LQ:
436  {
437  ViewArray<BoolView> x(home,n_n);
438  for (int i=n_n; i--; )
439  x[i]=t_n[i].x;
440  switch (r.mode()) {
441  case RM_EQV:
443  post(home,x,-c,r.var())));
444  break;
445  case RM_IMP:
447  post(home,x,-c,r.var())));
448  break;
449  case RM_PMI:
451  post(home,x,-c,r.var())));
452  break;
453  default: GECODE_NEVER;
454  }
455  }
456  break;
457  default: GECODE_NEVER;
458  }
459  }
460 
461  forceinline void
463  Term<BoolView>* t_p, int n_p,
464  Term<BoolView>* t_n, int n_n,
465  IntRelType irt, IntView y, int c) {
466  ScaleBoolArray b_p(home,n_p);
467  {
468  ScaleBool* f=b_p.fst();
469  for (int i=n_p; i--; ) {
470  f[i].x=t_p[i].x; f[i].a=t_p[i].a;
471  }
472  }
473  ScaleBoolArray b_n(home,n_n);
474  {
475  ScaleBool* f=b_n.fst();
476  for (int i=n_n; i--; ) {
477  f[i].x=t_n[i].x; f[i].a=t_n[i].a;
478  }
479  }
480  switch (irt) {
481  case IRT_EQ:
483  ::post(home,b_p,b_n,y,c)));
484  break;
485  case IRT_NQ:
487  ::post(home,b_p,b_n,y,c)));
488  break;
489  case IRT_LQ:
491  ::post(home,b_p,b_n,y,c)));
492  break;
493  case IRT_GQ:
494  {
495  MinusView m(y);
497  ::post(home,b_n,b_p,m,-c)));
498  }
499  break;
500  default:
501  GECODE_NEVER;
502  }
503  }
504 
505 
506  forceinline void
508  Term<BoolView>* t_p, int n_p,
509  Term<BoolView>* t_n, int n_n,
510  IntRelType irt, ZeroIntView y, int c) {
511  ScaleBoolArray b_p(home,n_p);
512  {
513  ScaleBool* f=b_p.fst();
514  for (int i=n_p; i--; ) {
515  f[i].x=t_p[i].x; f[i].a=t_p[i].a;
516  }
517  }
518  ScaleBoolArray b_n(home,n_n);
519  {
520  ScaleBool* f=b_n.fst();
521  for (int i=n_n; i--; ) {
522  f[i].x=t_n[i].x; f[i].a=t_n[i].a;
523  }
524  }
525  switch (irt) {
526  case IRT_EQ:
529  ::post(home,b_p,b_n,y,c)));
530  break;
531  case IRT_NQ:
534  ::post(home,b_p,b_n,y,c)));
535  break;
536  case IRT_LQ:
539  ::post(home,b_p,b_n,y,c)));
540  break;
541  case IRT_GQ:
544  ::post(home,b_n,b_p,y,-c)));
545  break;
546  default:
547  GECODE_NEVER;
548  }
549  }
550 
551  template<class View>
552  forceinline void
554  Term<BoolView>* t, int n,
555  IntRelType irt, View x, int c) {
556 
557  Limits::check(c,"Int::linear");
558 
559  long long int d = c;
560 
561  eliminate(t,n,d);
562 
563  Term<BoolView> *t_p, *t_n;
564  int n_p, n_n, gcd=0;
565  bool unit = normalize<BoolView>(t,n,t_p,n_p,t_n,n_n,gcd);
566 
567  rewrite(irt,d);
568 
569  c = static_cast<int>(d);
570 
571  if (n == 0) {
572  switch (irt) {
573  case IRT_EQ: GECODE_ME_FAIL(x.eq(home,-c)); break;
574  case IRT_NQ: GECODE_ME_FAIL(x.nq(home,-c)); break;
575  case IRT_GQ: GECODE_ME_FAIL(x.lq(home,-c)); break;
576  case IRT_LQ: GECODE_ME_FAIL(x.gq(home,-c)); break;
577  default: GECODE_NEVER;
578  }
579  return;
580  }
581 
582  // Check for overflow
583  {
584  long long int sl = static_cast<long long int>(x.max())+c;
585  long long int su = static_cast<long long int>(x.min())+c;
586  for (int i=n_p; i--; )
587  su -= t_p[i].a;
588  for (int i=n_n; i--; )
589  sl += t_n[i].a;
590  Limits::check(sl,"Int::linear");
591  Limits::check(su,"Int::linear");
592  }
593 
594  if (unit && (n_n == 0)) {
596  post_pos_unit(home,t_p,n_p,irt,x,c);
597  } else if (unit && (n_p == 0)) {
598  // All coefficients are -1
599  post_neg_unit(home,t_n,n_n,irt,x,c);
600  } else {
601  // Mixed coefficients
602  post_mixed(home,t_p,n_p,t_n,n_n,irt,x,c);
603  }
604  }
605 
606 
607  void
608  post(Home home,
609  Term<BoolView>* t, int n, IntRelType irt, IntView x, int c,
610  IntConLevel) {
611  post_all(home,t,n,irt,x,c);
612  }
613 
614  void
615  post(Home home,
616  Term<BoolView>* t, int n, IntRelType irt, int c,
617  IntConLevel) {
618  ZeroIntView x;
619  post_all(home,t,n,irt,x,c);
620  }
621 
622  void
623  post(Home home,
624  Term<BoolView>* t, int n, IntRelType irt, IntView x, Reify r,
625  IntConLevel icl) {
626  int l, u;
627  estimate(t,n,0,l,u);
628  IntVar z(home,l,u); IntView zv(z);
629  post_all(home,t,n,IRT_EQ,zv,0);
630  rel(home,z,irt,x,r,icl);
631  }
632 
633  void
634  post(Home home,
635  Term<BoolView>* t, int n, IntRelType irt, int c, Reify r,
636  IntConLevel icl) {
637 
638  if (r.var().one()) {
639  if (r.mode() != RM_PMI)
640  post(home,t,n,irt,c,icl);
641  return;
642  }
643  if (r.var().zero()) {
644  if (r.mode() != RM_IMP)
645  post(home,t,n,inverse(irt),c,icl);
646  return;
647  }
648 
649  Limits::check(c,"Int::linear");
650 
651  long long int d = c;
652 
653  eliminate(t,n,d);
654 
655  Term<BoolView> *t_p, *t_n;
656  int n_p, n_n, gcd=1;
657  bool unit = normalize<BoolView>(t,n,t_p,n_p,t_n,n_n,gcd);
658 
659  rewrite(irt,d);
660 
661  // Divide by gcd
662  if (gcd > 1) {
663  switch (irt) {
664  case IRT_EQ:
665  if ((d % gcd) != 0) {
666  if (r.mode() != RM_PMI)
667  GECODE_ME_FAIL(BoolView(r.var()).zero(home));
668  return;
669  }
670  d /= gcd;
671  break;
672  case IRT_NQ:
673  if ((d % gcd) == 0) {
674  if (r.mode() != RM_IMP)
675  GECODE_ME_FAIL(BoolView(r.var()).one(home));
676  return;
677  }
678  d /= gcd;
679  break;
680  case IRT_LQ:
681  d = floor_div_xp(d,static_cast<long long int>(gcd));
682  break;
683  case IRT_GQ:
684  d = ceil_div_xp(d,static_cast<long long int>(gcd));
685  break;
686  default: GECODE_NEVER;
687  }
688  }
689 
690  c = static_cast<int>(d);
691 
692  if (n == 0) {
693  bool fail = false;
694  switch (irt) {
695  case IRT_EQ: fail = (0 != c); break;
696  case IRT_NQ: fail = (0 == c); break;
697  case IRT_GQ: fail = (0 < c); break;
698  case IRT_LQ: fail = (0 > c); break;
699  default: GECODE_NEVER;
700  }
701  if (fail) {
702  if (r.mode() != RM_PMI)
703  GECODE_ME_FAIL(BoolView(r.var()).zero(home));
704  } else {
705  if (r.mode() != RM_IMP)
706  GECODE_ME_FAIL(BoolView(r.var()).one(home));
707  }
708  return;
709  }
710 
711  // Check for overflow
712  {
713  long long int sl = c;
714  long long int su = c;
715  for (int i=n_p; i--; )
716  su -= t_p[i].a;
717  for (int i=n_n; i--; )
718  sl += t_n[i].a;
719  Limits::check(sl,"Int::linear");
720  Limits::check(su,"Int::linear");
721  }
722 
723  if (unit && (n_n == 0)) {
725  post_pos_unit(home,t_p,n_p,irt,c,r,icl);
726  } else if (unit && (n_p == 0)) {
727  // All coefficients are -1
728  post_neg_unit(home,t_n,n_n,irt,c,r,icl);
729  } else {
730  // Mixed coefficients
731  /*
732  * Denormalize: Make all t_n coefficients negative again
733  * (t_p and t_n are shared in t)
734  */
735  for (int i=n_n; i--; )
736  t_n[i].a = -t_n[i].a;
737 
738  // Note: still slow implementation
739  int l, u;
740  estimate(t,n,0,l,u);
741  IntVar z(home,l,u); IntView zv(z);
742  post_all(home,t,n,IRT_EQ,zv,0);
743  rel(home,z,irt,c,r,icl);
744  }
745  }
746 
747 }}}
748 
749 // STATISTICS: int-post
750 
IntRelType inverse(const IntRelType irt)
Inverse the relation.
Definition: bool-post.cpp:47
NodeType t
Type of node.
Definition: bool-expr.cpp:234
Propagator for inequality to Boolean sum with coefficients
Definition: linear.hh:1252
BoolView x
Boolean view.
Definition: linear.hh:1115
void post_neg_unit(Home home, Term< BoolView > *t_n, int n_n, IntRelType irt, IntView y, int c)
Definition: bool-post.cpp:274
IntConLevel
Consistency levels for integer propagators.
Definition: int.hh:937
NNF * l
Left subtree.
Definition: bool-expr.cpp:244
Inverse implication for reification.
Definition: int.hh:847
ReifyMode mode(void) const
Return reification mode.
Definition: reify.hpp:60
void eliminate(Term< BoolView > *t, int &n, long long int &d)
Eliminate assigned views.
Definition: bool-post.cpp:62
BoolVar var(void) const
Return Boolean control variable.
Definition: reify.hpp:52
Negated Boolean view.
Definition: view.hpp:1503
bool one(const Gecode::FloatValArgs &a)
Check whether has only one coefficients.
Definition: linear.cpp:50
void post(Home home, Term< BoolView > *t, int n, IntRelType irt, IntView x, int c, IntConLevel)
Post propagator for linear constraint over Booleans.
Definition: bool-post.cpp:608
int a
Coefficient.
Definition: linear.hh:1313
bool zero(void) const
Test whether domain is zero.
Definition: bool.hpp:107
Less or equal ( )
Definition: int.hh:906
Propagator for integer disequal to Boolean sum (cardinality)
Definition: linear.hh:869
Greater ( )
Definition: int.hh:909
Greater or equal ( )
Definition: int.hh:908
Propagator for equality to Boolean sum (cardinality)
Definition: linear.hh:1032
Propagator for equality to Boolean sum with coefficients
Definition: linear.hh:1225
Gecode::IntSet d(v, 7)
Gecode::FloatVal c(-8, 8)
Propagator for greater or equal to Boolean sum (cardinality)
Definition: linear.hh:1084
Exception: Unknown relation passed as argument
Definition: exception.hpp:91
Gecode::IntArgs i(4, 1, 2, 3, 4)
int n
Number of negative literals for node type.
Definition: bool-expr.cpp:238
Equality ( )
Definition: int.hh:904
IntRelType
Relation types for integers.
Definition: int.hh:903
NNF * r
Right subtree.
Definition: bool-expr.cpp:246
Propagator for integer less or equal to Boolean sum (cardinality)
Definition: linear.hh:840
Propagator for integer equal to Boolean sum (cardinality)
Definition: linear.hh:811
int gcd(int a, int b)
Compute the greatest common divisor of a and b.
Definition: post.hpp:82
bool one(void) const
Test whether domain is one.
Definition: bool.hpp:111
ScaleBool * fst(void) const
Return pointer to first element.
Definition: bool-scale.hpp:80
Reification specification.
Definition: int.hh:854
void post_all(Home home, Term< BoolView > *t, int n, IntRelType irt, View x, int c)
Definition: bool-post.cpp:553
void rewrite(IntRelType &r, long long int &d)
Rewrite non-strict relations.
Definition: bool-post.cpp:74
IntType floor_div_xp(IntType x, IntType y)
Compute where y is non-negative.
Definition: div.hpp:79
IntType ceil_div_xp(IntType x, IntType y)
Compute where y is non-negative.
Definition: div.hpp:73
Less ( )
Definition: int.hh:907
Propagator for reified integer less or equal to Boolean sum (cardinality)
Definition: linear.hh:941
Propagator for reified integer equal to Boolean sum (cardinality)
Definition: linear.hh:971
Propagator for disequality to Boolean sum with coefficients
Definition: linear.hh:1279
Zero integer view.
Definition: view.hpp:959
union Gecode::@518::NNF::@57 u
Union depending on nodetype t.
Integer view for integer variables.
Definition: view.hpp:129
Array of scale Boolean views.
Definition: linear.hh:1119
Node * x
Pointer to corresponding Boolean expression node.
Definition: bool-expr.cpp:253
Minus integer view.
Definition: view.hpp:276
Integer variables.
Definition: int.hh:350
void estimate(Term< View > *t, int n, int c, int &l, int &u)
Estimate lower and upper bounds.
Definition: post.hpp:45
#define forceinline
Definition: config.hpp:132
void rel(Home home, FloatVar x0, FloatRelType frt, FloatVal n)
Propagates .
Definition: rel.cpp:47
Coefficient and Boolean view.
Definition: linear.hh:1110
#define GECODE_ME_FAIL(me)
Check whether modification event me is failed, and fail space home.
Definition: macros.hpp:70
Class for describing linear term .
Definition: linear.hh:1310
void post_mixed(Home home, Term< BoolView > *t_p, int n_p, Term< BoolView > *t_n, int n_n, IntRelType irt, IntView y, int c)
Definition: bool-post.cpp:462
Gecode toplevel namespace
Implication for reification.
Definition: int.hh:840
Propagator for disequality to Boolean sum (cardinality)
Definition: linear.hh:1058
int a
Integer coefficient.
Definition: linear.hh:1113
Disequality ( )
Definition: int.hh:905
void check(int n, const char *l)
Check whether n is in range, otherwise throw out of limits with information l.
Definition: limits.hpp:50
Home class for posting propagators
Definition: core.hpp:717
#define GECODE_ES_FAIL(es)
Check whether execution status es is failed, and fail space home.
Definition: macros.hpp:96
#define GECODE_NEVER
Assert that this command is never executed.
Definition: macros.hpp:60
struct Gecode::@518::NNF::@57::@59 a
For atomic nodes.
void post_pos_unit(Home home, Term< BoolView > *t_p, int n_p, IntRelType irt, IntView y, int c)
Definition: bool-post.cpp:88
Equivalence for reification (default)
Definition: int.hh:833
Boolean view for Boolean variables.
Definition: view.hpp:1315