Generated on Tue Jan 28 2020 00:00:00 for Gecode by doxygen 1.8.17
set.cpp
Go to the documentation of this file.
1 /* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
2 /*
3  * Main authors:
4  * Guido Tack <tack@gecode.org>
5  * Christian Schulte <schulte@gecode.org>
6  * Mikael Lagerkvist <lagerkvist@gecode.org>
7  *
8  * Copyright:
9  * Guido Tack, 2005
10  * Christian Schulte, 2005
11  * Mikael Lagerkvist, 2005
12  *
13  * Last modified:
14  * $Date: 2017-03-10 10:15:56 +0100 (Fri, 10 Mar 2017) $ by $Author: schulte $
15  * $Revision: 15566 $
16  *
17  * This file is part of Gecode, the generic constraint
18  * development environment:
19  * http://www.gecode.org
20  *
21  * Permission is hereby granted, free of charge, to any person obtaining
22  * a copy of this software and associated documentation files (the
23  * "Software"), to deal in the Software without restriction, including
24  * without limitation the rights to use, copy, modify, merge, publish,
25  * distribute, sublicense, and/or sell copies of the Software, and to
26  * permit persons to whom the Software is furnished to do so, subject to
27  * the following conditions:
28  *
29  * The above copyright notice and this permission notice shall be
30  * included in all copies or substantial portions of the Software.
31  *
32  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
33  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
34  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
35  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
36  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
37  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
38  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
39  *
40  */
41 
42 #include "test/set.hh"
43 
44 #include <algorithm>
45 
46 namespace Test { namespace Set {
47 
48  CountableSet::CountableSet(const Gecode::IntSet& d0) : d(d0), cur(0) {
49  Gecode::IntSetRanges isr(d);
50  lubmax =
51  static_cast<unsigned int>(pow(static_cast<double>(2.0),
52  static_cast<int>(Gecode::Iter::Ranges::size(isr))));
53  }
54 
56  cur++;
57  }
58 
60  d = d0;
61  cur = 0;
62  Gecode::IntSetRanges isr(d);
63  lubmax =
64  static_cast<unsigned int>(pow(static_cast<double>(2.0),
65  static_cast<int>(Gecode::Iter::Ranges::size(isr))));
66  }
67 
68  int CountableSet::val(void) const {
69  return cur;
70  }
71 
72  SetAssignment::SetAssignment(int n0, const Gecode::IntSet& d0, int _withInt)
73  : n(n0), dsv(new CountableSet[n]), ir(_withInt, d0), done(false), lub(d0),
74  withInt(_withInt) {
75  for (int i=n; i--; )
76  dsv[i].init(lub);
77  }
78 
79  void
81  int i = n-1;
82  while (true) {
83  ++dsv[i];
84  if (dsv[i]())
85  return;
86  dsv[i].init(lub);
87  --i;
88  if (i<0) {
89  if (withInt==0) {
90  done = true;
91  return;
92  }
93  ++ir;
94  if (ir()) {
95  i = n-1;
96  for (int j=n; j--; )
97  dsv[j].init(lub);
98  } else {
99  done = true;
100  return;
101  }
102  }
103  }
104  }
105 
106 }}
107 
108 std::ostream&
109 operator<<(std::ostream& os, const Test::Set::SetAssignment& a) {
110  int n = a.size();
111  os << "{";
112  for (int i=0; i<n; i++) {
114  Gecode::IntSet icsv(csv);
115  os << icsv << ((i!=n-1) ? "," : "}");
116  }
117  if (a.withInt > 0)
118  os << a.ints();
119  return os;
120 }
121 
122 namespace Test { namespace Set {
123 
125  SetTest* t, bool log)
126  : d(d0), y(*this, i, d),
127  withInt(i), r(Gecode::BoolVar(*this, 0, 1),Gecode::RM_EQV),
128  reified(false), test(t) {
129  using namespace Gecode;
131  x = SetVarArray(*this, n, Gecode::IntSet::empty, u);
132  SetVarArgs _x(*this, n, Gecode::IntSet::empty, d);
133  if (x.size() == 1)
134  dom(*this,x[0],_x[0]);
135  else
136  dom(*this,x,_x);
137  if (opt.log && log) {
138  olog << ind(2) << "Initial: x[]=" << x;
139  olog << " y[]=" << y;
140  olog << std::endl;
141  }
142  }
143 
145  SetTest* t, Gecode::ReifyMode rm, bool log)
146  : d(d0), x(*this, n, Gecode::IntSet::empty, d), y(*this, i, d),
147  withInt(i), r(Gecode::BoolVar(*this, 0, 1),rm),
148  reified(true), test(t) {
149  if (opt.log && log) {
150  olog << ind(2) << "Initial: x[]=" << x;
151  olog << " y[]=" << y;
152  olog << " b=" << r.var();
153  olog << std::endl;
154  }
155  }
156 
158  : Gecode::Space(share,s), d(s.d), withInt(s.withInt),
159  reified(s.reified), test(s.test) {
160  x.update(*this, share, s.x);
161  y.update(*this, share, s.y);
163  Gecode::BoolVar sr(s.r.var());
164  b.update(*this, share, sr);
165  r.var(b); r.mode(s.r.mode());
166  }
167 
169  SetTestSpace::copy(bool share) {
170  return new SetTestSpace(share,*this);
171  }
172 
173  void
175  if (reified){
176  test->post(*this,x,y,r);
177  if (opt.log)
178  olog << ind(3) << "Posting reified propagator" << std::endl;
179  } else {
180  test->post(*this,x,y);
181  if (opt.log)
182  olog << ind(3) << "Posting propagator" << std::endl;
183  }
184  }
185 
186  bool
188  if (opt.log) {
189  olog << ind(3) << "Fixpoint: x[]=" << x
190  << " y[]=" << y << std::endl;
191  bool f=(status() == Gecode::SS_FAILED);
192  olog << ind(3) << " --> x[]=" << x
193  << " y[]=" << y << std::endl;
194  return f;
195  } else {
196  return status() == Gecode::SS_FAILED;
197  }
198  }
199 
200  bool
202  return b ? (propagators() == 0) : true;
203  }
204 
205  void
207  if (opt.log) {
208  olog << ind(4) << "x[" << i << "] ";
209  switch (srt) {
210  case Gecode::SRT_EQ: olog << "="; break;
211  case Gecode::SRT_LQ: olog << "<="; break;
212  case Gecode::SRT_LE: olog << "<"; break;
213  case Gecode::SRT_GQ: olog << ">="; break;
214  case Gecode::SRT_GR: olog << ">"; break;
215  case Gecode::SRT_NQ: olog << "!="; break;
216  case Gecode::SRT_SUB: olog << "sub"; break;
217  case Gecode::SRT_SUP: olog << "sup"; break;
218  case Gecode::SRT_DISJ: olog << "||"; break;
219  case Gecode::SRT_CMPL: olog << "^-1 = "; break;
220  }
221  olog << is << std::endl;
222  }
223  Gecode::dom(*this, x[i], srt, is);
224  }
225 
226  void
227  SetTestSpace::cardinality(int i, int cmin, int cmax) {
228  if (opt.log) {
229  olog << ind(4) << cmin << " <= #(x[" << i << "]) <= " << cmax
230  << std::endl;
231  }
232  Gecode::cardinality(*this, x[i], cmin, cmax);
233  }
234 
235  void
237  if (opt.log) {
238  olog << ind(4) << "y[" << i << "] ";
239  switch (irt) {
240  case Gecode::IRT_EQ: olog << "="; break;
241  case Gecode::IRT_NQ: olog << "!="; break;
242  case Gecode::IRT_LQ: olog << "<="; break;
243  case Gecode::IRT_LE: olog << "<"; break;
244  case Gecode::IRT_GQ: olog << ">="; break;
245  case Gecode::IRT_GR: olog << ">"; break;
246  }
247  olog << " " << n << std::endl;
248  }
249  Gecode::rel(*this, y[i], irt, n);
250  }
251 
252  void
253  SetTestSpace::rel(bool sol) {
254  int n = sol ? 1 : 0;
255  assert(reified);
256  if (opt.log)
257  olog << ind(4) << "b = " << n << std::endl;
258  Gecode::rel(*this, r.var(), Gecode::IRT_EQ, n);
259  }
260 
261  void
263  for (int i=a.size(); i--; ) {
264  CountableSetRanges csv(a.lub, a[i]);
265  Gecode::IntSet ai(csv);
266  rel(i, Gecode::SRT_EQ, ai);
267  if (Base::fixpoint() && failed())
268  return;
269  }
270  for (int i=withInt; i--; ) {
271  rel(i, Gecode::IRT_EQ, a.ints()[i]);
272  if (Base::fixpoint() && failed())
273  return;
274  }
275  }
276 
277  bool
279  for (int i=x.size(); i--; )
280  if (!x[i].assigned())
281  return false;
282  for (int i=y.size(); i--; )
283  if (!y[i].assigned())
284  return false;
285  return true;
286  }
287 
288  void
290  using namespace Gecode;
291  SetVarUnknownRanges ur(x[i]);
292  CountableSetRanges air(a.lub, a[i]);
294  CountableSetRanges> diff(ur, air);
297  for (int j=0; j<v; j++, ++diffV) {}
298  rel(i, Gecode::SRT_DISJ, Gecode::IntSet(diffV.val(), diffV.val()));
299  }
300 
301  void
303  SetTestSpace& c) {
304  using namespace Gecode;
305  SetVarUnknownRanges ur(x[i]);
306  CountableSetRanges air(a.lub, a[i]);
308  CountableSetRanges> diff(ur, air);
311  for (int j=0; j<v; j++, ++diffV) {}
312  rel(i, Gecode::SRT_DISJ, Gecode::IntSet(diffV.val(), diffV.val()));
313  c.rel(i, Gecode::SRT_DISJ, Gecode::IntSet(diffV.val(), diffV.val()));
314  }
315 
316  void
318  using namespace Gecode;
319  SetVarUnknownRanges ur(x[i]);
320  CountableSetRanges air(a.lub, a[i]);
322  CountableSetRanges> inter(ur, air);
325  for (int j=0; j<v; j++, ++interV) {}
326  rel(i, Gecode::SRT_SUP, Gecode::IntSet(interV.val(), interV.val()));
327  }
328 
329  void
331  SetTestSpace& c) {
332  using namespace Gecode;
333  SetVarUnknownRanges ur(x[i]);
334  CountableSetRanges air(a.lub, a[i]);
336  CountableSetRanges> inter(ur, air);
339  for (int j=0; j<v; j++, ++interV) {}
340  rel(i, Gecode::SRT_SUP, Gecode::IntSet(interV.val(), interV.val()));
341  c.rel(i, Gecode::SRT_SUP, Gecode::IntSet(interV.val(), interV.val()));
342  }
343 
344  bool
346  if (failed())
347  return true;
348  SetTestSpace* c = static_cast<SetTestSpace*>(clone());
349  if (opt.log)
350  olog << ind(3) << "Testing fixpoint on copy" << std::endl;
351  c->post();
352  if (c->failed()) {
353  delete c; return false;
354  }
355 
356  for (int i=x.size(); i--; )
357  if (x[i].glbSize() != c->x[i].glbSize() ||
358  x[i].lubSize() != c->x[i].lubSize() ||
359  x[i].cardMin() != c->x[i].cardMin() ||
360  x[i].cardMax() != c->x[i].cardMax()) {
361  delete c;
362  return false;
363  }
364  for (int i=y.size(); i--; )
365  if (y[i].size() != c->y[i].size()) {
366  delete c; return false;
367  }
368  if (reified && (r.var().size() != c->r.var().size())) {
369  delete c; return false;
370  }
371  if (opt.log)
372  olog << ind(3) << "Finished testing fixpoint on copy" << std::endl;
373  delete c;
374  return true;
375  }
376 
377  bool
379  if (opt.log)
380  olog << ind(3) << "Testing whether enabled space is the same"
381  << std::endl;
382  bool f = failed();
383  bool cf = c.failed();
384  if (f != cf)
385  return false;
386  if (f)
387  return true;
388 
389  for (int i=x.size(); i--; )
390  if (x[i].glbSize() != c.x[i].glbSize() ||
391  x[i].lubSize() != c.x[i].lubSize() ||
392  x[i].cardMin() != c.x[i].cardMin() ||
393  x[i].cardMax() != c.x[i].cardMax())
394  return false;
395 
396  for (int i=y.size(); i--; )
397  if (y[i].size() != c.y[i].size())
398  return false;
399 
400  if (reified && (r.var().size() != c.r.var().size()))
401  return false;
402  if (opt.log)
403  olog << ind(3) << "Finished testing whether enabled space is the same"
404  << std::endl;
405  return true;
406  }
407 
408  bool
410  using namespace Gecode;
411  bool setsAssigned = true;
412  for (int j=x.size(); j--; )
413  if (!x[j].assigned()) {
414  setsAssigned = false;
415  break;
416  }
417  bool intsAssigned = true;
418  for (int j=y.size(); j--; )
419  if (!y[j].assigned()) {
420  intsAssigned = false;
421  break;
422  }
423 
424  // Select variable to be pruned
425  int i;
426  if (intsAssigned) {
427  i = Base::rand(x.size());
428  } else if (setsAssigned) {
429  i = Base::rand(y.size());
430  } else {
431  i = Base::rand(x.size()+y.size());
432  }
433 
434  if (setsAssigned || i>=x.size()) {
435  if (i>=x.size())
436  i = i-x.size();
437  while (y[i].assigned()) {
438  i = (i+1) % y.size();
439  }
440  // Prune int var
441 
442  // Select mode for pruning
443  switch (Base::rand(3)) {
444  case 0:
445  if (a.ints()[i] < y[i].max()) {
446  int v=a.ints()[i]+1+
447  Base::rand(static_cast<unsigned int>(y[i].max()-a.ints()[i]));
448  assert((v > a.ints()[i]) && (v <= y[i].max()));
449  rel(i, Gecode::IRT_LE, v);
450  }
451  break;
452  case 1:
453  if (a.ints()[i] > y[i].min()) {
454  int v=y[i].min()+
455  Base::rand(static_cast<unsigned int>(a.ints()[i]-y[i].min()));
456  assert((v < a.ints()[i]) && (v >= y[i].min()));
457  rel(i, Gecode::IRT_GR, v);
458  }
459  break;
460  default:
461  int v;
463  unsigned int skip = Base::rand(y[i].size()-1);
464  while (true) {
465  if (it.width() > skip) {
466  v = it.min() + skip;
467  if (v == a.ints()[i]) {
468  if (it.width() == 1) {
469  ++it; v = it.min();
470  } else if (v < it.max()) {
471  ++v;
472  } else {
473  --v;
474  }
475  }
476  break;
477  }
478  skip -= it.width();
479  ++it;
480  }
481  rel(i, Gecode::IRT_NQ, v);
482  }
483  return (!Base::fixpoint() || fixprob());
484  }
485  while (x[i].assigned()) {
486  i = (i+1) % x.size();
487  }
489  CountableSetRanges air1(a.lub, a[i]);
491  CountableSetRanges> diff(ur1, air1);
493  CountableSetRanges air2(a.lub, a[i]);
495  CountableSetRanges> inter(ur2, air2);
496 
497  CountableSetRanges aisizer(a.lub, a[i]);
498  unsigned int aisize = Gecode::Iter::Ranges::size(aisizer);
499 
500  // Select mode for pruning
501  switch (Base::rand(5)) {
502  case 0:
503  if (inter()) {
505  addToGlb(v, i, a);
506  }
507  break;
508  case 1:
509  if (diff()) {
511  removeFromLub(v, i, a);
512  }
513  break;
514  case 2:
515  if (x[i].cardMin() < aisize) {
516  unsigned int newc = x[i].cardMin() + 1 +
517  Base::rand(aisize - x[i].cardMin());
518  assert( newc > x[i].cardMin() );
519  assert( newc <= aisize );
521  }
522  break;
523  case 3:
524  if (x[i].cardMax() > aisize) {
525  unsigned int newc = x[i].cardMax() - 1 -
526  Base::rand(x[i].cardMax() - aisize);
527  assert( newc < x[i].cardMax() );
528  assert( newc >= aisize );
529  cardinality(i, 0, newc);
530  }
531  break;
532  default:
533  if (inter()) {
535  addToGlb(v, i, a);
536  } else {
538  removeFromLub(v, i, a);
539  }
540  }
541  return (!Base::fixpoint() || fixprob());
542  }
543 
544  bool
546  c.disable();
547  using namespace Gecode;
548  bool setsAssigned = true;
549  for (int j=x.size(); j--; )
550  if (!x[j].assigned()) {
551  setsAssigned = false;
552  break;
553  }
554  bool intsAssigned = true;
555  for (int j=y.size(); j--; )
556  if (!y[j].assigned()) {
557  intsAssigned = false;
558  break;
559  }
560 
561  // Select variable to be pruned
562  int i;
563  if (intsAssigned) {
564  i = Base::rand(x.size());
565  } else if (setsAssigned) {
566  i = Base::rand(y.size());
567  } else {
568  i = Base::rand(x.size()+y.size());
569  }
570 
571  if (setsAssigned || i>=x.size()) {
572  if (i>=x.size())
573  i = i-x.size();
574  while (y[i].assigned()) {
575  i = (i+1) % y.size();
576  }
577  // Prune int var
578 
579  // Select mode for pruning
580  switch (Base::rand(3)) {
581  case 0:
582  if (a.ints()[i] < y[i].max()) {
583  int v=a.ints()[i]+1+
584  Base::rand(static_cast<unsigned int>(y[i].max()-a.ints()[i]));
585  assert((v > a.ints()[i]) && (v <= y[i].max()));
586  rel(i, Gecode::IRT_LE, v);
587  c.rel(i, Gecode::IRT_LE, v);
588  }
589  break;
590  case 1:
591  if (a.ints()[i] > y[i].min()) {
592  int v=y[i].min()+
593  Base::rand(static_cast<unsigned int>(a.ints()[i]-y[i].min()));
594  assert((v < a.ints()[i]) && (v >= y[i].min()));
595  rel(i, Gecode::IRT_GR, v);
596  c.rel(i, Gecode::IRT_GR, v);
597  }
598  break;
599  default:
600  int v;
602  unsigned int skip = Base::rand(y[i].size()-1);
603  while (true) {
604  if (it.width() > skip) {
605  v = it.min() + skip;
606  if (v == a.ints()[i]) {
607  if (it.width() == 1) {
608  ++it; v = it.min();
609  } else if (v < it.max()) {
610  ++v;
611  } else {
612  --v;
613  }
614  }
615  break;
616  }
617  skip -= it.width();
618  ++it;
619  }
620  rel(i, Gecode::IRT_NQ, v);
621  c.rel(i, Gecode::IRT_NQ, v);
622  }
623  c.enable();
624  return same(c);
625  }
626  while (x[i].assigned()) {
627  i = (i+1) % x.size();
628  }
630  CountableSetRanges air1(a.lub, a[i]);
632  CountableSetRanges> diff(ur1, air1);
634  CountableSetRanges air2(a.lub, a[i]);
636  CountableSetRanges> inter(ur2, air2);
637 
638  CountableSetRanges aisizer(a.lub, a[i]);
639  unsigned int aisize = Gecode::Iter::Ranges::size(aisizer);
640 
641  // Select mode for pruning
642  switch (Base::rand(5)) {
643  case 0:
644  if (inter()) {
646  addToGlb(v, i, a, c);
647  }
648  break;
649  case 1:
650  if (diff()) {
652  removeFromLub(v, i, a, c);
653  }
654  break;
655  case 2:
656  if (x[i].cardMin() < aisize) {
657  unsigned int newc = x[i].cardMin() + 1 +
658  Base::rand(aisize - x[i].cardMin());
659  assert( newc > x[i].cardMin() );
660  assert( newc <= aisize );
662  c.cardinality(i, newc, Gecode::Set::Limits::card);
663  }
664  break;
665  case 3:
666  if (x[i].cardMax() > aisize) {
667  unsigned int newc = x[i].cardMax() - 1 -
668  Base::rand(x[i].cardMax() - aisize);
669  assert( newc < x[i].cardMax() );
670  assert( newc >= aisize );
671  cardinality(i, 0, newc);
672  c.cardinality(i, 0, newc);
673  }
674  break;
675  default:
676  if (inter()) {
678  addToGlb(v, i, a, c);
679  } else {
681  removeFromLub(v, i, a, c);
682  }
683  }
684  c.enable();
685  return same(c);
686  }
687 
688  unsigned int
690  return Gecode::PropagatorGroup::all.size(*this);
691  }
692 
693  void
696  }
697 
698  void
701  (void) status();
702  }
703 
704 
706 #define CHECK_TEST(T,M) \
707 if (opt.log) \
708  olog << ind(3) << "Check: " << (M) << std::endl; \
709 if (!(T)) { \
710  problem = (M); delete s; goto failed; \
711 }
712 
714 #define START_TEST(T) \
715  if (opt.log) { \
716  olog.str(""); \
717  olog << ind(2) << "Testing: " << (T) << std::endl; \
718  } \
719  test = (T);
720 
721  bool
722  SetTest::run(void) {
723  using namespace Gecode;
724  const char* test = "NONE";
725  const char* problem = "NONE";
726 
727  SetAssignment* ap = new SetAssignment(arity,lub,withInt);
728  SetAssignment& a = *ap;
729  while (a()) {
730  bool is_sol = solution(a);
731  if (opt.log)
732  olog << ind(1) << "Assignment: " << a
733  << (is_sol ? " (solution)" : " (no solution)")
734  << std::endl;
735  START_TEST("Assignment (after posting)");
736  {
737  SetTestSpace* s = new SetTestSpace(arity,lub,withInt,this);
738  SetTestSpace* sc = NULL;
739  s->post();
740  switch (Base::rand(3)) {
741  case 0:
742  if (opt.log)
743  olog << ind(3) << "No copy" << std::endl;
744  sc = s;
745  s = NULL;
746  break;
747  case 1:
748  if (opt.log)
749  olog << ind(3) << "Unshared copy" << std::endl;
750  if (s->status() != Gecode::SS_FAILED) {
751  sc = static_cast<SetTestSpace*>(s->clone(true));
752  } else {
753  sc = s; s = NULL;
754  }
755  break;
756  case 2:
757  if (opt.log)
758  olog << ind(3) << "Unshared copy" << std::endl;
759  if (s->status() != Gecode::SS_FAILED) {
760  sc = static_cast<SetTestSpace*>(s->clone(false));
761  } else {
762  sc = s; s = NULL;
763  }
764  break;
765  default: assert(false);
766  }
767  sc->assign(a);
768  if (is_sol) {
769  CHECK_TEST(!sc->failed(), "Failed on solution");
770  CHECK_TEST(sc->subsumed(testsubsumed), "No subsumption");
771  } else {
772  CHECK_TEST(sc->failed(), "Solved on non-solution");
773  }
774  delete s; delete sc;
775  }
776  START_TEST("Assignment (after posting, disable)");
777  {
778  SetTestSpace* s = new SetTestSpace(arity,lub,withInt,this);
779  s->post();
780  s->disable();
781  s->assign(a);
782  s->enable();
783  if (is_sol) {
784  CHECK_TEST(!s->failed(), "Failed on solution");
785  CHECK_TEST(s->subsumed(testsubsumed), "No subsumption");
786  } else {
787  CHECK_TEST(s->failed(), "Solved on non-solution");
788  }
789  delete s;
790  }
791  START_TEST("Assignment (before posting)");
792  {
793  SetTestSpace* s = new SetTestSpace(arity,lub,withInt,this);
794  s->assign(a);
795  s->post();
796  if (is_sol) {
797  CHECK_TEST(!s->failed(), "Failed on solution");
798  CHECK_TEST(s->subsumed(testsubsumed), "No subsumption");
799  } else {
800  CHECK_TEST(s->failed(), "Solved on non-solution");
801  }
802  delete s;
803  }
804  START_TEST("Prune");
805  {
806  SetTestSpace* s = new SetTestSpace(arity,lub,withInt,this);
807  s->post();
808  while (!s->failed() && !s->assigned())
809  if (!s->prune(a)) {
810  problem = "No fixpoint";
811  delete s;
812  goto failed;
813  }
814  s->assign(a);
815  if (is_sol) {
816  CHECK_TEST(!s->failed(), "Failed on solution");
817  CHECK_TEST(s->subsumed(testsubsumed), "No subsumption");
818  } else {
819  CHECK_TEST(s->failed(), "Solved on non-solution");
820  }
821  delete s;
822  }
823  if (disabled) {
824  START_TEST("Prune (disable)");
825  {
826  SetTestSpace* s = new SetTestSpace(arity,lub,withInt,this);
827  SetTestSpace* c = new SetTestSpace(arity,lub,withInt,this);
828  s->post(); c->post();
829  while (!s->failed() && !s->assigned())
830  if (!s->disabled(a,*c)) {
831  problem = "Different result after re-enable";
832  delete s; delete c;
833  goto failed;
834  }
835  s->assign(a); c->assign(a);
836  if (s->failed() != c->failed()) {
837  problem = "Different failure after re-enable";
838  delete s; delete c;
839  goto failed;
840  }
841  delete s; delete c;
842  }
843  }
844  if (reified) {
845  START_TEST("Assignment reified (rewrite after post, <=>)");
846  {
847  SetTestSpace* s = new SetTestSpace(arity,lub,withInt,this,RM_EQV);
848  s->post();
849  s->rel(is_sol);
850  s->assign(a);
851  CHECK_TEST(!s->failed(), "Failed");
852  CHECK_TEST(s->subsumed(testsubsumed), "No subsumption");
853  delete s;
854  }
855  START_TEST("Assignment reified (rewrite after post, =>)");
856  {
857  SetTestSpace* s = new SetTestSpace(arity,lub,withInt,this,RM_IMP);
858  s->post();
859  s->rel(is_sol);
860  s->assign(a);
861  CHECK_TEST(!s->failed(), "Failed");
862  CHECK_TEST(s->subsumed(testsubsumed), "No subsumption");
863  delete s;
864  }
865  START_TEST("Assignment reified (rewrite after post, <=)");
866  {
867  SetTestSpace* s = new SetTestSpace(arity,lub,withInt,this,RM_PMI);
868  s->post();
869  s->rel(is_sol);
870  s->assign(a);
871  CHECK_TEST(!s->failed(), "Failed");
872  CHECK_TEST(s->subsumed(testsubsumed), "No subsumption");
873  delete s;
874  }
875  {
876  START_TEST("Assignment reified (rewrite failure, <=>)");
877  SetTestSpace* s = new SetTestSpace(arity,lub,withInt,this,RM_EQV);
878  s->post();
879  s->rel(!is_sol);
880  s->assign(a);
881  CHECK_TEST(s->failed(), "Not failed");
882  delete s;
883  }
884  {
885  START_TEST("Assignment reified (rewrite failure, =>)");
886  SetTestSpace* s = new SetTestSpace(arity,lub,withInt,this,RM_IMP);
887  s->post();
888  s->rel(!is_sol);
889  s->assign(a);
890  if (is_sol) {
891  CHECK_TEST(!s->failed(), "Failed");
892  CHECK_TEST(s->subsumed(testsubsumed), "No subsumption");
893  } else {
894  CHECK_TEST(s->failed(), "Not failed");
895  }
896  delete s;
897  }
898  {
899  START_TEST("Assignment reified (rewrite failure, <=)");
900  SetTestSpace* s = new SetTestSpace(arity,lub,withInt,this,RM_PMI);
901  s->post();
902  s->rel(!is_sol);
903  s->assign(a);
904  if (is_sol) {
905  CHECK_TEST(s->failed(), "Not failed");
906  } else {
907  CHECK_TEST(!s->failed(), "Failed");
908  CHECK_TEST(s->subsumed(testsubsumed), "No subsumption");
909  }
910  delete s;
911  }
912  START_TEST("Assignment reified (immediate rewrite, <=>)");
913  {
914  SetTestSpace* s = new SetTestSpace(arity,lub,withInt,this,RM_EQV);
915  s->rel(is_sol);
916  s->post();
917  s->assign(a);
918  CHECK_TEST(!s->failed(), "Failed");
919  CHECK_TEST(s->subsumed(testsubsumed), "No subsumption");
920  delete s;
921  }
922  START_TEST("Assignment reified (immediate rewrite, =>)");
923  {
924  SetTestSpace* s = new SetTestSpace(arity,lub,withInt,this,RM_IMP);
925  s->rel(is_sol);
926  s->post();
927  s->assign(a);
928  CHECK_TEST(!s->failed(), "Failed");
929  CHECK_TEST(s->subsumed(testsubsumed), "No subsumption");
930  delete s;
931  }
932  START_TEST("Assignment reified (immediate rewrite, <=)");
933  {
934  SetTestSpace* s = new SetTestSpace(arity,lub,withInt,this,RM_PMI);
935  s->rel(is_sol);
936  s->post();
937  s->assign(a);
938  CHECK_TEST(!s->failed(), "Failed");
939  CHECK_TEST(s->subsumed(testsubsumed), "No subsumption");
940  delete s;
941  }
942  START_TEST("Assignment reified (immediate failure, <=>)");
943  {
944  SetTestSpace* s = new SetTestSpace(arity,lub,withInt,this,RM_EQV);
945  s->rel(!is_sol);
946  s->post();
947  s->assign(a);
948  CHECK_TEST(s->failed(), "Not failed");
949  delete s;
950  }
951  START_TEST("Assignment reified (immediate failure, =>)");
952  {
953  SetTestSpace* s = new SetTestSpace(arity,lub,withInt,this,RM_IMP);
954  s->rel(!is_sol);
955  s->post();
956  s->assign(a);
957  if (is_sol) {
958  CHECK_TEST(!s->failed(), "Failed");
959  CHECK_TEST(s->subsumed(testsubsumed), "No subsumption");
960  } else {
961  CHECK_TEST(s->failed(), "Not failed");
962  }
963  delete s;
964  }
965  START_TEST("Assignment reified (immediate failure, <=)");
966  {
967  SetTestSpace* s = new SetTestSpace(arity,lub,withInt,this,RM_PMI);
968  s->rel(!is_sol);
969  s->post();
970  s->assign(a);
971  if (is_sol) {
972  CHECK_TEST(s->failed(), "Not failed");
973  } else {
974  CHECK_TEST(!s->failed(), "Failed");
975  CHECK_TEST(s->subsumed(testsubsumed), "No subsumption");
976  }
977  delete s;
978  }
979  START_TEST("Assignment reified (before posting, <=>)");
980  {
981  SetTestSpace* s = new SetTestSpace(arity,lub,withInt,this,RM_EQV);
982  s->assign(a);
983  s->post();
984  CHECK_TEST(!s->failed(), "Failed");
985  CHECK_TEST(s->subsumed(testsubsumed), "No subsumption");
986  CHECK_TEST(s->r.var().assigned(), "Control variable unassigned");
987  if (is_sol) {
988  CHECK_TEST(s->r.var().val()==1, "Zero on solution");
989  } else {
990  CHECK_TEST(s->r.var().val()==0, "One on non-solution");
991  }
992  delete s;
993  }
994  START_TEST("Assignment reified (before posting, =>)");
995  {
996  SetTestSpace* s = new SetTestSpace(arity,lub,withInt,this,RM_IMP);
997  s->assign(a);
998  s->post();
999  CHECK_TEST(!s->failed(), "Failed");
1000  CHECK_TEST(s->subsumed(testsubsumed), "No subsumption");
1001  if (is_sol) {
1002  CHECK_TEST(!s->r.var().assigned(), "Control variable assigned");
1003  } else {
1004  CHECK_TEST(s->r.var().assigned(), "Control variable unassigned");
1005  CHECK_TEST(s->r.var().val()==0, "One on non-solution");
1006  }
1007  delete s;
1008  }
1009  START_TEST("Assignment reified (before posting, <=)");
1010  {
1011  SetTestSpace* s = new SetTestSpace(arity,lub,withInt,this,RM_PMI);
1012  s->assign(a);
1013  s->post();
1014  CHECK_TEST(!s->failed(), "Failed");
1015  CHECK_TEST(s->subsumed(testsubsumed), "No subsumption");
1016  if (is_sol) {
1017  CHECK_TEST(s->r.var().assigned(), "Control variable unassigned");
1018  CHECK_TEST(s->r.var().val()==1, "Zero on solution");
1019  } else {
1020  CHECK_TEST(!s->r.var().assigned(), "Control variable assigned");
1021  }
1022  delete s;
1023  }
1024  START_TEST("Assignment reified (after posting, <=>)");
1025  {
1026  SetTestSpace* s = new SetTestSpace(arity,lub,withInt,this,RM_EQV);
1027  s->post();
1028  s->assign(a);
1029  CHECK_TEST(!s->failed(), "Failed");
1030  CHECK_TEST(s->subsumed(testsubsumed), "No subsumption");
1031  CHECK_TEST(s->r.var().assigned(), "Control variable unassigned");
1032  if (is_sol) {
1033  CHECK_TEST(s->r.var().val()==1, "Zero on solution");
1034  } else {
1035  CHECK_TEST(s->r.var().val()==0, "One on non-solution");
1036  }
1037  delete s;
1038  }
1039  START_TEST("Assignment reified (after posting, =>)");
1040  {
1041  SetTestSpace* s = new SetTestSpace(arity,lub,withInt,this,RM_IMP);
1042  s->post();
1043  s->assign(a);
1044  CHECK_TEST(!s->failed(), "Failed");
1045  CHECK_TEST(s->subsumed(testsubsumed), "No subsumption");
1046  if (is_sol) {
1047  CHECK_TEST(!s->r.var().assigned(), "Control variable assigned");
1048  } else {
1049  CHECK_TEST(s->r.var().assigned(), "Control variable unassigned");
1050  CHECK_TEST(s->r.var().val()==0, "One on non-solution");
1051  }
1052  delete s;
1053  }
1054  START_TEST("Assignment reified (after posting, <=)");
1055  {
1056  SetTestSpace* s = new SetTestSpace(arity,lub,withInt,this,RM_PMI);
1057  s->post();
1058  s->assign(a);
1059  CHECK_TEST(!s->failed(), "Failed");
1060  CHECK_TEST(s->subsumed(testsubsumed), "No subsumption");
1061  if (is_sol) {
1062  CHECK_TEST(s->r.var().assigned(), "Control variable unassigned");
1063  CHECK_TEST(s->r.var().val()==1, "Zero on solution");
1064  } else {
1065  CHECK_TEST(!s->r.var().assigned(), "Control variable assigned");
1066  }
1067  delete s;
1068  }
1069  START_TEST("Assignment reified (after posting, <=>, disable)");
1070  {
1071  SetTestSpace* s = new SetTestSpace(arity,lub,withInt,this,RM_EQV);
1072  s->post();
1073  s->disable();
1074  s->assign(a);
1075  s->enable();
1076  CHECK_TEST(!s->failed(), "Failed");
1077  CHECK_TEST(s->subsumed(testsubsumed), "No subsumption");
1078  CHECK_TEST(s->r.var().assigned(), "Control variable unassigned");
1079  if (is_sol) {
1080  CHECK_TEST(s->r.var().val()==1, "Zero on solution");
1081  } else {
1082  CHECK_TEST(s->r.var().val()==0, "One on non-solution");
1083  }
1084  delete s;
1085  }
1086  START_TEST("Assignment reified (after posting, =>, disable)");
1087  {
1088  SetTestSpace* s = new SetTestSpace(arity,lub,withInt,this,RM_IMP);
1089  s->post();
1090  s->disable();
1091  s->assign(a);
1092  s->enable();
1093  CHECK_TEST(!s->failed(), "Failed");
1094  CHECK_TEST(s->subsumed(testsubsumed), "No subsumption");
1095  if (is_sol) {
1096  CHECK_TEST(!s->r.var().assigned(), "Control variable assigned");
1097  } else {
1098  CHECK_TEST(s->r.var().assigned(), "Control variable unassigned");
1099  CHECK_TEST(s->r.var().val()==0, "One on non-solution");
1100  }
1101  delete s;
1102  }
1103  START_TEST("Assignment reified (after posting, <=, disable)");
1104  {
1105  SetTestSpace* s = new SetTestSpace(arity,lub,withInt,this,RM_PMI);
1106  s->post();
1107  s->disable();
1108  s->assign(a);
1109  s->enable();
1110  CHECK_TEST(!s->failed(), "Failed");
1111  CHECK_TEST(s->subsumed(testsubsumed), "No subsumption");
1112  if (is_sol) {
1113  CHECK_TEST(s->r.var().assigned(), "Control variable unassigned");
1114  CHECK_TEST(s->r.var().val()==1, "Zero on solution");
1115  } else {
1116  CHECK_TEST(!s->r.var().assigned(), "Control variable assigned");
1117  }
1118  delete s;
1119  }
1120  START_TEST("Prune reified, <=>");
1121  {
1122  SetTestSpace* s = new SetTestSpace(arity,lub,withInt,this,RM_EQV);
1123  s->post();
1124  while (!s->failed() &&
1125  (!s->assigned() || !s->r.var().assigned()))
1126  if (!s->prune(a)) {
1127  problem = "No fixpoint";
1128  delete s;
1129  goto failed;
1130  }
1131  CHECK_TEST(!s->failed(), "Failed");
1132  CHECK_TEST(s->subsumed(testsubsumed), "No subsumption");
1133  CHECK_TEST(s->r.var().assigned(), "Control variable unassigned");
1134  if (is_sol) {
1135  CHECK_TEST(s->r.var().val()==1, "Zero on solution");
1136  } else {
1137  CHECK_TEST(s->r.var().val()==0, "One on non-solution");
1138  }
1139  delete s;
1140  }
1141  START_TEST("Prune reified, =>");
1142  {
1143  SetTestSpace* s = new SetTestSpace(arity,lub,withInt,this,RM_IMP);
1144  s->post();
1145  while (!s->failed() &&
1146  (!s->assigned() || (!is_sol && !s->r.var().assigned()))) {
1147  if (!s->prune(a)) {
1148  problem = "No fixpoint";
1149  delete s;
1150  goto failed;
1151  }
1152  }
1153  CHECK_TEST(!s->failed(), "Failed");
1154  CHECK_TEST(s->subsumed(testsubsumed), "No subsumption");
1155  if (is_sol) {
1156  CHECK_TEST(!s->r.var().assigned(), "Control variable assigned");
1157  } else {
1158  CHECK_TEST(s->r.var().assigned(), "Control variable unassigned");
1159  CHECK_TEST(s->r.var().val()==0, "One on non-solution");
1160  }
1161  delete s;
1162  }
1163  START_TEST("Prune reified, <=");
1164  {
1165  SetTestSpace* s = new SetTestSpace(arity,lub,withInt,this,RM_PMI);
1166  s->post();
1167  while (!s->failed() &&
1168  (!s->assigned() || (is_sol && !s->r.var().assigned())))
1169  if (!s->prune(a)) {
1170  problem = "No fixpoint";
1171  delete s;
1172  goto failed;
1173  }
1174  CHECK_TEST(!s->failed(), "Failed");
1175  CHECK_TEST(s->subsumed(testsubsumed), "No subsumption");
1176  if (is_sol) {
1177  CHECK_TEST(s->r.var().assigned(), "Control variable unassigned");
1178  CHECK_TEST(s->r.var().val()==1, "Zero on solution");
1179  } else {
1180  CHECK_TEST(!s->r.var().assigned(), "Control variable assigned");
1181  }
1182  delete s;
1183  }
1184  }
1185  ++a;
1186  }
1187  delete ap;
1188  return true;
1189  failed:
1190  if (opt.log)
1191  olog << "FAILURE" << std::endl
1192  << ind(1) << "Test: " << test << std::endl
1193  << ind(1) << "Problem: " << problem << std::endl;
1194  if (a() && opt.log)
1195  olog << ind(1) << "Assignment: " << a << std::endl;
1196  delete ap;
1197 
1198  return false;
1199  }
1200 
1201  const Gecode::SetRelType SetRelTypes::srts[] =
1204 
1205  const Gecode::SetOpType SetOpTypes::sots[] =
1208 
1209 }}
1210 
1211 #undef START_TEST
1212 #undef CHECK_TEST
1213 
1214 // STATISTICS: test-set
void pow(Home home, FloatVar x0, int n, FloatVar x1)
Post propagator for for $n\geq 0$.
Definition: arithmetic.cpp:113
unsigned int width(void) const
Return width of range (distance between minimum and maximum)
IntRelType
Relation types for integers.
Definition: int.hh:906
Region r
Definition: region.cpp:82
Post propagator for SetVar SetOpType SetVar y
Definition: set.hh:784
Gecode::SetVarArray x
Set variables to be tested.
Definition: set.hh:203
Space for executing set tests.
Definition: set.hh:198
void enable(void)
Enable propagators in space.
Definition: set.cpp:694
@ RM_PMI
Inverse implication for reification.
Definition: int.hh:850
void post(void)
Post propagator.
Definition: set.cpp:174
@ IRT_GQ
Greater or equal ( )
Definition: int.hh:911
Space * clone(bool share_data=true, bool share_info=true, CloneStatistics &stat=unused_clone) const
Clone space.
Definition: core.hpp:3326
bool failed(void)
Compute a fixpoint and check for failure.
Definition: set.cpp:187
int min(void) const
Return smallest value of range.
virtual void post(Gecode::Space &home, Gecode::SetVarArray &x, Gecode::IntVarArray &y)=0
Post propagator.
void log(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
unsigned int size(I &i)
Size of all ranges of range iterator i.
static const IntSet empty
Empty set.
Definition: int.hh:265
@ IRT_LE
Less ( )
Definition: int.hh:910
bool disabled(const SetAssignment &a, SetTestSpace &c)
Prune values also in a space c with disabled propagators, but not those in assignment a.
Definition: set.cpp:545
Gecode::IntSet lub
The common superset for all domains.
Definition: set.hh:170
const int min
Smallest allowed integer in integer set.
Definition: set.hh:103
unsigned int size(Space &home) const
Return number of propagators in a group.
Definition: core.cpp:917
void removeFromLub(int v, int i, const SetAssignment &a)
Remove value v from the upper bound of x[i].
Definition: set.cpp:289
Gecode::Reify r
Reification information.
Definition: set.hh:209
void update(Space &, bool share, VarArray< Var > &a)
Update array to be a clone of array a.
Definition: array.hpp:1072
@ RM_IMP
Implication for reification.
Definition: int.hh:843
Gecode::IntArgs i(4, 1, 2, 3, 4)
Passing set variables.
Definition: set.hh:492
NodeType t
Type of node.
Definition: bool-expr.cpp:234
Gecode::IntVarArray y
Int variables to be tested.
Definition: set.hh:205
void disable(Space &home)
Disable all propagators in a group.
Definition: core.cpp:941
Computation spaces.
Definition: core.hpp:1748
@ SRT_LQ
Less or equal ( )
Definition: set.hh:652
SetOpType
Common operations for sets.
Definition: set.hh:662
#define START_TEST(T)
Start new test.
Definition: set.cpp:714
@ SRT_GQ
Greater or equal ( )
Definition: set.hh:654
@ SRT_SUB
Subset ( )
Definition: set.hh:648
bool assigned(void) const
Test whether view is assigned.
Definition: var.hpp:123
void init(const Gecode::IntSet &s)
Initialize with set s.
Definition: set.cpp:59
void operator++(void)
Move to next subset.
Definition: set.cpp:55
static Gecode::Support::RandomGenerator rand
Random number generator.
Definition: test.hh:138
@ SRT_SUP
Superset ( )
Definition: set.hh:649
union Gecode::@579::NNF::@61 u
Union depending on nodetype t.
Range iterator for integer sets.
Definition: int.hh:274
void disable(void)
Disable propagators in space and compute fixpoint (make all idle)
Definition: set.cpp:699
int size(void) const
Return size of array (number of elements)
Definition: array.hpp:985
Generate all set assignments.
Definition: set.hh:158
@ SOT_INTER
Intersection
Definition: set.hh:665
@ SRT_DISJ
Disjoint ( )
Definition: set.hh:650
Gecode toplevel namespace
void enable(Space &home, bool s=true)
Enable all propagators in a group.
Definition: core.cpp:950
bool subsumed(bool b)
Check for subsumption if b is true.
Definition: set.cpp:201
int withInt
How many integer variables to iterate.
Definition: set.hh:172
Integer sets.
Definition: int.hh:174
const int max
Largest allowed integer in integer set.
Definition: set.hh:101
const unsigned int card
Maximum cardinality of an integer set.
Definition: set.hh:105
std::basic_ostream< Char, Traits > & operator<<(std::basic_ostream< Char, Traits > &os, const FloatView &x)
Print float variable view.
Definition: print.hpp:62
Options opt
The options.
Definition: test.cpp:101
static PropagatorGroup all
Group of all propagators.
Definition: core.hpp:855
@ SRT_EQ
Equality ( )
Definition: set.hh:646
@ RM_EQV
Equivalence for reification (default)
Definition: int.hh:836
void operator++(void)
Move to next assignment.
Definition: set.cpp:80
struct Gecode::@579::NNF::@61::@63 a
For atomic nodes.
void rel(int i, Gecode::SetRelType srt, const Gecode::IntSet &is)
Perform set tell operation on x[i].
Definition: set.cpp:206
struct Gecode::@579::NNF::@61::@62 b
For binary nodes (and, or, eqv)
bool prune(const SetAssignment &a)
Perform random pruning.
Definition: set.cpp:409
Value iterator from range iterator.
bool log
Whether to log the tests.
Definition: test.hh:95
Range iterator for computing intersection (binary)
virtual Gecode::Space * copy(bool share)
Copy space during cloning.
Definition: set.cpp:169
int val(void) const
Return current subset.
Definition: set.cpp:68
void dom(Home home, FloatVar x, FloatVal n)
Propagates .
Definition: dom.cpp:44
@ SOT_UNION
Union.
Definition: set.hh:663
Range iterator for computing set difference.
Definition: ranges-diff.hpp:47
Boolean integer variables.
Definition: int.hh:494
Gecode::IntSet d
Initial domain.
Definition: set.hh:201
Base class for tests with set constraints
Definition: set.hh:289
LinIntExpr cardinality(const SetExpr &e)
Cardinality of set expression.
Definition: set-expr.cpp:818
#define CHECK_TEST(T, M)
Check the test result and handle failed test.
Definition: set.cpp:706
SetRelType
Common relation types for sets.
Definition: set.hh:645
unsigned int propagators(void)
Return the number of propagators.
Definition: set.cpp:689
@ SRT_LE
Less ( )
Definition: set.hh:653
SetTest * test
The test currently run.
Definition: set.hh:213
static bool fixpoint(void)
Throw a coin whether to compute a fixpoint.
Definition: test.hpp:70
bool fixprob(void)
Perform fixpoint computation.
Definition: set.cpp:345
@ SRT_GR
Greater ( )
Definition: set.hh:655
@ SRT_NQ
Disequality ( )
Definition: set.hh:647
SpaceStatus status(StatusStatistics &stat=unused_status)
Query space status.
Definition: core.cpp:224
ChannelShared csv(Gecode::IPL_VAL)
@ SRT_CMPL
Complement.
Definition: set.hh:651
@ SOT_DUNION
Disjoint union.
Definition: set.hh:664
bool same(SetTestSpace &c)
Check whether propagation is the same as in c.
Definition: set.cpp:378
void cardinality(int i, int cmin, int cmax)
Perform cardinality tell operation on x[i].
Definition: set.cpp:227
BoolVar var(void) const
Return Boolean control variable.
Definition: reify.hpp:52
const int v[7]
Definition: distinct.cpp:263
void rel(Home home, FloatVar x0, FloatRelType frt, FloatVal n)
Propagates .
Definition: rel.cpp:47
int withInt
How many integer variables are used by the test.
Definition: set.hh:207
SetTestSpace(int n, Gecode::IntSet &d0, int i, SetTest *t, bool log=true)
Create test space without reification.
Definition: set.cpp:124
Gecode::IntSet d(v, 7)
ReifyMode
Mode for reification.
Definition: int.hh:829
void addToGlb(int v, int i, const SetAssignment &a)
Remove value v from the lower bound of x[i].
Definition: set.cpp:317
Iterate all subsets of a given set.
Definition: set.hh:134
Simple class for describing identation.
Definition: test.hh:70
struct Gecode::Space::@56::@58 c
Data available only during copying.
int max(void) const
Return largest value of range.
ReifyMode mode(void) const
Return reification mode.
Definition: reify.hpp:60
General test support.
Definition: afc.cpp:43
Range iterator producing subsets of an IntSet.
Definition: set.hh:114
void assign(const SetAssignment &a)
Assign all variables to values in a.
Definition: set.cpp:262
@ IRT_EQ
Equality ( )
Definition: int.hh:907
Iterator for the unknown ranges of a set variable.
Definition: set.hh:338
int val(void) const
Return assigned value.
Definition: bool.hpp:61
@ IRT_NQ
Disequality ( )
Definition: int.hh:908
Post propagator for f(x \diamond_{\mathit{op}} y) \sim_r z \f$ void rel(Home home
Set variable array
Definition: set.hh:572
@ SOT_MINUS
Difference.
Definition: set.hh:666
CountableSet(void)
Default constructor.
Definition: set.hh:146
int n
Number of negative literals for node type.
Definition: bool-expr.cpp:238
@ IRT_GR
Greater ( )
Definition: int.hh:912
std::ostringstream olog
Stream used for logging.
Definition: test.cpp:57
SetExpr inter(const SetVarArgs &x)
Intersection of set variables.
Definition: set-expr.cpp:699
@ SS_FAILED
Space is failed
Definition: core.hpp:1689
SetAssignment(int n, const Gecode::IntSet &d, int i=0)
Initialize with n set variables, initial bound d and i int variables.
Definition: set.cpp:72
const FloatNum max
Largest allowed float value.
Definition: float.hh:848
bool assigned(void) const
Test whether all variables are assigned.
Definition: set.cpp:278
virtual bool run(void)
Perform test.
Definition: set.cpp:722
bool reified
Whether the test is for a reified propagator.
Definition: set.hh:211
@ IRT_LQ
Less or equal ( )
Definition: int.hh:909
unsigned int size(void) const
Return size (cardinality) of domain.
Definition: bool.hpp:85