Generated on Thu Jan 31 2019 20:56:37 for Gecode by doxygen 1.8.15
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: 2017-03-09 09:51:58 +0100 (Thu, 09 Mar 2017) $ by $Author: schulte $
13  * $Revision: 15565 $
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 
46  forceinline void
47  eliminate(Term<BoolView>* t, int &n, long long int& d) {
48  for (int i=n; i--; )
49  if (t[i].x.one()) {
50  d -= t[i].a; t[i]=t[--n];
51  } else if (t[i].x.zero()) {
52  t[i]=t[--n];
53  }
54  Limits::check(d,"Int::linear");
55  }
56 
58  forceinline void
59  rewrite(IntRelType &r, long long int &d) {
60  switch (r) {
61  case IRT_EQ: case IRT_NQ: case IRT_LQ: case IRT_GQ:
62  break;
63  case IRT_LE:
64  d--; r = IRT_LQ; break;
65  case IRT_GR:
66  d++; r = IRT_GQ; break;
67  default:
68  throw UnknownRelation("Int::linear");
69  }
70  }
71 
72  forceinline void
74  Term<BoolView>* t_p, int n_p,
75  IntRelType irt, IntView y, int c) {
76  switch (irt) {
77  case IRT_EQ:
78  {
79  ViewArray<BoolView> x(home,n_p);
80  for (int i=n_p; i--; )
81  x[i]=t_p[i].x;
83  ::post(home,x,y,c)));
84  }
85  break;
86  case IRT_NQ:
87  {
88  ViewArray<BoolView> x(home,n_p);
89  for (int i=n_p; i--; )
90  x[i]=t_p[i].x;
92  ::post(home,x,y,c)));
93  }
94  break;
95  case IRT_GQ:
96  {
97  ViewArray<BoolView> x(home,n_p);
98  for (int i=n_p; i--; )
99  x[i]=t_p[i].x;
101  ::post(home,x,y,c)));
102  }
103  break;
104  case IRT_LQ:
105  {
106  ViewArray<NegBoolView> x(home,n_p);
107  for (int i=n_p; i--; )
108  x[i]=NegBoolView(t_p[i].x);
109  MinusView z(y);
111  ::post(home,x,z,n_p-c)));
112  }
113  break;
114  default: GECODE_NEVER;
115  }
116  }
117 
118  forceinline void
120  Term<BoolView>* t_p, int n_p,
121  IntRelType irt, ZeroIntView, int c) {
122  switch (irt) {
123  case IRT_EQ:
124  {
125  ViewArray<BoolView> x(home,n_p);
126  for (int i=n_p; i--; )
127  x[i]=t_p[i].x;
129  }
130  break;
131  case IRT_NQ:
132  {
133  ViewArray<BoolView> x(home,n_p);
134  for (int i=n_p; i--; )
135  x[i]=t_p[i].x;
137  }
138  break;
139  case IRT_GQ:
140  {
141  ViewArray<BoolView> x(home,n_p);
142  for (int i=n_p; i--; )
143  x[i]=t_p[i].x;
145  }
146  break;
147  case IRT_LQ:
148  {
149  ViewArray<NegBoolView> x(home,n_p);
150  for (int i=n_p; i--; )
151  x[i]=NegBoolView(t_p[i].x);
153  }
154  break;
155  default: GECODE_NEVER;
156  }
157  }
158 
159  forceinline void
161  Term<BoolView>* t_p, int n_p,
162  IntRelType irt, int c, Reify r,
163  IntPropLevel) {
164  switch (irt) {
165  case IRT_EQ:
166  {
167  ViewArray<BoolView> x(home,n_p);
168  for (int i=n_p; i--; )
169  x[i]=t_p[i].x;
170  switch (r.mode()) {
171  case RM_EQV:
173  post(home,x,c,r.var())));
174  break;
175  case RM_IMP:
177  post(home,x,c,r.var())));
178  break;
179  case RM_PMI:
181  post(home,x,c,r.var())));
182  break;
183  default: GECODE_NEVER;
184  }
185  }
186  break;
187  case IRT_NQ:
188  {
189  ViewArray<BoolView> x(home,n_p);
190  for (int i=n_p; i--; )
191  x[i]=t_p[i].x;
192  NegBoolView nb(r.var());
193  switch (r.mode()) {
194  case RM_EQV:
196  post(home,x,c,nb)));
197  break;
198  case RM_IMP:
200  post(home,x,c,nb)));
201  break;
202  case RM_PMI:
204  post(home,x,c,nb)));
205  break;
206  default: GECODE_NEVER;
207  }
208  }
209  break;
210  case IRT_GQ:
211  {
212  ViewArray<BoolView> x(home,n_p);
213  for (int i=n_p; i--; )
214  x[i]=t_p[i].x;
215  switch (r.mode()) {
216  case RM_EQV:
218  post(home,x,c,r.var())));
219  break;
220  case RM_IMP:
222  post(home,x,c,r.var())));
223  break;
224  case RM_PMI:
226  post(home,x,c,r.var())));
227  break;
228  default: GECODE_NEVER;
229  }
230  }
231  break;
232  case IRT_LQ:
233  {
234  ViewArray<NegBoolView> x(home,n_p);
235  for (int i=n_p; i--; )
236  x[i]=NegBoolView(t_p[i].x);
237  switch (r.mode()) {
238  case RM_EQV:
240  post(home,x,n_p-c,r.var())));
241  break;
242  case RM_IMP:
244  post(home,x,n_p-c,r.var())));
245  break;
246  case RM_PMI:
248  post(home,x,n_p-c,r.var())));
249  break;
250  default: GECODE_NEVER;
251  }
252  }
253  break;
254  default: GECODE_NEVER;
255  }
256  }
257 
258  forceinline void
260  Term<BoolView>* t_n, int n_n,
261  IntRelType irt, IntView y, int c) {
262  switch (irt) {
263  case IRT_EQ:
264  {
265  ViewArray<BoolView> x(home,n_n);
266  for (int i=n_n; i--; )
267  x[i]=t_n[i].x;
268  MinusView z(y);
270  ::post(home,x,z,-c)));
271  }
272  break;
273  case IRT_NQ:
274  {
275  ViewArray<BoolView> x(home,n_n);
276  for (int i=n_n; i--; )
277  x[i]=t_n[i].x;
278  MinusView z(y);
280  ::post(home,x,z,-c)));
281  }
282  break;
283  case IRT_GQ:
284  {
285  ViewArray<NegBoolView> x(home,n_n);
286  for (int i=n_n; i--; )
287  x[i]=NegBoolView(t_n[i].x);
289  ::post(home,x,y,n_n+c)));
290  }
291  break;
292  case IRT_LQ:
293  {
294  ViewArray<BoolView> x(home,n_n);
295  for (int i=n_n; i--; )
296  x[i]=t_n[i].x;
297  MinusView z(y);
299  ::post(home,x,z,-c)));
300  }
301  break;
302  default: GECODE_NEVER;
303  }
304  }
305 
306  forceinline void
308  Term<BoolView>* t_n, int n_n,
309  IntRelType irt, ZeroIntView, int c) {
310  switch (irt) {
311  case IRT_EQ:
312  {
313  ViewArray<BoolView> x(home,n_n);
314  for (int i=n_n; i--; )
315  x[i]=t_n[i].x;
317  }
318  break;
319  case IRT_NQ:
320  {
321  ViewArray<BoolView> x(home,n_n);
322  for (int i=n_n; i--; )
323  x[i]=t_n[i].x;
325  }
326  break;
327  case IRT_GQ:
328  {
329  ViewArray<NegBoolView> x(home,n_n);
330  for (int i=n_n; i--; )
331  x[i]=NegBoolView(t_n[i].x);
333  }
334  break;
335  case IRT_LQ:
336  {
337  ViewArray<BoolView> x(home,n_n);
338  for (int i=n_n; i--; )
339  x[i]=t_n[i].x;
341  }
342  break;
343  default: GECODE_NEVER;
344  }
345  }
346 
347  forceinline void
349  Term<BoolView>* t_n, int n_n,
350  IntRelType irt, int c, Reify r,
351  IntPropLevel) {
352  switch (irt) {
353  case IRT_EQ:
354  {
355  ViewArray<BoolView> x(home,n_n);
356  for (int i=n_n; i--; )
357  x[i]=t_n[i].x;
358  switch (r.mode()) {
359  case RM_EQV:
361  post(home,x,-c,r.var())));
362  break;
363  case RM_IMP:
365  post(home,x,-c,r.var())));
366  break;
367  case RM_PMI:
369  post(home,x,-c,r.var())));
370  break;
371  default: GECODE_NEVER;
372  }
373  }
374  break;
375  case IRT_NQ:
376  {
377  ViewArray<BoolView> x(home,n_n);
378  for (int i=n_n; i--; )
379  x[i]=t_n[i].x;
380  NegBoolView nb(r.var());
381  switch (r.mode()) {
382  case RM_EQV:
384  post(home,x,-c,nb)));
385  break;
386  case RM_IMP:
388  post(home,x,-c,nb)));
389  break;
390  case RM_PMI:
392  post(home,x,-c,nb)));
393  break;
394  default: GECODE_NEVER;
395  }
396  }
397  break;
398  case IRT_GQ:
399  {
400  ViewArray<NegBoolView> x(home,n_n);
401  for (int i=n_n; i--; )
402  x[i]=NegBoolView(t_n[i].x);
403  switch (r.mode()) {
404  case RM_EQV:
406  post(home,x,n_n+c,r.var())));
407  break;
408  case RM_IMP:
410  post(home,x,n_n+c,r.var())));
411  break;
412  case RM_PMI:
414  post(home,x,n_n+c,r.var())));
415  break;
416  default: GECODE_NEVER;
417  }
418  }
419  break;
420  case IRT_LQ:
421  {
422  ViewArray<BoolView> x(home,n_n);
423  for (int i=n_n; i--; )
424  x[i]=t_n[i].x;
425  switch (r.mode()) {
426  case RM_EQV:
428  post(home,x,-c,r.var())));
429  break;
430  case RM_IMP:
432  post(home,x,-c,r.var())));
433  break;
434  case RM_PMI:
436  post(home,x,-c,r.var())));
437  break;
438  default: GECODE_NEVER;
439  }
440  }
441  break;
442  default: GECODE_NEVER;
443  }
444  }
445 
446  forceinline void
448  Term<BoolView>* t_p, int n_p,
449  Term<BoolView>* t_n, int n_n,
450  IntRelType irt, IntView y, int c) {
451  ScaleBoolArray b_p(home,n_p);
452  {
453  ScaleBool* f=b_p.fst();
454  for (int i=n_p; i--; ) {
455  f[i].x=t_p[i].x; f[i].a=t_p[i].a;
456  }
457  }
458  ScaleBoolArray b_n(home,n_n);
459  {
460  ScaleBool* f=b_n.fst();
461  for (int i=n_n; i--; ) {
462  f[i].x=t_n[i].x; f[i].a=t_n[i].a;
463  }
464  }
465  switch (irt) {
466  case IRT_EQ:
468  ::post(home,b_p,b_n,y,c)));
469  break;
470  case IRT_NQ:
472  ::post(home,b_p,b_n,y,c)));
473  break;
474  case IRT_LQ:
476  ::post(home,b_p,b_n,y,c)));
477  break;
478  case IRT_GQ:
479  {
480  MinusView m(y);
482  ::post(home,b_n,b_p,m,-c)));
483  }
484  break;
485  default:
486  GECODE_NEVER;
487  }
488  }
489 
490 
491  forceinline void
493  Term<BoolView>* t_p, int n_p,
494  Term<BoolView>* t_n, int n_n,
495  IntRelType irt, ZeroIntView y, int c) {
496  ScaleBoolArray b_p(home,n_p);
497  {
498  ScaleBool* f=b_p.fst();
499  for (int i=n_p; i--; ) {
500  f[i].x=t_p[i].x; f[i].a=t_p[i].a;
501  }
502  }
503  ScaleBoolArray b_n(home,n_n);
504  {
505  ScaleBool* f=b_n.fst();
506  for (int i=n_n; i--; ) {
507  f[i].x=t_n[i].x; f[i].a=t_n[i].a;
508  }
509  }
510  switch (irt) {
511  case IRT_EQ:
514  ::post(home,b_p,b_n,y,c)));
515  break;
516  case IRT_NQ:
519  ::post(home,b_p,b_n,y,c)));
520  break;
521  case IRT_LQ:
524  ::post(home,b_p,b_n,y,c)));
525  break;
526  case IRT_GQ:
529  ::post(home,b_n,b_p,y,-c)));
530  break;
531  default:
532  GECODE_NEVER;
533  }
534  }
535 
536  template<class View>
537  forceinline void
539  Term<BoolView>* t, int n,
540  IntRelType irt, View x, int c) {
541 
542  Limits::check(c,"Int::linear");
543 
544  long long int d = c;
545 
546  eliminate(t,n,d);
547 
548  Term<BoolView> *t_p, *t_n;
549  int n_p, n_n, gcd=0;
550  bool unit = normalize<BoolView>(t,n,t_p,n_p,t_n,n_n,gcd);
551 
552  rewrite(irt,d);
553 
554  c = static_cast<int>(d);
555 
556  if (n == 0) {
557  switch (irt) {
558  case IRT_EQ: GECODE_ME_FAIL(x.eq(home,-c)); break;
559  case IRT_NQ: GECODE_ME_FAIL(x.nq(home,-c)); break;
560  case IRT_GQ: GECODE_ME_FAIL(x.lq(home,-c)); break;
561  case IRT_LQ: GECODE_ME_FAIL(x.gq(home,-c)); break;
562  default: GECODE_NEVER;
563  }
564  return;
565  }
566 
567  // Check for overflow
568  {
569  long long int sl = static_cast<long long int>(x.max())+c;
570  long long int su = static_cast<long long int>(x.min())+c;
571  for (int i=n_p; i--; )
572  su -= t_p[i].a;
573  for (int i=n_n; i--; )
574  sl += t_n[i].a;
575  Limits::check(sl,"Int::linear");
576  Limits::check(su,"Int::linear");
577  }
578 
579  if (unit && (n_n == 0)) {
581  post_pos_unit(home,t_p,n_p,irt,x,c);
582  } else if (unit && (n_p == 0)) {
583  // All coefficients are -1
584  post_neg_unit(home,t_n,n_n,irt,x,c);
585  } else {
586  // Mixed coefficients
587  post_mixed(home,t_p,n_p,t_n,n_n,irt,x,c);
588  }
589  }
590 
591 
592  void
593  post(Home home,
594  Term<BoolView>* t, int n, IntRelType irt, IntView x, int c,
595  IntPropLevel) {
596  post_all(home,t,n,irt,x,c);
597  }
598 
599  void
600  post(Home home,
601  Term<BoolView>* t, int n, IntRelType irt, int c,
602  IntPropLevel) {
603  ZeroIntView x;
604  post_all(home,t,n,irt,x,c);
605  }
606 
607  void
608  post(Home home,
609  Term<BoolView>* t, int n, IntRelType irt, IntView x, Reify r,
610  IntPropLevel ipl) {
611  int l, u;
612  estimate(t,n,0,l,u);
613  IntVar z(home,l,u); IntView zv(z);
614  post_all(home,t,n,IRT_EQ,zv,0);
615  rel(home,z,irt,x,r,ipl);
616  }
617 
618  void
619  post(Home home,
620  Term<BoolView>* t, int n, IntRelType irt, int c, Reify r,
621  IntPropLevel ipl) {
622 
623  if (r.var().one()) {
624  if (r.mode() != RM_PMI)
625  post(home,t,n,irt,c,ipl);
626  return;
627  }
628  if (r.var().zero()) {
629  if (r.mode() != RM_IMP)
630  post(home,t,n,neg(irt),c,ipl);
631  return;
632  }
633 
634  Limits::check(c,"Int::linear");
635 
636  long long int d = c;
637 
638  eliminate(t,n,d);
639 
640  Term<BoolView> *t_p, *t_n;
641  int n_p, n_n, gcd=1;
642  bool unit = normalize<BoolView>(t,n,t_p,n_p,t_n,n_n,gcd);
643 
644  rewrite(irt,d);
645 
646  // Divide by gcd
647  if (gcd > 1) {
648  switch (irt) {
649  case IRT_EQ:
650  if ((d % gcd) != 0) {
651  if (r.mode() != RM_PMI)
652  GECODE_ME_FAIL(BoolView(r.var()).zero(home));
653  return;
654  }
655  d /= gcd;
656  break;
657  case IRT_NQ:
658  if ((d % gcd) == 0) {
659  if (r.mode() != RM_IMP)
660  GECODE_ME_FAIL(BoolView(r.var()).one(home));
661  return;
662  }
663  d /= gcd;
664  break;
665  case IRT_LQ:
666  d = floor_div_xp(d,static_cast<long long int>(gcd));
667  break;
668  case IRT_GQ:
669  d = ceil_div_xp(d,static_cast<long long int>(gcd));
670  break;
671  default: GECODE_NEVER;
672  }
673  }
674 
675  c = static_cast<int>(d);
676 
677  if (n == 0) {
678  bool fail = false;
679  switch (irt) {
680  case IRT_EQ: fail = (0 != c); break;
681  case IRT_NQ: fail = (0 == c); break;
682  case IRT_GQ: fail = (0 < c); break;
683  case IRT_LQ: fail = (0 > c); break;
684  default: GECODE_NEVER;
685  }
686  if (fail) {
687  if (r.mode() != RM_PMI)
688  GECODE_ME_FAIL(BoolView(r.var()).zero(home));
689  } else {
690  if (r.mode() != RM_IMP)
691  GECODE_ME_FAIL(BoolView(r.var()).one(home));
692  }
693  return;
694  }
695 
696  // Check for overflow
697  {
698  long long int sl = c;
699  long long int su = c;
700  for (int i=n_p; i--; )
701  su -= t_p[i].a;
702  for (int i=n_n; i--; )
703  sl += t_n[i].a;
704  Limits::check(sl,"Int::linear");
705  Limits::check(su,"Int::linear");
706  }
707 
708  if (unit && (n_n == 0)) {
710  post_pos_unit(home,t_p,n_p,irt,c,r,ipl);
711  } else if (unit && (n_p == 0)) {
712  // All coefficients are -1
713  post_neg_unit(home,t_n,n_n,irt,c,r,ipl);
714  } else {
715  // Mixed coefficients
716  /*
717  * Denormalize: Make all t_n coefficients negative again
718  * (t_p and t_n are shared in t)
719  */
720  for (int i=n_n; i--; )
721  t_n[i].a = -t_n[i].a;
722 
723  // Note: still slow implementation
724  int l, u;
725  estimate(t,n,0,l,u);
726  IntVar z(home,l,u); IntView zv(z);
727  post_all(home,t,n,IRT_EQ,zv,0);
728  rel(home,z,irt,c,r,ipl);
729  }
730  }
731 
732 }}}
733 
734 // STATISTICS: int-post
735 
NodeType t
Type of node.
Definition: bool-expr.cpp:234
Propagator for inequality to Boolean sum with coefficients
Definition: linear.hh:1282
void post_neg_unit(Home home, Term< BoolView > *t_n, int n_n, IntRelType irt, IntView y, int c)
Definition: bool-post.cpp:259
NNF * l
Left subtree.
Definition: bool-expr.cpp:244
Inverse implication for reification.
Definition: int.hh:850
void eliminate(Term< BoolView > *t, int &n, long long int &d)
Eliminate assigned views.
Definition: bool-post.cpp:47
union Gecode::@579::NNF::@61 u
Union depending on nodetype t.
Negated Boolean view.
Definition: view.hpp:1503
bool one(const Gecode::FloatValArgs &a)
Check whether has only one coefficients.
Definition: linear.cpp:50
int a
Coefficient.
Definition: linear.hh:1343
Less or equal ( )
Definition: int.hh:909
Propagator for integer disequal to Boolean sum (cardinality)
Definition: linear.hh:887
Greater ( )
Definition: int.hh:912
Greater or equal ( )
Definition: int.hh:911
Propagator for equality to Boolean sum (cardinality)
Definition: linear.hh:1056
Propagator for equality to Boolean sum with coefficients
Definition: linear.hh:1255
Gecode::IntSet d(v, 7)
struct Gecode::@579::NNF::@61::@63 a
For atomic nodes.
Gecode::FloatVal c(-8, 8)
Propagator for greater or equal to Boolean sum (cardinality)
Definition: linear.hh:1108
Exception: Unknown relation passed as argument
Definition: exception.hpp:91
Gecode::IntArgs i(4, 1, 2, 3, 4)
IntRelType neg(IntRelType irt)
Return negated relation type of irt.
Definition: irt.hpp:56
int n
Number of negative literals for node type.
Definition: bool-expr.cpp:238
Equality ( )
Definition: int.hh:907
IntRelType
Relation types for integers.
Definition: int.hh:906
Propagator for integer less or equal to Boolean sum (cardinality)
Definition: linear.hh:855
Propagator for integer equal to Boolean sum (cardinality)
Definition: linear.hh:823
int gcd(int a, int b)
Compute the greatest common divisor of a and b.
Definition: post.hpp:82
Reification specification.
Definition: int.hh:857
void post_all(Home home, Term< BoolView > *t, int n, IntRelType irt, View x, int c)
Definition: bool-post.cpp:538
void rewrite(IntRelType &r, long long int &d)
Rewrite non-strict relations.
Definition: bool-post.cpp:59
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:910
Post propagator for SetVar SetOpType SetVar SetRelType SetVar z
Definition: set.hh:784
Propagator for reified integer less or equal to Boolean sum (cardinality)
Definition: linear.hh:959
Propagator for reified integer equal to Boolean sum (cardinality)
Definition: linear.hh:991
Propagator for disequality to Boolean sum with coefficients
Definition: linear.hh:1309
Zero integer view.
Definition: view.hpp:959
Post propagator for SetVar SetOpType SetVar SetRelType r
Definition: set.hh:784
IntPropLevel
Propagation levels for integer propagators.
Definition: int.hh:955
Post propagator for f(x \diamond_{\mathit{op}} y) \sim_r z \f$ void rel(Home home
Integer view for integer variables.
Definition: view.hpp:129
Post propagator for SetVar SetOpType SetVar y
Definition: set.hh:784
Array of scale Boolean views.
Definition: linear.hh:1143
Minus integer view.
Definition: view.hpp:276
Integer variables.
Definition: int.hh:353
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:173
void rel(Home home, FloatVar x0, FloatRelType frt, FloatVal n)
Propagates .
Definition: rel.cpp:47
Coefficient and Boolean view.
Definition: linear.hh:1134
Post propagator for SetVar x
Definition: set.hh:784
#define GECODE_ME_FAIL(me)
Check whether modification event me is failed, and fail space home.
Definition: macros.hpp:81
Class for describing linear term .
Definition: linear.hh:1340
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:447
Gecode toplevel namespace
Implication for reification.
Definition: int.hh:843
Propagator for disequality to Boolean sum (cardinality)
Definition: linear.hh:1082
Disequality ( )
Definition: int.hh:908
void post(Home home, Term< BoolView > *t, int n, IntRelType irt, IntView x, int c, IntPropLevel)
Post propagator for linear constraint over Booleans.
Definition: bool-post.cpp:593
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:922
#define GECODE_ES_FAIL(es)
Check whether execution status es is failed, and fail space home.
Definition: macros.hpp:107
#define GECODE_NEVER
Assert that this command is never executed.
Definition: macros.hpp:60
ScaleBool * fst(void) const
Return pointer to first element.
Definition: bool-scale.hpp:85
void post_pos_unit(Home home, Term< BoolView > *t_p, int n_p, IntRelType irt, IntView y, int c)
Definition: bool-post.cpp:73
Equivalence for reification (default)
Definition: int.hh:836
Boolean view for Boolean variables.
Definition: view.hpp:1315