Generated on Tue Jul 18 2017 18:41:42 for Gecode by doxygen 1.8.13
bool.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  *
6  * Copyright:
7  * Christian Schulte, 2002
8  *
9  * Last modified:
10  * $Date: 2016-12-02 13:20:09 +0100 (Fri, 02 Dec 2016) $ by $Author: schulte $
11  * $Revision: 15304 $
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/int/bool.hh>
39 #include <gecode/int/rel.hh>
40 
41 namespace Gecode {
42 
43  void
45  using namespace Int;
47  switch (irt) {
48  case IRT_EQ:
50  ::post(home,x0,x1)));
51  break;
52  case IRT_NQ:
53  {
54  NegBoolView n1(x1);
56  ::post(home,x0,n1)));
57  }
58  break;
59  case IRT_GQ:
61  break;
62  case IRT_LQ:
64  break;
65  case IRT_GR:
67  break;
68  case IRT_LE:
70  break;
71  default:
72  throw UnknownRelation("Int::rel");
73  }
74  }
75 
76  void
77  rel(Home home, BoolVar x0, IntRelType irt, int n, IntPropLevel) {
78  using namespace Int;
80  BoolView x(x0);
81  if (n == 0) {
82  switch (irt) {
83  case IRT_LQ:
84  case IRT_EQ:
85  GECODE_ME_FAIL(x.zero(home)); break;
86  case IRT_NQ:
87  case IRT_GR:
88  GECODE_ME_FAIL(x.one(home)); break;
89  case IRT_LE:
90  home.fail(); break;
91  case IRT_GQ:
92  break;
93  default:
94  throw UnknownRelation("Int::rel");
95  }
96  } else if (n == 1) {
97  switch (irt) {
98  case IRT_GQ:
99  case IRT_EQ:
100  GECODE_ME_FAIL(x.one(home)); break;
101  case IRT_NQ:
102  case IRT_LE:
103  GECODE_ME_FAIL(x.zero(home)); break;
104  case IRT_GR:
105  home.fail(); break;
106  case IRT_LQ:
107  break;
108  default:
109  throw UnknownRelation("Int::rel");
110  }
111  } else {
112  throw NotZeroOne("Int::rel");
113  }
114  }
115 
116  void
117  rel(Home home, BoolVar x0, IntRelType irt, BoolVar x1, Reify r,
118  IntPropLevel) {
119  using namespace Int;
120  GECODE_POST;
121  switch (irt) {
122  case IRT_EQ:
123  switch (r.mode()) {
124  case RM_EQV:
126  ::post(home,x0,x1,r.var())));
127  break;
128  case RM_IMP:
130  ::post(home,x0,x1,r.var())));
131  break;
132  case RM_PMI:
134  ::post(home,x0,x1,r.var())));
135  break;
136  default: throw UnknownReifyMode("Int::rel");
137  }
138  break;
139  case IRT_NQ:
140  {
141  NegBoolView nr(r.var());
142  switch (r.mode()) {
143  case RM_EQV:
145  ::post(home,x0,x1,nr)));
146  break;
147  case RM_IMP:
149  ::post(home,x0,x1,nr)));
150  break;
151  case RM_PMI:
153  ::post(home,x0,x1,nr)));
154  break;
155  default: throw UnknownReifyMode("Int::rel");
156  }
157  }
158  break;
159  case IRT_GQ:
160  std::swap(x0,x1); // Fall through
161  case IRT_LQ:
162  switch (r.mode()) {
163  case RM_EQV:
164  {
165  NegBoolView n0(x0);
167  ::post(home,n0,x1,r.var())));
168  }
169  break;
170  case RM_IMP:
172  ::post(home,x0,x1,r.var())));
173  break;
174  case RM_PMI:
176  ::post(home,x0,x1,r.var())));
177  break;
178  default: throw UnknownReifyMode("Int::rel");
179  }
180  break;
181  case IRT_LE:
182  std::swap(x0,x1); // Fall through
183  case IRT_GR:
184  {
185  NegBoolView nr(r.var());
186  switch (r.mode()) {
187  case RM_EQV:
188  {
189  NegBoolView n0(x0);
191  ::post(home,n0,x1,nr)));
192  }
193  break;
194  case RM_IMP:
196  ::post(home,x0,x1,nr)));
197  break;
198  case RM_PMI:
200  ::post(home,x0,x1,nr)));
201  break;
202  default: throw UnknownReifyMode("Int::rel");
203  }
204  }
205  break;
206  default:
207  throw UnknownRelation("Int::rel");
208  }
209  }
210 
211  void
212  rel(Home home, BoolVar x0, IntRelType irt, int n, Reify r,
213  IntPropLevel) {
214  using namespace Int;
215  GECODE_POST;
216  BoolView x(x0);
217  BoolView y(r.var());
218  if (n == 0) {
219  switch (irt) {
220  case IRT_LQ:
221  case IRT_EQ:
222  switch (r.mode()) {
223  case RM_EQV:
224  {
225  NegBoolView ny(y);
227  ::post(home,x,ny)));
228  }
229  break;
230  case RM_IMP:
231  {
232  NegBoolView nx(x); NegBoolView ny(y);
234  ::post(home,nx,ny)));
235  }
236  break;
237  case RM_PMI:
239  ::post(home,x,y)));
240  break;
241  default: throw UnknownReifyMode("Int::rel");
242  }
243  break;
244  case IRT_NQ:
245  case IRT_GR:
246  switch (r.mode()) {
247  case RM_EQV:
249  ::post(home,x,y)));
250  break;
251  case RM_IMP:
252  {
253  NegBoolView ny(y);
255  ::post(home,x,ny)));
256  }
257  break;
258  case RM_PMI:
259  {
260  NegBoolView nx(x);
262  ::post(home,nx,y)));
263  }
264  break;
265  default: throw UnknownReifyMode("Int::rel");
266  }
267  break;
268  case IRT_LE:
269  switch (r.mode()) {
270  case RM_EQV:
271  case RM_IMP:
272  GECODE_ME_FAIL(y.zero(home));
273  break;
274  case RM_PMI:
275  break;
276  default: throw UnknownReifyMode("Int::rel");
277  }
278  break;
279  case IRT_GQ:
280  switch (r.mode()) {
281  case RM_EQV:
282  case RM_PMI:
283  GECODE_ME_FAIL(y.one(home));
284  break;
285  case RM_IMP:
286  break;
287  default: throw UnknownReifyMode("Int::rel");
288  }
289  break;
290  default:
291  throw UnknownRelation("Int::rel");
292  }
293  } else if (n == 1) {
294  switch (irt) {
295  case IRT_NQ:
296  case IRT_LE:
297  switch (r.mode()) {
298  case RM_EQV:
299  {
300  NegBoolView ny(y);
302  ::post(home,x,ny)));
303  }
304  break;
305  case RM_IMP:
306  {
307  NegBoolView nx(x); NegBoolView ny(y);
309  ::post(home,nx,ny)));
310  }
311  break;
312  case RM_PMI:
314  ::post(home,x,y)));
315  break;
316  default: throw UnknownReifyMode("Int::rel");
317  }
318  break;
319  case IRT_EQ:
320  case IRT_GQ:
321  switch (r.mode()) {
322  case RM_EQV:
324  ::post(home,x,y)));
325  break;
326  case RM_IMP:
327  {
328  NegBoolView ny(y);
330  ::post(home,x,ny)));
331  }
332  break;
333  case RM_PMI:
334  {
335  NegBoolView nx(x);
337  ::post(home,nx,y)));
338  }
339  break;
340  default: throw UnknownReifyMode("Int::rel");
341  }
342  break;
343  case IRT_GR:
344  switch (r.mode()) {
345  case RM_EQV:
346  case RM_IMP:
347  GECODE_ME_FAIL(y.zero(home));
348  break;
349  case RM_PMI:
350  break;
351  default: throw UnknownReifyMode("Int::rel");
352  }
353  break;
354  case IRT_LQ:
355  switch (r.mode()) {
356  case RM_EQV:
357  case RM_PMI:
358  GECODE_ME_FAIL(y.one(home));
359  break;
360  case RM_IMP:
361  break;
362  default: throw UnknownReifyMode("Int::rel");
363  }
364  break;
365  default:
366  throw UnknownRelation("Int::rel");
367  }
368  } else {
369  throw NotZeroOne("Int::rel");
370  }
371  }
372 
373  void
374  rel(Home home, const BoolVarArgs& x, IntRelType irt, BoolVar y,
375  IntPropLevel) {
376  using namespace Int;
377  GECODE_POST;
378  switch (irt) {
379  case IRT_EQ:
380  for (int i=x.size(); i--; ) {
382  ::post(home,x[i],y)));
383  }
384  break;
385  case IRT_NQ:
386  {
387  NegBoolView n(y);
388  for (int i=x.size(); i--; ) {
390  ::post(home,x[i],n)));
391  }
392  }
393  break;
394  case IRT_GQ:
395  for (int i=x.size(); i--; ) {
397  }
398  break;
399  case IRT_LQ:
400  for (int i=x.size(); i--; ) {
402  }
403  break;
404  case IRT_GR:
405  for (int i=x.size(); i--; ) {
407  }
408  break;
409  case IRT_LE:
410  for (int i=x.size(); i--; ) {
412  }
413  break;
414  default:
415  throw UnknownRelation("Int::rel");
416  }
417  }
418 
419  void
420  rel(Home home, const BoolVarArgs& x, IntRelType irt, int n,
421  IntPropLevel) {
422  using namespace Int;
423  GECODE_POST;
424  if (n == 0) {
425  switch (irt) {
426  case IRT_LQ:
427  case IRT_EQ:
428  for (int i=x.size(); i--; ) {
429  BoolView xi(x[i]); GECODE_ME_FAIL(xi.zero(home));
430  }
431  break;
432  case IRT_NQ:
433  case IRT_GR:
434  for (int i=x.size(); i--; ) {
435  BoolView xi(x[i]); GECODE_ME_FAIL(xi.one(home));
436  }
437  break;
438  case IRT_LE:
439  home.fail(); break;
440  case IRT_GQ:
441  break;
442  default:
443  throw UnknownRelation("Int::rel");
444  }
445  } else if (n == 1) {
446  switch (irt) {
447  case IRT_GQ:
448  case IRT_EQ:
449  for (int i=x.size(); i--; ) {
450  BoolView xi(x[i]); GECODE_ME_FAIL(xi.one(home));
451  }
452  break;
453  case IRT_NQ:
454  case IRT_LE:
455  for (int i=x.size(); i--; ) {
456  BoolView xi(x[i]); GECODE_ME_FAIL(xi.zero(home));
457  }
458  break;
459  case IRT_GR:
460  home.fail(); break;
461  case IRT_LQ:
462  break;
463  default:
464  throw UnknownRelation("Int::rel");
465  }
466  } else {
467  throw NotZeroOne("Int::rel");
468  }
469  }
470 
471  void
472  rel(Home home, const BoolVarArgs& x, IntRelType irt, IntPropLevel) {
473  using namespace Int;
474  GECODE_POST;
475  if ((irt != IRT_NQ) && (x.size() < 2))
476  return;
477 
478  switch (irt) {
479  case IRT_EQ:
480  {
481  ViewArray<BoolView> y(home,x);
483  }
484  break;
485  case IRT_NQ:
486  {
487  ViewArray<BoolView> y(home,x);
489  }
490  break;
491  case IRT_LE:
492  if (x.size() == 2) {
493  GECODE_ES_FAIL(Bool::Le<BoolView>::post(home,x[0],x[1]));
494  } else {
495  home.fail();
496  }
497  break;
498  case IRT_LQ:
499  {
500  ViewArray<BoolView> y(home,x);
502  }
503  break;
504  case IRT_GR:
505  if (x.size() == 2) {
506  GECODE_ES_FAIL(Bool::Le<BoolView>::post(home,x[1],x[0]));
507  } else {
508  home.fail();
509  }
510  break;
511  case IRT_GQ:
512  {
513  ViewArray<BoolView> y(home,x.size());
514  for (int i=x.size(); i--; )
515  y[i] = x[x.size()-1-i];
517  }
518  for (int i=x.size()-1; i--; )
520  break;
521  default:
522  throw UnknownRelation("Int::rel");
523  }
524  }
525 
526  void
527  rel(Home home, const BoolVarArgs& x, IntRelType irt, const BoolVarArgs& y,
528  IntPropLevel) {
529  using namespace Int;
530  GECODE_POST;
531 
532  switch (irt) {
533  case IRT_GR:
534  {
535  ViewArray<BoolView> xv(home,x), yv(home,y);
537  ::post(home,yv,xv,true)));
538  }
539  break;
540  case IRT_LE:
541  {
542  ViewArray<BoolView> xv(home,x), yv(home,y);
544  ::post(home,xv,yv,true)));
545  }
546  break;
547  case IRT_GQ:
548  {
549  ViewArray<BoolView> xv(home,x), yv(home,y);
551  ::post(home,yv,xv,false)));
552  }
553  break;
554  case IRT_LQ:
555  {
556  ViewArray<BoolView> xv(home,x), yv(home,y);
558  ::post(home,xv,yv,false)));
559  }
560  break;
561  case IRT_EQ:
562  for (int i=x.size(); i--; ) {
564  ::post(home,x[i],y[i])));
565  }
566  break;
567  case IRT_NQ:
568  {
569  ViewArray<BoolView> xv(home,x), yv(home,y);
571  ::post(home,xv,yv)));
572  }
573  break;
574  default:
575  throw UnknownRelation("Int::rel");
576  }
577  }
578 
579  namespace {
580 
583  viewarray(Space& home, const IntArgs& x) {
584  ViewArray<Int::ConstIntView> xv(home, x.size());
585  for (int i = x.size(); i--; ) {
586  if ((x[i] != 0) && (x[i] != 1))
587  throw Int::NotZeroOne("Int::rel");
588  xv[i] = Int::ConstIntView(x[i]);
589  }
590  return xv;
591  }
592 
593  }
594 
595  void
596  rel(Home home, const BoolVarArgs& x, IntRelType irt, const IntArgs& y,
597  IntPropLevel) {
598  using namespace Int;
599  GECODE_POST;
600 
601  switch (irt) {
602  case IRT_GR:
603  {
604  ViewArray<BoolView> xv(home,x);
605  ViewArray<ConstIntView> yv(viewarray(home,y));
607  ::post(home,yv,xv,true)));
608  }
609  break;
610  case IRT_LE:
611  {
612  ViewArray<BoolView> xv(home,x);
613  ViewArray<ConstIntView> yv(viewarray(home,y));
615  ::post(home,xv,yv,true)));
616  }
617  break;
618  case IRT_GQ:
619  {
620  ViewArray<BoolView> xv(home,x);
621  ViewArray<ConstIntView> yv(viewarray(home,y));
623  ::post(home,yv,xv,false)));
624  }
625  break;
626  case IRT_LQ:
627  {
628  ViewArray<BoolView> xv(home,x);
629  ViewArray<ConstIntView> yv(viewarray(home,y));
631  ::post(home,xv,yv,false)));
632  }
633  break;
634  case IRT_EQ:
635  if (x.size() != y.size()) {
636  home.fail();
637  } else {
638  for (int i=x.size(); i--; )
639  GECODE_ME_FAIL(BoolView(x[i]).eq(home,y[i]));
640  }
641  break;
642  case IRT_NQ:
643  {
644  ViewArray<BoolView> xv(home,x);
645  ViewArray<ConstIntView> yv(viewarray(home,y));
647  ::post(home,xv,yv)));
648  }
649  break;
650  default:
651  throw UnknownRelation("Int::rel");
652  }
653  }
654 
655  void
656  rel(Home home, const IntArgs& x, IntRelType irt, const BoolVarArgs& y,
657  IntPropLevel ipl) {
658  rel(home,y,irt,x,ipl);
659  }
660 
661  void
662  rel(Home home, BoolVar x0, BoolOpType o, BoolVar x1, BoolVar x2,
663  IntPropLevel) {
664  using namespace Int;
665  GECODE_POST;
666  switch (o) {
667  case BOT_AND:
668  {
669  NegBoolView n0(x0); NegBoolView n1(x1); NegBoolView n2(x2);
671  ::post(home,n0,n1,n2)));
672  }
673  break;
674  case BOT_OR:
676  ::post(home,x0,x1,x2)));
677  break;
678  case BOT_IMP:
679  {
680  NegBoolView n0(x0);
682  ::post(home,n0,x1,x2)));
683  }
684  break;
685  case BOT_EQV:
687  ::post(home,x0,x1,x2)));
688  break;
689  case BOT_XOR:
690  {
691  NegBoolView n2(x2);
693  ::post(home,x0,x1,n2)));
694  }
695  break;
696  default:
697  throw UnknownOperation("Int::rel");
698  }
699  }
700 
701  void
702  rel(Home home, BoolVar x0, BoolOpType o, BoolVar x1, int n,
703  IntPropLevel) {
704  using namespace Int;
705  GECODE_POST;
706  if (n == 0) {
707  switch (o) {
708  case BOT_AND:
709  {
710  NegBoolView n0(x0); NegBoolView n1(x1);
712  ::post(home,n0,n1)));
713  }
714  break;
715  case BOT_OR:
716  {
717  BoolView b0(x0); BoolView b1(x1);
718  GECODE_ME_FAIL(b0.zero(home));
719  GECODE_ME_FAIL(b1.zero(home));
720  }
721  break;
722  case BOT_IMP:
723  {
724  BoolView b0(x0); BoolView b1(x1);
725  GECODE_ME_FAIL(b0.one(home));
726  GECODE_ME_FAIL(b1.zero(home));
727  }
728  break;
729  case BOT_EQV:
730  {
731  NegBoolView n0(x0);
733  }
734  break;
735  case BOT_XOR:
737  break;
738  default:
739  throw UnknownOperation("Int::rel");
740  }
741  } else if (n == 1) {
742  switch (o) {
743  case BOT_AND:
744  {
745  BoolView b0(x0); BoolView b1(x1);
746  GECODE_ME_FAIL(b0.one(home));
747  GECODE_ME_FAIL(b1.one(home));
748  }
749  break;
750  case BOT_OR:
752  break;
753  case BOT_IMP:
754  {
755  NegBoolView n0(x0);
757  ::post(home,n0,x1)));
758  }
759  break;
760  case BOT_EQV:
762  break;
763  case BOT_XOR:
764  {
765  NegBoolView n0(x0);
767  }
768  break;
769  default:
770  throw UnknownOperation("Int::rel");
771  }
772  } else {
773  throw NotZeroOne("Int::rel");
774  }
775  }
776 
777  void
779  IntPropLevel) {
780  using namespace Int;
781  GECODE_POST;
782  int m = x.size();
783  Region r(home);
784  switch (o) {
785  case BOT_AND:
786  {
787  ViewArray<NegBoolView> b(home,m);
788  for (int i=m; i--; ) {
789  NegBoolView nb(x[i]); b[i]=nb;
790  }
791  NegBoolView ny(y);
792  b.unique(home);
794  ::post(home,b,ny)));
795  }
796  break;
797  case BOT_OR:
798  {
799  ViewArray<BoolView> b(home,x);
800  b.unique(home);
802  }
803  break;
804  case BOT_IMP:
805  if (m < 2) {
806  throw TooFewArguments("Int::rel");
807  } else {
808  ViewArray<NegBoolView> a(home,x.size()-1);
809  for (int i=x.size()-1; i--; )
810  a[i]=NegBoolView(x[i]);
811  ViewArray<BoolView> b(home,1);
812  b[0]=x[x.size()-1];
814  ::post(home,b,a,y)));
815  }
816  break;
817  case BOT_EQV:
818  {
819  ViewArray<BoolView> xy(home, x.size() + 1);
820  for (int i=x.size(); i--; )
821  xy[i] = x[i];
822  xy[x.size()] = y;
824  }
825  break;
826  case BOT_XOR:
827  {
828  ViewArray<BoolView> xy(home, x.size() + 1);
829  for (int i=x.size(); i--; )
830  xy[i] = x[i];
831  xy[x.size()] = y;
833  }
834  break;
835  default:
836  throw UnknownOperation("Int::rel");
837  }
838  }
839 
840  void
841  rel(Home home, BoolOpType o, const BoolVarArgs& x, int n,
842  IntPropLevel) {
843  using namespace Int;
844  if ((n < 0) || (n > 1))
845  throw NotZeroOne("Int::rel");
846  GECODE_POST;
847  int m = x.size();
848  Region r(home);
849  switch (o) {
850  case BOT_AND:
851  if (n == 0) {
852  ViewArray<NegBoolView> b(home,m);
853  for (int i=m; i--; ) {
854  NegBoolView nb(x[i]); b[i]=nb;
855  }
856  b.unique(home);
858  } else {
859  for (int i=m; i--; ) {
860  BoolView b(x[i]); GECODE_ME_FAIL(b.one(home));
861  }
862  }
863  break;
864  case BOT_OR:
865  if (n == 0) {
866  for (int i=m; i--; ) {
867  BoolView b(x[i]); GECODE_ME_FAIL(b.zero(home));
868  }
869  } else {
870  ViewArray<BoolView> b(home,x);
871  b.unique(home);
873  }
874  break;
875  case BOT_IMP:
876  if (m < 2) {
877  throw TooFewArguments("Int::rel");
878  } else if (n == 0) {
879  for (int i=m-1; i--; )
880  GECODE_ME_FAIL(BoolView(x[i]).one(home));
881  GECODE_ME_FAIL(BoolView(x[m-1]).zero(home));
882  } else {
883  ViewArray<NegBoolView> a(home,x.size()-1);
884  for (int i=x.size()-1; i--; )
885  a[i]=NegBoolView(x[i]);
886  ViewArray<BoolView> b(home,1);
887  b[0]=x[x.size()-1];
889  ::post(home,b,a)));
890  }
891  break;
892  case BOT_EQV:
893  {
894  ViewArray<BoolView> b(home,x);
896  }
897  break;
898  case BOT_XOR:
899  {
900  ViewArray<BoolView> b(home,x);
901  GECODE_ES_FAIL(Bool::NaryEqv::post(home,b,1^n));
902  }
903  break;
904  default:
905  throw UnknownOperation("Int::rel");
906  }
907  }
908 
909  void
910  clause(Home home, BoolOpType o, const BoolVarArgs& x, const BoolVarArgs& y,
911  int n, IntPropLevel) {
912  using namespace Int;
913  if ((n < 0) || (n > 1))
914  throw NotZeroOne("Int::rel");
915  GECODE_POST;
916  switch (o) {
917  case BOT_AND:
918  if (n == 0) {
919  ViewArray<NegBoolView> xv(home,x.size());
920  for (int i=x.size(); i--; ) {
921  NegBoolView nxi(x[i]); xv[i]=nxi;
922  }
923  ViewArray<BoolView> yv(home,y);
924  xv.unique(home); yv.unique(home);
926  ::post(home,xv,yv)));
927  } else {
928  for (int i=x.size(); i--; ) {
929  BoolView b(x[i]); GECODE_ME_FAIL(b.one(home));
930  }
931  for (int i=y.size(); i--; ) {
932  BoolView b(y[i]); GECODE_ME_FAIL(b.zero(home));
933  }
934  }
935  break;
936  case BOT_OR:
937  if (n == 0) {
938  for (int i=x.size(); i--; ) {
939  BoolView b(x[i]); GECODE_ME_FAIL(b.zero(home));
940  }
941  for (int i=y.size(); i--; ) {
942  BoolView b(y[i]); GECODE_ME_FAIL(b.one(home));
943  }
944  } else {
945  ViewArray<BoolView> xv(home,x);
946  ViewArray<NegBoolView> yv(home,y.size());
947  for (int i=y.size(); i--; ) {
948  NegBoolView nyi(y[i]); yv[i]=nyi;
949  }
950  xv.unique(home); yv.unique(home);
952  ::post(home,xv,yv)));
953  }
954  break;
955  default:
956  throw IllegalOperation("Int::clause");
957  }
958  }
959 
960  void
961  clause(Home home, BoolOpType o, const BoolVarArgs& x, const BoolVarArgs& y,
963  using namespace Int;
964  GECODE_POST;
965  switch (o) {
966  case BOT_AND:
967  {
968  ViewArray<NegBoolView> xv(home,x.size());
969  for (int i=x.size(); i--; ) {
970  NegBoolView n(x[i]); xv[i]=n;
971  }
972  ViewArray<BoolView> yv(home,y);
973  xv.unique(home); yv.unique(home);
974  NegBoolView nz(z);
976  ::post(home,xv,yv,nz)));
977  }
978  break;
979  case BOT_OR:
980  {
981  ViewArray<BoolView> xv(home,x);
982  ViewArray<NegBoolView> yv(home,y.size());
983  for (int i=y.size(); i--; ) {
984  NegBoolView n(y[i]); yv[i]=n;
985  }
986  xv.unique(home); yv.unique(home);
988  ::post(home,xv,yv,z)));
989  }
990  break;
991  default:
992  throw IllegalOperation("Int::clause");
993  }
994  }
995 
996  void
998  IntPropLevel ipl) {
999  using namespace Int;
1000  GECODE_POST;
1001  if (vbd(ipl) == IPL_BND) {
1003  ::post(home,b,x,y,z)));
1004  } else {
1006  ::post(home,b,x,y,z)));
1007  }
1008  }
1009 
1010  void
1012  IntPropLevel) {
1013  using namespace Int;
1014  GECODE_POST;
1016  ::post(home,b,x,y,z)));
1017  }
1018 
1019 }
1020 
1021 // STATISTICS: int-post
Bounds propagation.
Definition: int.hh:959
If-then-else bounds-consistent propagator.
Definition: bool.hh:610
IntPropLevel vbd(IntPropLevel ipl)
Extract value, bounds, or domain propagation from propagation level.
Definition: ipl.hpp:41
bool zero(void) const
Test whether view is assigned to be zero.
Definition: bool.hpp:214
Inverse implication for reification.
Definition: int.hh:850
int size(void) const
Return size of array (number of elements)
Definition: array.hpp:1669
Boolean clause propagator (disjunctive, true)
Definition: bool.hh:550
ReifyMode mode(void) const
Return reification mode.
Definition: reify.hpp:60
Negated Boolean view.
Definition: view.hpp:1503
bool one(const Gecode::FloatValArgs &a)
Check whether has only one coefficients.
Definition: linear.cpp:50
BoolOpType
Operation types for Booleans.
Definition: int.hh:931
bool one(void) const
Test whether view is assigned to be one.
Definition: bool.hpp:218
Less or equal ( )
Definition: int.hh:909
Conjunction.
Definition: int.hh:932
Exception: Too few arguments available in argument array
Definition: exception.hpp:70
Exception: Unknown operation passed as argument
Definition: exception.hpp:98
Implication.
Definition: int.hh:934
Lexical disequality propagator.
Definition: rel.hh:665
Boolean clause propagator (disjunctive)
Definition: bool.hh:496
static ExecStatus post(Home home, ViewArray< BoolView > &x, int pm2)
Post propagator .
Definition: eqv.cpp:58
Handle to region.
Definition: region.hpp:61
Greater ( )
Definition: int.hh:912
void unique(const Space &home)
Remove all duplicate views from array (changes element order)
Definition: array.hpp:1505
Computation spaces.
Definition: core.hpp:1748
Greater or equal ( )
Definition: int.hh:911
Exclusive or.
Definition: int.hh:936
ModEvent eq(Space &home, int n)
Restrict domain values to be equal to n.
Definition: bool.hpp:164
Reified less or equal propagator.
Definition: rel.hh:556
Nary disequality propagator.
Definition: rel.hh:322
struct Gecode::@579::NNF::@61::@63 a
For atomic nodes.
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:907
n-ary Boolean equality propagator
Definition: bool.hh:137
Boolean equivalence propagator.
Definition: bool.hh:430
IntRelType
Relation types for integers.
Definition: int.hh:906
Exception: Illegal operation passed as argument
Definition: exception.hpp:105
Boolean disjunction propagator.
Definition: bool.hh:332
Reification specification.
Definition: int.hh:857
struct Gecode::@579::NNF::@61::@62 b
For binary nodes (and, or, eqv)
Reified binary bounds consistent equality propagator.
Definition: rel.hh:376
Less ( )
Definition: int.hh:910
Boolean equality propagator.
Definition: bool.hh:109
Post propagator for SetVar SetOpType SetVar SetRelType SetVar z
Definition: set.hh:784
Disjunction.
Definition: int.hh:933
Passing integer arguments.
Definition: int.hh:610
Passing Boolean variables.
Definition: int.hh:693
Boolean less or equal propagator.
Definition: bool.hh:163
Boolean integer variables.
Definition: int.hh:494
Post propagator for SetVar SetOpType SetVar SetRelType r
Definition: set.hh:784
If-then-else domain-consistent propagator.
Definition: bool.hh:636
Boolean n-ary disjunction propagator (true)
Definition: bool.hh:397
IntPropLevel
Propagation levels for integer propagators.
Definition: int.hh:955
Constant integer view.
Definition: view.hpp:804
Post propagator for SetVar SetOpType SetVar y
Definition: set.hh:784
Boolean less propagator.
Definition: bool.hh:227
Nary Boolean less or equal propagator.
Definition: bool.hh:187
Lexical ordering propagator.
Definition: rel.hh:631
Boolean n-ary disjunction propagator.
Definition: bool.hh:359
Binary Boolean disjunction propagator (true)
Definition: bool.hh:241
Integer variables.
Definition: int.hh:353
void rel(Home home, FloatVar x0, FloatRelType frt, FloatVal n)
Propagates .
Definition: rel.cpp:47
Equivalence.
Definition: int.hh:935
BoolVar var(void) const
Return Boolean control variable.
Definition: reify.hpp:52
Post propagator for SetVar x
Definition: set.hh:784
Exception: Not 0/1 integer
Definition: exception.hpp:55
#define GECODE_ME_FAIL(me)
Check whether modification event me is failed, and fail space home.
Definition: macros.hpp:81
void fail(void)
Mark space as failed.
Definition: core.hpp:4090
Exception: Unknown reification mode passed as argument
Definition: exception.hpp:119
Gecode toplevel namespace
Implication for reification.
Definition: int.hh:843
Disequality ( )
Definition: int.hh:908
#define GECODE_POST
Check for failure in a constraint post function.
Definition: macros.hpp:44
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
void ite(Home home, BoolVar b, FloatVar x, FloatVar y, FloatVar z)
Post propagator for if-then-else constraint.
Definition: bool.cpp:43
TFE post(PropagatorGroup g)
Only post functions (but not propagators) from g are considered.
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:910
Equivalence for reification (default)
Definition: int.hh:836
IntRelType swap(IntRelType irt)
Return swapped relation type of irt.
Definition: irt.hpp:41
Boolean view for Boolean variables.
Definition: view.hpp:1315