Generated on Sat Feb 7 2015 02:01:20 for Gecode by doxygen 1.8.9.1
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: 2013-04-29 20:52:35 +0200 (Mon, 29 Apr 2013) $ by $Author: schulte $
11  * $Revision: 13590 $
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
44  rel(Home home, BoolVar x0, IntRelType irt, BoolVar x1, IntConLevel) {
45  using namespace Int;
46  if (home.failed()) return;
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, IntConLevel) {
78  using namespace Int;
79  if (home.failed()) return;
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  IntConLevel) {
119  using namespace Int;
120  if (home.failed()) return;
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  IntConLevel) {
214  using namespace Int;
215  if (home.failed()) return;
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  IntConLevel) {
376  using namespace Int;
377  if (home.failed()) return;
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  IntConLevel) {
422  using namespace Int;
423  if (home.failed()) return;
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, IntConLevel) {
473  using namespace Int;
474  if (home.failed() || ((irt != IRT_NQ) && (x.size() < 2)))
475  return;
476 
477  switch (irt) {
478  case IRT_EQ:
479  {
480  ViewArray<BoolView> y(home,x);
482  }
483  break;
484  case IRT_NQ:
485  {
486  ViewArray<BoolView> y(home,x);
488  }
489  break;
490  case IRT_LE:
491  if (x.size() == 2) {
492  GECODE_ES_FAIL(Bool::Le<BoolView>::post(home,x[0],x[1]));
493  } else {
494  home.fail();
495  }
496  break;
497  case IRT_LQ:
498  {
499  ViewArray<BoolView> y(home,x);
501  }
502  break;
503  case IRT_GR:
504  if (x.size() == 2) {
505  GECODE_ES_FAIL(Bool::Le<BoolView>::post(home,x[1],x[0]));
506  } else {
507  home.fail();
508  }
509  break;
510  case IRT_GQ:
511  {
512  ViewArray<BoolView> y(home,x.size());
513  for (int i=x.size(); i--; )
514  y[i] = x[x.size()-1-i];
516  }
517  for (int i=x.size()-1; i--; )
519  break;
520  default:
521  throw UnknownRelation("Int::rel");
522  }
523  }
524 
525  void
526  rel(Home home, const BoolVarArgs& x, IntRelType irt, const BoolVarArgs& y,
527  IntConLevel) {
528  using namespace Int;
529  if (x.size() != y.size())
530  throw ArgumentSizeMismatch("Int::rel");
531  if (home.failed()) return;
532 
533  switch (irt) {
534  case IRT_GR:
535  {
536  ViewArray<BoolView> xv(home,x), yv(home,y);
538  }
539  break;
540  case IRT_LE:
541  {
542  ViewArray<BoolView> xv(home,x), yv(home,y);
544  }
545  break;
546  case IRT_GQ:
547  {
548  ViewArray<BoolView> xv(home,x), yv(home,y);
549  GECODE_ES_FAIL(Rel::LexLqLe<BoolView>::post(home,yv,xv,false));
550  }
551  break;
552  case IRT_LQ:
553  {
554  ViewArray<BoolView> xv(home,x), yv(home,y);
555  GECODE_ES_FAIL(Rel::LexLqLe<BoolView>::post(home,xv,yv,false));
556  }
557  break;
558  case IRT_EQ:
559  for (int i=x.size(); i--; ) {
561  ::post(home,x[i],y[i])));
562  }
563  break;
564  case IRT_NQ:
565  {
566  ViewArray<BoolView> xv(home,x), yv(home,y);
568  }
569  break;
570  default:
571  throw UnknownRelation("Int::rel");
572  }
573  }
574 
575  void
576  rel(Home home, BoolVar x0, BoolOpType o, BoolVar x1, BoolVar x2,
577  IntConLevel) {
578  using namespace Int;
579  if (home.failed()) return;
580  switch (o) {
581  case BOT_AND:
582  {
583  NegBoolView n0(x0); NegBoolView n1(x1); NegBoolView n2(x2);
585  ::post(home,n0,n1,n2)));
586  }
587  break;
588  case BOT_OR:
590  ::post(home,x0,x1,x2)));
591  break;
592  case BOT_IMP:
593  {
594  NegBoolView n0(x0);
596  ::post(home,n0,x1,x2)));
597  }
598  break;
599  case BOT_EQV:
601  ::post(home,x0,x1,x2)));
602  break;
603  case BOT_XOR:
604  {
605  NegBoolView n2(x2);
607  ::post(home,x0,x1,n2)));
608  }
609  break;
610  default:
611  throw UnknownOperation("Int::rel");
612  }
613  }
614 
615  void
616  rel(Home home, BoolVar x0, BoolOpType o, BoolVar x1, int n,
617  IntConLevel) {
618  using namespace Int;
619  if (home.failed()) return;
620  if (n == 0) {
621  switch (o) {
622  case BOT_AND:
623  {
624  NegBoolView n0(x0); NegBoolView n1(x1);
626  ::post(home,n0,n1)));
627  }
628  break;
629  case BOT_OR:
630  {
631  BoolView b0(x0); BoolView b1(x1);
632  GECODE_ME_FAIL(b0.zero(home));
633  GECODE_ME_FAIL(b1.zero(home));
634  }
635  break;
636  case BOT_IMP:
637  {
638  BoolView b0(x0); BoolView b1(x1);
639  GECODE_ME_FAIL(b0.one(home));
640  GECODE_ME_FAIL(b1.zero(home));
641  }
642  break;
643  case BOT_EQV:
644  {
645  NegBoolView n0(x0);
647  }
648  break;
649  case BOT_XOR:
651  break;
652  default:
653  throw UnknownOperation("Int::rel");
654  }
655  } else if (n == 1) {
656  switch (o) {
657  case BOT_AND:
658  {
659  BoolView b0(x0); BoolView b1(x1);
660  GECODE_ME_FAIL(b0.one(home));
661  GECODE_ME_FAIL(b1.one(home));
662  }
663  break;
664  case BOT_OR:
666  break;
667  case BOT_IMP:
668  {
669  NegBoolView n0(x0);
671  ::post(home,n0,x1)));
672  }
673  break;
674  case BOT_EQV:
676  break;
677  case BOT_XOR:
678  {
679  NegBoolView n0(x0);
681  }
682  break;
683  default:
684  throw UnknownOperation("Int::rel");
685  }
686  } else {
687  throw NotZeroOne("Int::rel");
688  }
689  }
690 
691  void
692  rel(Home home, BoolOpType o, const BoolVarArgs& x, BoolVar y,
693  IntConLevel) {
694  using namespace Int;
695  if (home.failed()) return;
696  int m = x.size();
697  Region r(home);
698  switch (o) {
699  case BOT_AND:
700  {
701  ViewArray<NegBoolView> b(home,m);
702  for (int i=m; i--; ) {
703  NegBoolView nb(x[i]); b[i]=nb;
704  }
705  NegBoolView ny(y);
706  b.unique(home);
708  ::post(home,b,ny)));
709  }
710  break;
711  case BOT_OR:
712  {
713  ViewArray<BoolView> b(home,x);
714  b.unique(home);
716  }
717  break;
718  case BOT_IMP:
719  if (m < 2) {
720  throw TooFewArguments("Int::rel");
721  } else {
722  ViewArray<NegBoolView> a(home,x.size()-1);
723  for (int i=x.size()-1; i--; )
724  a[i]=NegBoolView(x[i]);
725  ViewArray<BoolView> b(home,1);
726  b[0]=x[x.size()-1];
728  ::post(home,b,a,y)));
729  }
730  break;
731  case BOT_EQV:
732  {
733  ViewArray<BoolView> xy(home, x.size() + 1);
734  for (int i=x.size(); i--; )
735  xy[i] = x[i];
736  xy[x.size()] = y;
738  }
739  break;
740  case BOT_XOR:
741  {
742  ViewArray<BoolView> xy(home, x.size() + 1);
743  for (int i=x.size(); i--; )
744  xy[i] = x[i];
745  xy[x.size()] = y;
747  }
748  break;
749  default:
750  throw UnknownOperation("Int::rel");
751  }
752  }
753 
754  void
755  rel(Home home, BoolOpType o, const BoolVarArgs& x, int n,
756  IntConLevel) {
757  using namespace Int;
758  if ((n < 0) || (n > 1))
759  throw NotZeroOne("Int::rel");
760  if (home.failed()) return;
761  int m = x.size();
762  Region r(home);
763  switch (o) {
764  case BOT_AND:
765  if (n == 0) {
766  ViewArray<NegBoolView> b(home,m);
767  for (int i=m; i--; ) {
768  NegBoolView nb(x[i]); b[i]=nb;
769  }
770  b.unique(home);
772  } else {
773  for (int i=m; i--; ) {
774  BoolView b(x[i]); GECODE_ME_FAIL(b.one(home));
775  }
776  }
777  break;
778  case BOT_OR:
779  if (n == 0) {
780  for (int i=m; i--; ) {
781  BoolView b(x[i]); GECODE_ME_FAIL(b.zero(home));
782  }
783  } else {
784  ViewArray<BoolView> b(home,x);
785  b.unique(home);
787  }
788  break;
789  case BOT_IMP:
790  if (m < 2) {
791  throw TooFewArguments("Int::rel");
792  } else if (n == 0) {
793  for (int i=m-1; i--; )
794  GECODE_ME_FAIL(BoolView(x[i]).one(home));
795  GECODE_ME_FAIL(BoolView(x[m-1]).zero(home));
796  } else {
797  ViewArray<NegBoolView> a(home,x.size()-1);
798  for (int i=x.size()-1; i--; )
799  a[i]=NegBoolView(x[i]);
800  ViewArray<BoolView> b(home,1);
801  b[0]=x[x.size()-1];
803  ::post(home,b,a)));
804  }
805  break;
806  case BOT_EQV:
807  {
808  ViewArray<BoolView> b(home,x);
810  }
811  break;
812  case BOT_XOR:
813  {
814  ViewArray<BoolView> b(home,x);
815  GECODE_ES_FAIL(Bool::NaryEqv::post(home,b,1^n));
816  }
817  break;
818  default:
819  throw UnknownOperation("Int::rel");
820  }
821  }
822 
823  void
824  clause(Home home, BoolOpType o, const BoolVarArgs& x, const BoolVarArgs& y,
825  int n, IntConLevel) {
826  using namespace Int;
827  if ((n < 0) || (n > 1))
828  throw NotZeroOne("Int::rel");
829  if (home.failed()) return;
830  switch (o) {
831  case BOT_AND:
832  if (n == 0) {
833  ViewArray<NegBoolView> xv(home,x.size());
834  for (int i=x.size(); i--; ) {
835  NegBoolView n(x[i]); xv[i]=n;
836  }
837  ViewArray<BoolView> yv(home,y);
838  xv.unique(home); yv.unique(home);
840  ::post(home,xv,yv)));
841  } else {
842  for (int i=x.size(); i--; ) {
843  BoolView b(x[i]); GECODE_ME_FAIL(b.one(home));
844  }
845  for (int i=y.size(); i--; ) {
846  BoolView b(y[i]); GECODE_ME_FAIL(b.zero(home));
847  }
848  }
849  break;
850  case BOT_OR:
851  if (n == 0) {
852  for (int i=x.size(); i--; ) {
853  BoolView b(x[i]); GECODE_ME_FAIL(b.zero(home));
854  }
855  for (int i=y.size(); i--; ) {
856  BoolView b(y[i]); GECODE_ME_FAIL(b.one(home));
857  }
858  } else {
859  ViewArray<BoolView> xv(home,x);
860  ViewArray<NegBoolView> yv(home,y.size());
861  for (int i=y.size(); i--; ) {
862  NegBoolView n(y[i]); yv[i]=n;
863  }
864  xv.unique(home); yv.unique(home);
866  ::post(home,xv,yv)));
867  }
868  break;
869  default:
870  throw IllegalOperation("Int::clause");
871  }
872  }
873 
874  void
875  clause(Home home, BoolOpType o, const BoolVarArgs& x, const BoolVarArgs& y,
876  BoolVar z, IntConLevel) {
877  using namespace Int;
878  if (home.failed()) return;
879  switch (o) {
880  case BOT_AND:
881  {
882  ViewArray<NegBoolView> xv(home,x.size());
883  for (int i=x.size(); i--; ) {
884  NegBoolView n(x[i]); xv[i]=n;
885  }
886  ViewArray<BoolView> yv(home,y);
887  xv.unique(home); yv.unique(home);
888  NegBoolView nz(z);
890  ::post(home,xv,yv,nz)));
891  }
892  break;
893  case BOT_OR:
894  {
895  ViewArray<BoolView> xv(home,x);
896  ViewArray<NegBoolView> yv(home,y.size());
897  for (int i=y.size(); i--; ) {
898  NegBoolView n(y[i]); yv[i]=n;
899  }
900  xv.unique(home); yv.unique(home);
902  ::post(home,xv,yv,z)));
903  }
904  break;
905  default:
906  throw IllegalOperation("Int::clause");
907  }
908  }
909 
910  void
912  IntConLevel icl) {
913  using namespace Int;
914  if (home.failed()) return;
915  if (icl == ICL_BND) {
917  } else {
919  }
920  }
921 
922 }
923 
924 // STATISTICS: int-post
bool failed(void) const
Check whether corresponding space is failed.
Definition: core.hpp:3446
If-then-else bounds-consistent propagator.
Definition: bool.hh:600
IntConLevel
Consistency levels for integer propagators.
Definition: int.hh:937
Inverse implication for reification.
Definition: int.hh:847
ReifyMode mode(void) const
Return reification mode.
Definition: reify.hpp:60
Boolean clause propagator (disjunctive, true)
Definition: bool.hh:542
void post(Home home, Term *t, int n, FloatRelType frt, FloatVal c)
Post propagator for linear constraint over floats.
Definition: post.cpp:228
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
int size(void) const
Return size of array (number of elements)
Definition: array.hpp:1662
BoolOpType
Operation types for Booleans.
Definition: int.hh:916
Less or equal ( )
Definition: int.hh:906
Conjunction.
Definition: int.hh:917
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:919
Lexical disequality propagator.
Definition: rel.hh:628
Boolean clause propagator (disjunctive)
Definition: bool.hh:490
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:909
void unique(const Space &home)
Remove all duplicate views from array (changes element order)
Definition: array.hpp:1498
Greater or equal ( )
Definition: int.hh:908
Exclusive or.
Definition: int.hh:921
Reified less or equal propagator.
Definition: rel.hh:522
Nary disequality propagator.
Definition: rel.hh:290
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
n-ary Boolean equality propagator
Definition: bool.hh:133
Boolean equivalence propagator.
Definition: bool.hh:424
IntRelType
Relation types for integers.
Definition: int.hh:903
Exception: Illegal operation passed as argument
Definition: exception.hpp:105
NNF * r
Right subtree.
Definition: bool-expr.cpp:246
void clause(Home home, BoolOpType o, const BoolVarArgs &x, const BoolVarArgs &y, int n, IntConLevel)
Post domain consistent propagator for Boolean clause with positive variables x and negative variables...
Definition: bool.cpp:824
Boolean disjunction propagator.
Definition: bool.hh:328
Reification specification.
Definition: int.hh:854
Reified binary bounds consistent equality propagator.
Definition: rel.hh:344
Less ( )
Definition: int.hh:907
Boolean equality propagator.
Definition: bool.hh:105
Disjunction.
Definition: int.hh:918
void ite(Home home, BoolVar b, IntVar x, IntVar y, IntVar z, IntConLevel icl)
Post propagator for if-then-else constraint.
Definition: bool.cpp:911
Passing Boolean variables.
Definition: int.hh:690
Boolean less or equal propagator.
Definition: bool.hh:159
Boolean integer variables.
Definition: int.hh:491
If-then-else domain-consistent propagator.
Definition: bool.hh:626
Boolean n-ary disjunction propagator (true)
Definition: bool.hh:391
bool one(void) const
Test whether view is assigned to be one.
Definition: bool.hpp:218
Boolean less propagator.
Definition: bool.hh:223
Nary Boolean less or equal propagator.
Definition: bool.hh:183
Node * x
Pointer to corresponding Boolean expression node.
Definition: bool-expr.cpp:253
Lexical ordering propagator.
Definition: rel.hh:597
Boolean n-ary disjunction propagator.
Definition: bool.hh:355
Binary Boolean disjunction propagator (true)
Definition: bool.hh:237
Integer variables.
Definition: int.hh:350
void rel(Home home, FloatVar x0, FloatRelType frt, FloatVal n)
Propagates .
Definition: rel.cpp:47
Equivalence.
Definition: int.hh:920
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:70
void fail(void)
Mark space as failed.
Definition: core.hpp:3437
Bounds propagation or consistency.
Definition: int.hh:939
Exception: Unknown reification mode passed as argument
Definition: exception.hpp:119
struct Gecode::@518::NNF::@57::@58 b
For binary nodes (and, or, eqv)
Gecode toplevel namespace
Implication for reification.
Definition: int.hh:840
Disequality ( )
Definition: int.hh:905
bool zero(void) const
Test whether view is assigned to be zero.
Definition: bool.hpp:214
Home class for posting propagators
Definition: core.hpp:717
Exception: Arguments are of different size
Definition: exception.hpp:77
#define GECODE_ES_FAIL(es)
Check whether execution status es is failed, and fail space home.
Definition: macros.hpp:96
struct Gecode::@518::NNF::@57::@59 a
For atomic nodes.
Equivalence for reification (default)
Definition: int.hh:833
Boolean view for Boolean variables.
Definition: view.hpp:1315