Generated on Sat Jun 2 2018 07:17:44 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  * This file is part of Gecode, the generic constraint
10  * development environment:
11  * http://www.gecode.org
12  *
13  * Permission is hereby granted, free of charge, to any person obtaining
14  * a copy of this software and associated documentation files (the
15  * "Software"), to deal in the Software without restriction, including
16  * without limitation the rights to use, copy, modify, merge, publish,
17  * distribute, sublicense, and/or sell copies of the Software, and to
18  * permit persons to whom the Software is furnished to do so, subject to
19  * the following conditions:
20  *
21  * The above copyright notice and this permission notice shall be
22  * included in all copies or substantial portions of the Software.
23  *
24  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
28  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
29  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
30  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
31  *
32  */
33 
34 #include <gecode/int/bool.hh>
35 #include <gecode/int/rel.hh>
36 
37 namespace Gecode {
38 
39  void
41  using namespace Int;
43  switch (irt) {
44  case IRT_EQ:
46  ::post(home,x0,x1)));
47  break;
48  case IRT_NQ:
49  {
50  NegBoolView n1(x1);
52  ::post(home,x0,n1)));
53  }
54  break;
55  case IRT_GQ:
57  break;
58  case IRT_LQ:
60  break;
61  case IRT_GR:
63  break;
64  case IRT_LE:
66  break;
67  default:
68  throw UnknownRelation("Int::rel");
69  }
70  }
71 
72  void
73  rel(Home home, BoolVar x0, IntRelType irt, int n, IntPropLevel) {
74  using namespace Int;
76  BoolView x(x0);
77  if (n == 0) {
78  switch (irt) {
79  case IRT_LQ:
80  case IRT_EQ:
81  GECODE_ME_FAIL(x.zero(home)); break;
82  case IRT_NQ:
83  case IRT_GR:
84  GECODE_ME_FAIL(x.one(home)); break;
85  case IRT_LE:
86  home.fail(); break;
87  case IRT_GQ:
88  break;
89  default:
90  throw UnknownRelation("Int::rel");
91  }
92  } else if (n == 1) {
93  switch (irt) {
94  case IRT_GQ:
95  case IRT_EQ:
96  GECODE_ME_FAIL(x.one(home)); break;
97  case IRT_NQ:
98  case IRT_LE:
99  GECODE_ME_FAIL(x.zero(home)); break;
100  case IRT_GR:
101  home.fail(); break;
102  case IRT_LQ:
103  break;
104  default:
105  throw UnknownRelation("Int::rel");
106  }
107  } else {
108  throw NotZeroOne("Int::rel");
109  }
110  }
111 
112  void
113  rel(Home home, BoolVar x0, IntRelType irt, BoolVar x1, Reify r,
114  IntPropLevel) {
115  using namespace Int;
116  GECODE_POST;
117  switch (irt) {
118  case IRT_EQ:
119  switch (r.mode()) {
120  case RM_EQV:
122  ::post(home,x0,x1,r.var())));
123  break;
124  case RM_IMP:
126  ::post(home,x0,x1,r.var())));
127  break;
128  case RM_PMI:
130  ::post(home,x0,x1,r.var())));
131  break;
132  default: throw UnknownReifyMode("Int::rel");
133  }
134  break;
135  case IRT_NQ:
136  {
137  NegBoolView nr(r.var());
138  switch (r.mode()) {
139  case RM_EQV:
141  ::post(home,x0,x1,nr)));
142  break;
143  case RM_IMP:
145  ::post(home,x0,x1,nr)));
146  break;
147  case RM_PMI:
149  ::post(home,x0,x1,nr)));
150  break;
151  default: throw UnknownReifyMode("Int::rel");
152  }
153  }
154  break;
155  case IRT_GQ:
156  std::swap(x0,x1); // Fall through
157  case IRT_LQ:
158  switch (r.mode()) {
159  case RM_EQV:
160  {
161  NegBoolView n0(x0);
163  ::post(home,n0,x1,r.var())));
164  }
165  break;
166  case RM_IMP:
168  ::post(home,x0,x1,r.var())));
169  break;
170  case RM_PMI:
172  ::post(home,x0,x1,r.var())));
173  break;
174  default: throw UnknownReifyMode("Int::rel");
175  }
176  break;
177  case IRT_LE:
178  std::swap(x0,x1); // Fall through
179  case IRT_GR:
180  {
181  NegBoolView nr(r.var());
182  switch (r.mode()) {
183  case RM_EQV:
184  {
185  NegBoolView n0(x0);
187  ::post(home,n0,x1,nr)));
188  }
189  break;
190  case RM_IMP:
192  ::post(home,x0,x1,nr)));
193  break;
194  case RM_PMI:
196  ::post(home,x0,x1,nr)));
197  break;
198  default: throw UnknownReifyMode("Int::rel");
199  }
200  }
201  break;
202  default:
203  throw UnknownRelation("Int::rel");
204  }
205  }
206 
207  void
208  rel(Home home, BoolVar x0, IntRelType irt, int n, Reify r,
209  IntPropLevel) {
210  using namespace Int;
211  GECODE_POST;
212  BoolView x(x0);
213  BoolView y(r.var());
214  if (n == 0) {
215  switch (irt) {
216  case IRT_LQ:
217  case IRT_EQ:
218  switch (r.mode()) {
219  case RM_EQV:
220  {
221  NegBoolView ny(y);
223  ::post(home,x,ny)));
224  }
225  break;
226  case RM_IMP:
227  {
228  NegBoolView nx(x); NegBoolView ny(y);
230  ::post(home,nx,ny)));
231  }
232  break;
233  case RM_PMI:
235  ::post(home,x,y)));
236  break;
237  default: throw UnknownReifyMode("Int::rel");
238  }
239  break;
240  case IRT_NQ:
241  case IRT_GR:
242  switch (r.mode()) {
243  case RM_EQV:
245  ::post(home,x,y)));
246  break;
247  case RM_IMP:
248  {
249  NegBoolView ny(y);
251  ::post(home,x,ny)));
252  }
253  break;
254  case RM_PMI:
255  {
256  NegBoolView nx(x);
258  ::post(home,nx,y)));
259  }
260  break;
261  default: throw UnknownReifyMode("Int::rel");
262  }
263  break;
264  case IRT_LE:
265  switch (r.mode()) {
266  case RM_EQV:
267  case RM_IMP:
268  GECODE_ME_FAIL(y.zero(home));
269  break;
270  case RM_PMI:
271  break;
272  default: throw UnknownReifyMode("Int::rel");
273  }
274  break;
275  case IRT_GQ:
276  switch (r.mode()) {
277  case RM_EQV:
278  case RM_PMI:
279  GECODE_ME_FAIL(y.one(home));
280  break;
281  case RM_IMP:
282  break;
283  default: throw UnknownReifyMode("Int::rel");
284  }
285  break;
286  default:
287  throw UnknownRelation("Int::rel");
288  }
289  } else if (n == 1) {
290  switch (irt) {
291  case IRT_NQ:
292  case IRT_LE:
293  switch (r.mode()) {
294  case RM_EQV:
295  {
296  NegBoolView ny(y);
298  ::post(home,x,ny)));
299  }
300  break;
301  case RM_IMP:
302  {
303  NegBoolView nx(x); NegBoolView ny(y);
305  ::post(home,nx,ny)));
306  }
307  break;
308  case RM_PMI:
310  ::post(home,x,y)));
311  break;
312  default: throw UnknownReifyMode("Int::rel");
313  }
314  break;
315  case IRT_EQ:
316  case IRT_GQ:
317  switch (r.mode()) {
318  case RM_EQV:
320  ::post(home,x,y)));
321  break;
322  case RM_IMP:
323  {
324  NegBoolView ny(y);
326  ::post(home,x,ny)));
327  }
328  break;
329  case RM_PMI:
330  {
331  NegBoolView nx(x);
333  ::post(home,nx,y)));
334  }
335  break;
336  default: throw UnknownReifyMode("Int::rel");
337  }
338  break;
339  case IRT_GR:
340  switch (r.mode()) {
341  case RM_EQV:
342  case RM_IMP:
343  GECODE_ME_FAIL(y.zero(home));
344  break;
345  case RM_PMI:
346  break;
347  default: throw UnknownReifyMode("Int::rel");
348  }
349  break;
350  case IRT_LQ:
351  switch (r.mode()) {
352  case RM_EQV:
353  case RM_PMI:
354  GECODE_ME_FAIL(y.one(home));
355  break;
356  case RM_IMP:
357  break;
358  default: throw UnknownReifyMode("Int::rel");
359  }
360  break;
361  default:
362  throw UnknownRelation("Int::rel");
363  }
364  } else {
365  throw NotZeroOne("Int::rel");
366  }
367  }
368 
369  void
370  rel(Home home, const BoolVarArgs& x, IntRelType irt, BoolVar y,
371  IntPropLevel) {
372  using namespace Int;
373  GECODE_POST;
374  switch (irt) {
375  case IRT_EQ:
376  for (int i=x.size(); i--; ) {
378  ::post(home,x[i],y)));
379  }
380  break;
381  case IRT_NQ:
382  {
383  NegBoolView n(y);
384  for (int i=x.size(); i--; ) {
386  ::post(home,x[i],n)));
387  }
388  }
389  break;
390  case IRT_GQ:
391  for (int i=x.size(); i--; ) {
393  }
394  break;
395  case IRT_LQ:
396  for (int i=x.size(); i--; ) {
398  }
399  break;
400  case IRT_GR:
401  for (int i=x.size(); i--; ) {
403  }
404  break;
405  case IRT_LE:
406  for (int i=x.size(); i--; ) {
408  }
409  break;
410  default:
411  throw UnknownRelation("Int::rel");
412  }
413  }
414 
415  void
416  rel(Home home, const BoolVarArgs& x, IntRelType irt, int n,
417  IntPropLevel) {
418  using namespace Int;
419  GECODE_POST;
420  if (n == 0) {
421  switch (irt) {
422  case IRT_LQ:
423  case IRT_EQ:
424  for (int i=x.size(); i--; ) {
425  BoolView xi(x[i]); GECODE_ME_FAIL(xi.zero(home));
426  }
427  break;
428  case IRT_NQ:
429  case IRT_GR:
430  for (int i=x.size(); i--; ) {
431  BoolView xi(x[i]); GECODE_ME_FAIL(xi.one(home));
432  }
433  break;
434  case IRT_LE:
435  home.fail(); break;
436  case IRT_GQ:
437  break;
438  default:
439  throw UnknownRelation("Int::rel");
440  }
441  } else if (n == 1) {
442  switch (irt) {
443  case IRT_GQ:
444  case IRT_EQ:
445  for (int i=x.size(); i--; ) {
446  BoolView xi(x[i]); GECODE_ME_FAIL(xi.one(home));
447  }
448  break;
449  case IRT_NQ:
450  case IRT_LE:
451  for (int i=x.size(); i--; ) {
452  BoolView xi(x[i]); GECODE_ME_FAIL(xi.zero(home));
453  }
454  break;
455  case IRT_GR:
456  home.fail(); break;
457  case IRT_LQ:
458  break;
459  default:
460  throw UnknownRelation("Int::rel");
461  }
462  } else {
463  throw NotZeroOne("Int::rel");
464  }
465  }
466 
467  void
468  rel(Home home, const BoolVarArgs& x, IntRelType irt, IntPropLevel) {
469  using namespace Int;
470  GECODE_POST;
471  if ((irt != IRT_NQ) && (x.size() < 2))
472  return;
473 
474  switch (irt) {
475  case IRT_EQ:
476  {
477  ViewArray<BoolView> y(home,x);
479  }
480  break;
481  case IRT_NQ:
482  {
483  ViewArray<BoolView> y(home,x);
485  }
486  break;
487  case IRT_LE:
488  if (x.size() == 2) {
489  GECODE_ES_FAIL(Bool::Le<BoolView>::post(home,x[0],x[1]));
490  } else {
491  home.fail();
492  }
493  break;
494  case IRT_LQ:
495  {
496  ViewArray<BoolView> y(home,x);
498  }
499  break;
500  case IRT_GR:
501  if (x.size() == 2) {
502  GECODE_ES_FAIL(Bool::Le<BoolView>::post(home,x[1],x[0]));
503  } else {
504  home.fail();
505  }
506  break;
507  case IRT_GQ:
508  {
509  ViewArray<BoolView> y(home,x.size());
510  for (int i=x.size(); i--; )
511  y[i] = x[x.size()-1-i];
513  }
514  for (int i=x.size()-1; i--; )
516  break;
517  default:
518  throw UnknownRelation("Int::rel");
519  }
520  }
521 
522  void
523  rel(Home home, const BoolVarArgs& x, IntRelType irt, const BoolVarArgs& y,
524  IntPropLevel) {
525  using namespace Int;
526  GECODE_POST;
527 
528  switch (irt) {
529  case IRT_GR:
530  {
531  ViewArray<BoolView> xv(home,x), yv(home,y);
533  ::post(home,yv,xv,true)));
534  }
535  break;
536  case IRT_LE:
537  {
538  ViewArray<BoolView> xv(home,x), yv(home,y);
540  ::post(home,xv,yv,true)));
541  }
542  break;
543  case IRT_GQ:
544  {
545  ViewArray<BoolView> xv(home,x), yv(home,y);
547  ::post(home,yv,xv,false)));
548  }
549  break;
550  case IRT_LQ:
551  {
552  ViewArray<BoolView> xv(home,x), yv(home,y);
554  ::post(home,xv,yv,false)));
555  }
556  break;
557  case IRT_EQ:
558  for (int i=x.size(); i--; ) {
560  ::post(home,x[i],y[i])));
561  }
562  break;
563  case IRT_NQ:
564  {
565  ViewArray<BoolView> xv(home,x), yv(home,y);
567  ::post(home,xv,yv)));
568  }
569  break;
570  default:
571  throw UnknownRelation("Int::rel");
572  }
573  }
574 
575  namespace {
576 
579  viewarray(Space& home, const IntArgs& x) {
580  ViewArray<Int::ConstIntView> xv(home, x.size());
581  for (int i = x.size(); i--; ) {
582  if ((x[i] != 0) && (x[i] != 1))
583  throw Int::NotZeroOne("Int::rel");
584  xv[i] = Int::ConstIntView(x[i]);
585  }
586  return xv;
587  }
588 
589  }
590 
591  void
592  rel(Home home, const BoolVarArgs& x, IntRelType irt, const IntArgs& y,
593  IntPropLevel) {
594  using namespace Int;
595  GECODE_POST;
596 
597  switch (irt) {
598  case IRT_GR:
599  {
600  ViewArray<BoolView> xv(home,x);
601  ViewArray<ConstIntView> yv(viewarray(home,y));
603  ::post(home,yv,xv,true)));
604  }
605  break;
606  case IRT_LE:
607  {
608  ViewArray<BoolView> xv(home,x);
609  ViewArray<ConstIntView> yv(viewarray(home,y));
611  ::post(home,xv,yv,true)));
612  }
613  break;
614  case IRT_GQ:
615  {
616  ViewArray<BoolView> xv(home,x);
617  ViewArray<ConstIntView> yv(viewarray(home,y));
619  ::post(home,yv,xv,false)));
620  }
621  break;
622  case IRT_LQ:
623  {
624  ViewArray<BoolView> xv(home,x);
625  ViewArray<ConstIntView> yv(viewarray(home,y));
627  ::post(home,xv,yv,false)));
628  }
629  break;
630  case IRT_EQ:
631  if (x.size() != y.size()) {
632  home.fail();
633  } else {
634  for (int i=x.size(); i--; )
635  GECODE_ME_FAIL(BoolView(x[i]).eq(home,y[i]));
636  }
637  break;
638  case IRT_NQ:
639  {
640  ViewArray<BoolView> xv(home,x);
641  ViewArray<ConstIntView> yv(viewarray(home,y));
643  ::post(home,xv,yv)));
644  }
645  break;
646  default:
647  throw UnknownRelation("Int::rel");
648  }
649  }
650 
651  void
652  rel(Home home, const IntArgs& x, IntRelType irt, const BoolVarArgs& y,
653  IntPropLevel ipl) {
654  rel(home,y,irt,x,ipl);
655  }
656 
657  void
658  rel(Home home, BoolVar x0, BoolOpType o, BoolVar x1, BoolVar x2,
659  IntPropLevel) {
660  using namespace Int;
661  GECODE_POST;
662  switch (o) {
663  case BOT_AND:
664  {
665  NegBoolView n0(x0); NegBoolView n1(x1); NegBoolView n2(x2);
667  ::post(home,n0,n1,n2)));
668  }
669  break;
670  case BOT_OR:
672  ::post(home,x0,x1,x2)));
673  break;
674  case BOT_IMP:
675  {
676  NegBoolView n0(x0);
678  ::post(home,n0,x1,x2)));
679  }
680  break;
681  case BOT_EQV:
683  ::post(home,x0,x1,x2)));
684  break;
685  case BOT_XOR:
686  {
687  NegBoolView n2(x2);
689  ::post(home,x0,x1,n2)));
690  }
691  break;
692  default:
693  throw UnknownOperation("Int::rel");
694  }
695  }
696 
697  void
698  rel(Home home, BoolVar x0, BoolOpType o, BoolVar x1, int n,
699  IntPropLevel) {
700  using namespace Int;
701  GECODE_POST;
702  if (n == 0) {
703  switch (o) {
704  case BOT_AND:
705  {
706  NegBoolView n0(x0); NegBoolView n1(x1);
708  ::post(home,n0,n1)));
709  }
710  break;
711  case BOT_OR:
712  {
713  BoolView b0(x0); BoolView b1(x1);
714  GECODE_ME_FAIL(b0.zero(home));
715  GECODE_ME_FAIL(b1.zero(home));
716  }
717  break;
718  case BOT_IMP:
719  {
720  BoolView b0(x0); BoolView b1(x1);
721  GECODE_ME_FAIL(b0.one(home));
722  GECODE_ME_FAIL(b1.zero(home));
723  }
724  break;
725  case BOT_EQV:
726  {
727  NegBoolView n0(x0);
729  }
730  break;
731  case BOT_XOR:
733  break;
734  default:
735  throw UnknownOperation("Int::rel");
736  }
737  } else if (n == 1) {
738  switch (o) {
739  case BOT_AND:
740  {
741  BoolView b0(x0); BoolView b1(x1);
742  GECODE_ME_FAIL(b0.one(home));
743  GECODE_ME_FAIL(b1.one(home));
744  }
745  break;
746  case BOT_OR:
748  break;
749  case BOT_IMP:
750  {
751  NegBoolView n0(x0);
753  ::post(home,n0,x1)));
754  }
755  break;
756  case BOT_EQV:
758  break;
759  case BOT_XOR:
760  {
761  NegBoolView n0(x0);
763  }
764  break;
765  default:
766  throw UnknownOperation("Int::rel");
767  }
768  } else {
769  throw NotZeroOne("Int::rel");
770  }
771  }
772 
773  void
775  IntPropLevel) {
776  using namespace Int;
777  GECODE_POST;
778  int m = x.size();
779  Region r;
780  switch (o) {
781  case BOT_AND:
782  {
783  ViewArray<NegBoolView> b(home,m);
784  for (int i=m; i--; ) {
785  NegBoolView nb(x[i]); b[i]=nb;
786  }
787  NegBoolView ny(y);
788  b.unique();
790  ::post(home,b,ny)));
791  }
792  break;
793  case BOT_OR:
794  {
795  ViewArray<BoolView> b(home,x);
796  b.unique();
798  }
799  break;
800  case BOT_IMP:
801  if (m < 2) {
802  throw TooFewArguments("Int::rel");
803  } else {
804  ViewArray<NegBoolView> a(home,x.size()-1);
805  for (int i=x.size()-1; i--; )
806  a[i]=NegBoolView(x[i]);
807  ViewArray<BoolView> b(home,1);
808  b[0]=x[x.size()-1];
810  ::post(home,b,a,y)));
811  }
812  break;
813  case BOT_EQV:
814  {
815  ViewArray<BoolView> xy(home, x.size() + 1);
816  for (int i=x.size(); i--; )
817  xy[i] = x[i];
818  xy[x.size()] = y;
820  }
821  break;
822  case BOT_XOR:
823  {
824  ViewArray<BoolView> xy(home, x.size() + 1);
825  for (int i=x.size(); i--; )
826  xy[i] = x[i];
827  xy[x.size()] = y;
829  }
830  break;
831  default:
832  throw UnknownOperation("Int::rel");
833  }
834  }
835 
836  void
837  rel(Home home, BoolOpType o, const BoolVarArgs& x, int n,
838  IntPropLevel) {
839  using namespace Int;
840  if ((n < 0) || (n > 1))
841  throw NotZeroOne("Int::rel");
842  GECODE_POST;
843  int m = x.size();
844  Region r;
845  switch (o) {
846  case BOT_AND:
847  if (n == 0) {
848  ViewArray<NegBoolView> b(home,m);
849  for (int i=m; i--; ) {
850  NegBoolView nb(x[i]); b[i]=nb;
851  }
852  b.unique();
854  } else {
855  for (int i=m; i--; ) {
856  BoolView b(x[i]); GECODE_ME_FAIL(b.one(home));
857  }
858  }
859  break;
860  case BOT_OR:
861  if (n == 0) {
862  for (int i=m; i--; ) {
863  BoolView b(x[i]); GECODE_ME_FAIL(b.zero(home));
864  }
865  } else {
866  ViewArray<BoolView> b(home,x);
867  b.unique();
869  }
870  break;
871  case BOT_IMP:
872  if (m < 2) {
873  throw TooFewArguments("Int::rel");
874  } else if (n == 0) {
875  for (int i=m-1; i--; )
876  GECODE_ME_FAIL(BoolView(x[i]).one(home));
877  GECODE_ME_FAIL(BoolView(x[m-1]).zero(home));
878  } else {
879  ViewArray<NegBoolView> a(home,x.size()-1);
880  for (int i=x.size()-1; i--; )
881  a[i]=NegBoolView(x[i]);
882  ViewArray<BoolView> b(home,1);
883  b[0]=x[x.size()-1];
885  ::post(home,b,a)));
886  }
887  break;
888  case BOT_EQV:
889  {
890  ViewArray<BoolView> b(home,x);
892  }
893  break;
894  case BOT_XOR:
895  {
896  ViewArray<BoolView> b(home,x);
897  GECODE_ES_FAIL(Bool::NaryEqv::post(home,b,1^n));
898  }
899  break;
900  default:
901  throw UnknownOperation("Int::rel");
902  }
903  }
904 
905  void
906  clause(Home home, BoolOpType o, const BoolVarArgs& x, const BoolVarArgs& y,
907  int n, IntPropLevel) {
908  using namespace Int;
909  if ((n < 0) || (n > 1))
910  throw NotZeroOne("Int::rel");
911  GECODE_POST;
912  switch (o) {
913  case BOT_AND:
914  if (n == 0) {
915  ViewArray<NegBoolView> xv(home,x.size());
916  for (int i=x.size(); i--; ) {
917  NegBoolView nxi(x[i]); xv[i]=nxi;
918  }
919  ViewArray<BoolView> yv(home,y);
920  xv.unique(); yv.unique();
922  ::post(home,xv,yv)));
923  } else {
924  for (int i=x.size(); i--; ) {
925  BoolView b(x[i]); GECODE_ME_FAIL(b.one(home));
926  }
927  for (int i=y.size(); i--; ) {
928  BoolView b(y[i]); GECODE_ME_FAIL(b.zero(home));
929  }
930  }
931  break;
932  case BOT_OR:
933  if (n == 0) {
934  for (int i=x.size(); i--; ) {
935  BoolView b(x[i]); GECODE_ME_FAIL(b.zero(home));
936  }
937  for (int i=y.size(); i--; ) {
938  BoolView b(y[i]); GECODE_ME_FAIL(b.one(home));
939  }
940  } else {
941  ViewArray<BoolView> xv(home,x);
942  ViewArray<NegBoolView> yv(home,y.size());
943  for (int i=y.size(); i--; ) {
944  NegBoolView nyi(y[i]); yv[i]=nyi;
945  }
946  xv.unique(); yv.unique();
948  ::post(home,xv,yv)));
949  }
950  break;
951  default:
952  throw IllegalOperation("Int::clause");
953  }
954  }
955 
956  void
957  clause(Home home, BoolOpType o, const BoolVarArgs& x, const BoolVarArgs& y,
959  using namespace Int;
960  GECODE_POST;
961  switch (o) {
962  case BOT_AND:
963  {
964  ViewArray<NegBoolView> xv(home,x.size());
965  for (int i=x.size(); i--; ) {
966  NegBoolView n(x[i]); xv[i]=n;
967  }
968  ViewArray<BoolView> yv(home,y);
969  xv.unique(); yv.unique();
970  NegBoolView nz(z);
972  ::post(home,xv,yv,nz)));
973  }
974  break;
975  case BOT_OR:
976  {
977  ViewArray<BoolView> xv(home,x);
978  ViewArray<NegBoolView> yv(home,y.size());
979  for (int i=y.size(); i--; ) {
980  NegBoolView n(y[i]); yv[i]=n;
981  }
982  xv.unique(); yv.unique();
984  ::post(home,xv,yv,z)));
985  }
986  break;
987  default:
988  throw IllegalOperation("Int::clause");
989  }
990  }
991 
992  void
994  IntPropLevel ipl) {
995  using namespace Int;
996  GECODE_POST;
997  if (vbd(ipl) == IPL_BND) {
999  ::post(home,b,x,y,z)));
1000  } else {
1002  ::post(home,b,x,y,z)));
1003  }
1004  }
1005 
1006  void
1008  IntPropLevel) {
1009  using namespace Int;
1010  GECODE_POST;
1012  ::post(home,b,x,y,z)));
1013  }
1014 
1015 }
1016 
1017 // STATISTICS: int-post
Bounds propagation.
Definition: int.hh:953
If-then-else bounds-consistent propagator.
Definition: bool.hh:606
IntPropLevel vbd(IntPropLevel ipl)
Extract value, bounds, or domain propagation from propagation level.
Definition: ipl.hpp:37
bool zero(void) const
Test whether view is assigned to be zero.
Definition: bool.hpp:220
Inverse implication for reification.
Definition: int.hh:844
int size(void) const
Return size of array (number of elements)
Definition: array.hpp:1653
Boolean clause propagator (disjunctive, true)
Definition: bool.hh:546
ReifyMode mode(void) const
Return reification mode.
Definition: reify.hpp:56
Negated Boolean view.
Definition: view.hpp:1543
bool one(const Gecode::FloatValArgs &a)
Check whether has only one coefficients.
Definition: linear.cpp:46
BoolOpType
Operation types for Booleans.
Definition: int.hh:925
bool one(void) const
Test whether view is assigned to be one.
Definition: bool.hpp:224
Less or equal ( )
Definition: int.hh:903
Conjunction.
Definition: int.hh:926
Exception: Too few arguments available in argument array
Definition: exception.hpp:66
Exception: Unknown operation passed as argument
Definition: exception.hpp:94
Implication.
Definition: int.hh:928
Lexical disequality propagator.
Definition: rel.hh:661
Boolean clause propagator (disjunctive)
Definition: bool.hh:492
static ExecStatus post(Home home, ViewArray< BoolView > &x, int pm2)
Post propagator .
Definition: eqv.cpp:54
Handle to region.
Definition: region.hpp:53
Greater ( )
Definition: int.hh:906
Computation spaces.
Definition: core.hpp:1701
Greater or equal ( )
Definition: int.hh:905
Exclusive or.
Definition: int.hh:930
ModEvent eq(Space &home, int n)
Restrict domain values to be equal to n.
Definition: bool.hpp:170
Reified less or equal propagator.
Definition: rel.hh:552
Nary disequality propagator.
Definition: rel.hh:318
Exception: Unknown relation passed as argument
Definition: exception.hpp:87
Gecode::IntArgs i(4, 1, 2, 3, 4)
int n
Number of negative literals for node type.
Definition: bool-expr.cpp:234
Equality ( )
Definition: int.hh:901
n-ary Boolean equality propagator
Definition: bool.hh:133
Boolean equivalence propagator.
Definition: bool.hh:426
IntRelType
Relation types for integers.
Definition: int.hh:900
Exception: Illegal operation passed as argument
Definition: exception.hpp:101
Boolean disjunction propagator.
Definition: bool.hh:328
Reification specification.
Definition: int.hh:851
Reified binary bounds consistent equality propagator.
Definition: rel.hh:372
Less ( )
Definition: int.hh:904
Boolean equality propagator.
Definition: bool.hh:105
Post propagator for SetVar SetOpType SetVar SetRelType SetVar z
Definition: set.hh:765
Disjunction.
Definition: int.hh:927
Passing integer arguments.
Definition: int.hh:604
Passing Boolean variables.
Definition: int.hh:687
Boolean less or equal propagator.
Definition: bool.hh:159
Boolean integer variables.
Definition: int.hh:488
Post propagator for SetVar SetOpType SetVar SetRelType r
Definition: set.hh:765
If-then-else domain-consistent propagator.
Definition: bool.hh:632
Boolean n-ary disjunction propagator (true)
Definition: bool.hh:393
IntPropLevel
Propagation levels for integer propagators.
Definition: int.hh:949
Constant integer view.
Definition: view.hpp:828
struct Gecode::@585::NNF::@62::@63 b
For binary nodes (and, or, eqv)
Post propagator for SetVar SetOpType SetVar y
Definition: set.hh:765
Boolean less propagator.
Definition: bool.hh:223
Nary Boolean less or equal propagator.
Definition: bool.hh:183
struct Gecode::@585::NNF::@62::@64 a
For atomic nodes.
Lexical ordering propagator.
Definition: rel.hh:627
Boolean n-ary disjunction propagator.
Definition: bool.hh:355
Binary Boolean disjunction propagator (true)
Definition: bool.hh:237
Integer variables.
Definition: int.hh:347
void rel(Home home, FloatVar x0, FloatRelType frt, FloatVal n)
Propagates .
Definition: rel.cpp:43
Equivalence.
Definition: int.hh:929
BoolVar var(void) const
Return Boolean control variable.
Definition: reify.hpp:48
Post propagator for SetVar x
Definition: set.hh:765
Exception: Not 0/1 integer
Definition: exception.hpp:51
void unique(void)
Remove all duplicate views from array (changes element order)
Definition: array.hpp:1489
#define GECODE_ME_FAIL(me)
Check whether modification event me is failed, and fail space home.
Definition: macros.hpp:77
void fail(void)
Mark space as failed.
Definition: core.hpp:3958
Exception: Unknown reification mode passed as argument
Definition: exception.hpp:115
Gecode toplevel namespace
Implication for reification.
Definition: int.hh:837
Disequality ( )
Definition: int.hh:902
#define GECODE_POST
Check for failure in a constraint post function.
Definition: macros.hpp:40
Home class for posting propagators
Definition: core.hpp:853
#define GECODE_ES_FAIL(es)
Check whether execution status es is failed, and fail space home.
Definition: macros.hpp:103
void ite(Home home, BoolVar b, FloatVar x, FloatVar y, FloatVar z)
Post propagator for if-then-else constraint.
Definition: bool.cpp:39
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
Equivalence for reification (default)
Definition: int.hh:830
IntRelType swap(IntRelType irt)
Return swapped relation type of irt.
Definition: irt.hpp:37
Boolean view for Boolean variables.
Definition: view.hpp:1349