Generated on Sat Jan 12 2019 20:58:51 for Gecode by doxygen 1.8.13
extensional.cpp
Go to the documentation of this file.
1 /* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
2 /*
3  * Main authors:
4  * Mikael Lagerkvist <lagerkvist@gecode.org>
5  * Linnea Ingmar <linnea.ingmar@hotmail.com>
6  * Christian Schulte <schulte@gecode.org>
7  *
8  * Copyright:
9  * Linnea Ingmar, 2017
10  * Mikael Lagerkvist, 2007
11  * Christian Schulte, 2005
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 "test/int.hh"
39 
40 #include <gecode/minimodel.hh>
41 #include <climits>
42 
43 namespace Test { namespace Int {
44 
46  namespace Extensional {
47 
53  class RegSimpleA : public Test {
55  public:
57  RegSimpleA(void) : Test("Extensional::Reg::Simple::A",4,2,2) {}
59  virtual bool solution(const Assignment& x) const {
60  return (((x[0] == 0) || (x[0] == 2)) &&
61  ((x[1] == -1) || (x[1] == 1)) &&
62  ((x[2] == 0) || (x[2] == 1)) &&
63  ((x[3] == 0) || (x[3] == 1)));
64  }
66  virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
67  using namespace Gecode;
68  extensional(home, x,
69  (REG(0) | REG(2)) +
70  (REG(-1) | REG(1)) +
71  (REG(7) | REG(0) | REG(1)) +
72  (REG(0) | REG(1)));
73  }
74  };
75 
77  class RegSimpleB : public Test {
78  public:
80  RegSimpleB(void) : Test("Extensional::Reg::Simple::B",4,2,2) {}
82  virtual bool solution(const Assignment& x) const {
83  return (x[0]<x[1]) && (x[1]<x[2]) && (x[2]<x[3]);
84  }
86  virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
87  using namespace Gecode;
88  extensional(home, x,
89  (REG(-2) + REG(-1) + REG(0) + REG(1)) |
90  (REG(-2) + REG(-1) + REG(0) + REG(2)) |
91  (REG(-2) + REG(-1) + REG(1) + REG(2)) |
92  (REG(-2) + REG(0) + REG(1) + REG(2)) |
93  (REG(-1) + REG(0) + REG(1) + REG(2)));
94  }
95  };
96 
98  class RegSimpleC : public Test {
99  public:
101  RegSimpleC(void) : Test("Extensional::Reg::Simple::C",6,0,1) {}
103  virtual bool solution(const Assignment& x) const {
104  int pos = 0;
105  int s = x.size();
106 
107  while (pos < s && x[pos] == 0) ++pos;
108  if (pos + 4 > s) return false;
109 
110  for (int i = 0; i < 2; ++i, ++pos)
111  if (x[pos] != 1) return false;
112  if (pos + 2 > s) return false;
113 
114  for (int i = 0; i < 1; ++i, ++pos)
115  if (x[pos] != 0) return false;
116  while (pos < s && x[pos] == 0) ++pos;
117  if (pos + 1 > s) return false;
118 
119  for (int i = 0; i < 1; ++i, ++pos)
120  if (x[pos] != 1) return false;
121  while (pos < s) if (x[pos++] != 0) return false;
122  return true;
123 
124  }
126  virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
127  using namespace Gecode;
128  extensional(home, x,
129  *REG(0) + REG(1)(2,2) + +REG(0) + REG(1)(1,1) + *REG(0));
130  }
131  };
132 
134  class RegDistinct : public Test {
135  public:
137  RegDistinct(void) : Test("Extensional::Reg::Distinct",4,-1,4) {}
139  virtual bool solution(const Assignment& x) const {
140  for (int i=0; i<x.size(); i++) {
141  if ((x[i] < 0) || (x[i] > 3))
142  return false;
143  for (int j=i+1; j<x.size(); j++)
144  if (x[i]==x[j])
145  return false;
146  }
147  return true;
148  }
150  virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
151  using namespace Gecode;
152  extensional(home, x,
153  (REG(0)+REG(1)+REG(2)+REG(3)) |
154  (REG(0)+REG(1)+REG(3)+REG(2)) |
155  (REG(0)+REG(2)+REG(1)+REG(3)) |
156  (REG(0)+REG(2)+REG(3)+REG(1)) |
157  (REG(0)+REG(3)+REG(1)+REG(2)) |
158  (REG(0)+REG(3)+REG(2)+REG(1)) |
159  (REG(1)+REG(0)+REG(2)+REG(3)) |
160  (REG(1)+REG(0)+REG(3)+REG(2)) |
161  (REG(1)+REG(2)+REG(0)+REG(3)) |
162  (REG(1)+REG(2)+REG(3)+REG(0)) |
163  (REG(1)+REG(3)+REG(0)+REG(2)) |
164  (REG(1)+REG(3)+REG(2)+REG(0)) |
165  (REG(2)+REG(0)+REG(1)+REG(3)) |
166  (REG(2)+REG(0)+REG(3)+REG(1)) |
167  (REG(2)+REG(1)+REG(0)+REG(3)) |
168  (REG(2)+REG(1)+REG(3)+REG(0)) |
169  (REG(2)+REG(3)+REG(0)+REG(1)) |
170  (REG(2)+REG(3)+REG(1)+REG(0)) |
171  (REG(3)+REG(0)+REG(1)+REG(2)) |
172  (REG(3)+REG(0)+REG(2)+REG(1)) |
173  (REG(3)+REG(1)+REG(0)+REG(2)) |
174  (REG(3)+REG(1)+REG(2)+REG(0)) |
175  (REG(3)+REG(2)+REG(0)+REG(1)) |
176  (REG(3)+REG(2)+REG(1)+REG(0)));
177  }
178  };
179 
181  class RegRoland : public Test {
182  public:
185  : Test("Extensional::Reg::Roland::"+str(n),n,0,1) {}
187  virtual bool solution(const Assignment& x) const {
188  int n = x.size();
189  return
190  ((n > 1) && (x[n-2] == 0)) ||
191  ((n > 0) && (x[n-1] == 0));
192  }
194  virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
195  using namespace Gecode;
196  REG r0(0), r1(1);
197  REG r01 = r0 | r1;
198  extensional(home, x, *r01 + r0 + r01(0,1));
199  }
200  };
201 
203  class RegSharedA : public Test {
204  public:
206  RegSharedA(void) : Test("Extensional::Reg::Shared::A",4,2,2) {}
208  virtual bool solution(const Assignment& x) const {
209  return (((x[0] == 0) || (x[0] == 2)) &&
210  ((x[1] == -1) || (x[1] == 1)) &&
211  ((x[2] == 0) || (x[2] == 1)) &&
212  ((x[3] == 0) || (x[3] == 1)));
213  }
215  virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
216  using namespace Gecode;
217  IntVarArgs y(8);
218  for (int i=0; i<4; i++)
219  y[i]=y[i+4]=x[i];
220  unshare(home,y);
221  extensional(home, y,
222  ((REG(0) | REG(2)) +
223  (REG(-1) | REG(1)) +
224  (REG(7) | REG(0) | REG(1)) +
225  (REG(0) | REG(1)))(2,2));
226  }
227  };
228 
230  class RegSharedB : public Test {
231  public:
233  RegSharedB(void) : Test("Extensional::Reg::Shared::B",4,2,2) {}
235  virtual bool solution(const Assignment& x) const {
236  return (((x[0] == 0) || (x[0] == 2)) &&
237  ((x[1] == -1) || (x[1] == 1)) &&
238  ((x[2] == 0) || (x[2] == 1)) &&
239  ((x[3] == 0) || (x[3] == 1)));
240  }
242  virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
243  using namespace Gecode;
244  IntVarArgs y(12);
245  for (int i=0; i<4; i++)
246  y[i]=y[i+4]=y[i+8]=x[i];
247  unshare(home,y);
248  extensional(home, y,
249  ((REG(0) | REG(2)) +
250  (REG(-1) | REG(1)) +
251  (REG(7) | REG(0) | REG(1)) +
252  (REG(0) | REG(1)))(3,3));
253  }
254  };
255 
257  class RegSharedC : public Test {
258  public:
260  RegSharedC(void) : Test("Extensional::Reg::Shared::C",4,0,1) {}
262  virtual bool solution(const Assignment& x) const {
263  return (x[1]==1) && (x[2]==0) && (x[3]==1);
264  }
266  virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
267  using namespace Gecode;
269  for (int i=0; i<4; i++)
270  y[i]=y[i+4]=channel(home,x[i]);
271  unshare(home,y);
272  extensional(home,y,
273  ((REG(0) | REG(1)) + REG(1) + REG(0) + REG(1))(2,2));
274  }
275  };
276 
278  class RegSharedD : public Test {
279  public:
281  RegSharedD(void) : Test("Extensional::Reg::Shared::D",4,0,1) {}
283  virtual bool solution(const Assignment& x) const {
284  return (x[1]==1) && (x[2]==0) && (x[3]==1);
285  }
287  virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
288  using namespace Gecode;
290  for (int i=0; i<4; i++)
291  y[i]=y[i+4]=y[i+8]=channel(home,x[i]);
292  unshare(home, y);
293  extensional(home, y,
294  ((REG(0) | REG(1)) + REG(1) + REG(0) + REG(1))(3,3));
295  }
296  };
297 
299  class RegEmptyDFA : public Test {
300  public:
302  RegEmptyDFA(void) : Test("Extensional::Reg::Empty::DFA",1,0,0) {
303  testsearch = false;
304  }
306  virtual bool solution(const Assignment& x) const {
307  (void)x;
308  return false;
309  }
311  virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
312  Gecode::DFA d;
313  Gecode::extensional(home, x, d);
314  }
315  };
316 
318  class RegEmptyREG : public Test {
319  public:
321  RegEmptyREG(void) : Test("Extensional::Reg::Empty::REG",1,0,0) {
322  testsearch = false;
323  }
325  virtual bool solution(const Assignment& x) const {
326  (void)x;
327  return false;
328  }
330  virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
331  Gecode::REG r;
332  Gecode::extensional(home, x, r);
333  }
334  };
335 
337  class RegOpt : public Test {
338  protected:
340  int n;
341  public:
343  RegOpt(int n0)
344  : Test("Extensional::Reg::Opt::"+str(n0),1,0,15), n(n0) {}
346  virtual bool solution(const Assignment& x) const {
347  return (x[0] < n) && ((x[0] & 1) == 0);
348  }
350  virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
351  using namespace Gecode;
352  DFA::Transition* t = new DFA::Transition[n+1];
353  DFA::Transition* ti = t;
354  int* f = new int[n+1];
355  int* fi = f;
356  for (int i=0; i<n; i++) {
357  ti->i_state = 0;
358  ti->symbol = i;
359  ti->o_state = i+1;
360  ti++;
361  if ((i & 1) == 0) {
362  *fi = i+1; fi++;
363  }
364  }
365  ti->i_state = -1;
366  *fi = -1;
367  DFA d(0, t, f, false);
368  delete [] t;
369  delete [] f;
370  extensional(home, x, d);
371  }
372 
373  };
374 
377  using namespace Gecode;
378  REG expression;
379  for (int i = 0; i<ts.tuples(); i++) {
380  REG r;
381  for (int j = 0; j<ts.arity(); j++) {
382  r += REG(ts[i][j]);
383  }
384  expression |= r;
385  }
386  DFA dfa(expression);
387  return dfa;
388  }
389 
391  class TupleSetBase : public Test {
392  protected:
396  bool pos;
397  public:
400  : Test("Extensional::TupleSet::" + str(p) + "::Base",
401  4,1,5,true,Gecode::IPL_DOM), t(4), pos(p) {
402  using namespace Gecode;
403  IntArgs t1({2, 1, 2, 4});
404  IntArgs t2({2, 2, 1, 4});
405  IntArgs t3({4, 3, 4, 1});
406  IntArgs t4({1, 3, 2, 3});
407  IntArgs t5({3, 3, 3, 2});
408  t.add(t1).add(t1).add(t2).add(t2)
409  .add(t3).add(t3).add(t4).add(t4)
410  .add(t5).add(t5).add(t5).add(t5)
411  .add(t5).add(t5).add(t5).add(t5)
412  .add(t1).add(t1).add(t2).add(t2)
413  .add(t3).add(t3).add(t4).add(t4)
414  .add(t5).add(t5).add(t5).add(t5)
415  .add(t5).add(t5).add(t5).add(t5)
416  .finalize();
417  }
419  virtual bool solution(const Assignment& x) const {
420  return pos == ((x[0] == 1 && x[1] == 3 && x[2] == 2 && x[3] == 3) ||
421  (x[0] == 2 && x[1] == 1 && x[2] == 2 && x[3] == 4) ||
422  (x[0] == 2 && x[1] == 2 && x[2] == 1 && x[3] == 4) ||
423  (x[0] == 3 && x[1] == 3 && x[2] == 3 && x[3] == 2) ||
424  (x[0] == 4 && x[1] == 3 && x[2] == 4 && x[3] == 1));
425  }
427  virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
428  using namespace Gecode;
429  TupleSet ts = TupleSet(t.arity(),tupleset2dfa(t));
430  assert(t == ts);
431  extensional(home, x, t, pos, ipl);
432  }
434  virtual void post(Gecode::Space& home, Gecode::IntVarArray& x,
435  Gecode::Reify r) {
436  extensional(home, x, t, pos, r, ipl);
437  }
438  };
439 
441  class TupleSetTest : public Test {
442  protected:
444  bool pos;
448  bool toDFA;
449  public:
451  TupleSetTest(const std::string& s, bool p,
452  Gecode::IntSet d0, Gecode::TupleSet ts0, bool td)
453  : Test("Extensional::TupleSet::" + str(p) + "::" + s,
454  ts0.arity(),d0,true,Gecode::IPL_DOM),
455  pos(p), ts(ts0), toDFA(td) {
456  }
458  virtual bool solution(const Assignment& x) const {
459  using namespace Gecode;
460  for (int i=ts.tuples(); i--; ) {
461  TupleSet::Tuple t = ts[i];
462  bool same = true;
463  for (int j=0; (j < ts.arity()) && same; j++)
464  if (t[j] != x[j])
465  same = false;
466  if (same)
467  return pos;
468  }
469  return !pos;
470  }
472  virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
473  using namespace Gecode;
474  if (toDFA) {
475  TupleSet t = TupleSet(ts.arity(),tupleset2dfa(ts));
476  assert(ts == t);
477  }
478  extensional(home, x, ts, pos, ipl);
479  }
481  virtual void post(Gecode::Space& home, Gecode::IntVarArray& x,
482  Gecode::Reify r) {
483  using namespace Gecode;
484  extensional(home, x, ts, pos, r, ipl);
485  }
486  };
487 
489  public:
491  RandomTupleSetTest(const std::string& s, bool p,
493  : TupleSetTest(s,p,d0,ts0,false) {
494  testsearch = false;
495  }
497  virtual Assignment* assignment(void) const {
498  using namespace Gecode;
499  return new RandomAssignment(arity,dom,1000);
500  }
501  };
502 
504  class TupleSetLarge : public Test {
505  protected:
507  bool pos;
510  public:
512  TupleSetLarge(double prob, bool p)
513  : Test("Extensional::TupleSet::" + str(p) + "::Large",
514  5,1,5,true,Gecode::IPL_DOM), pos(p), t(5) {
515  using namespace Gecode;
516 
517  CpltAssignment ass(5, IntSet(1, 5));
518  while (ass()) {
519  if (Base::rand(100) <= prob*100) {
520  IntArgs tuple(5);
521  for (int i = 5; i--; ) tuple[i] = ass[i];
522  t.add(tuple);
523  }
524  ++ass;
525  }
526  t.finalize();
527  }
529  virtual bool solution(const Assignment& x) const {
530  using namespace Gecode;
531  for (int i = 0; i < t.tuples(); ++i) {
532  TupleSet::Tuple l = t[i];
533  bool same = true;
534  for (int j = 0; j < t.arity() && same; ++j)
535  if (l[j] != x[j]) same = false;
536  if (same)
537  return pos;
538  }
539  return !pos;
540  }
542  virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
543  using namespace Gecode;
544  extensional(home, x, t, pos, ipl);
545  }
547  virtual void post(Gecode::Space& home, Gecode::IntVarArray& x,
548  Gecode::Reify r) {
549  using namespace Gecode;
550  extensional(home, x, t, pos, r, ipl);
551  }
552  };
553 
555  class TupleSetBool : public Test {
556  protected:
558  bool pos;
561  public:
563  TupleSetBool(double prob, bool p)
564  : Test("Extensional::TupleSet::" + str(p) + "::Bool",
565  5,0,1,true), pos(p), t(5) {
566  using namespace Gecode;
567 
568  CpltAssignment ass(5, IntSet(0, 1));
569  while (ass()) {
570  if (Base::rand(100) <= prob*100) {
571  IntArgs tuple(5);
572  for (int i = 5; i--; ) tuple[i] = ass[i];
573  t.add(tuple);
574  }
575  ++ass;
576  }
577  t.finalize();
578  }
580  virtual bool solution(const Assignment& x) const {
581  using namespace Gecode;
582  for (int i = 0; i < t.tuples(); ++i) {
583  TupleSet::Tuple l = t[i];
584  bool same = true;
585  for (int j = 0; j < t.arity() && same; ++j)
586  if (l[j] != x[j])
587  same = false;
588  if (same)
589  return pos;
590  }
591  return !pos;
592  }
594  virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
595  using namespace Gecode;
596  BoolVarArgs y(x.size());
597  for (int i = x.size(); i--; )
598  y[i] = channel(home, x[i]);
599  extensional(home, y, t, pos, ipl);
600  }
602  virtual void post(Gecode::Space& home, Gecode::IntVarArray& x,
603  Gecode::Reify r) {
604  using namespace Gecode;
605  BoolVarArgs y(x.size());
606  for (int i = x.size(); i--; )
607  y[i] = channel(home, x[i]);
608  extensional(home, y, t, pos, r, ipl);
609  }
610  };
611 
614  public:
616  TupleSetTestSize(int size, bool pos) {
617  using namespace Gecode;
619  int arity = 2;
620  int n_tuples = 5*5;
621  while (n_tuples < size) {
622  arity++;
623  n_tuples*=5;
624  }
626  TupleSet ts(arity);
627  CpltAssignment ass(arity, IntSet(0, 4));
628  for (int i = size; i--; ) {
629  assert(ass());
630  IntArgs tuple(arity);
631  for (int j = arity; j--; ) tuple[j] = ass[j];
632  ts.add(tuple);
633  ++ass;
634  }
635  ts.finalize();
636  assert(ts.tuples() == size);
637  // Create and register test
638  (void) new TupleSetTest(std::to_string(size),pos,IntSet(0,4),ts,
639  size <= 128);
640  }
641  };
642 
643  Gecode::TupleSet randomTupleSet(int n, int min, int max, double prob) {
644  using namespace Gecode;
645  TupleSet t(n);
646  CpltAssignment ass(n, IntSet(min, max));
647  while (ass()) {
648  if (Base::rand(100) <= prob*100) {
649  IntArgs tuple(n);
650  for (int i = n; i--; ) tuple[i] = ass[i];
651  t.add(tuple);
652  }
653  ++ass;
654  }
655  t.finalize();
656  return t;
657  }
658 
660  class Create {
661  public:
663  Create(void) {
664  using namespace Gecode;
665  for (bool pos : { false, true }) {
666  {
667  TupleSet ts(4);
668  ts.add({2, 1, 2, 4}).add({2, 2, 1, 4})
669  .add({4, 3, 4, 1}).add({1, 3, 2, 3})
670  .add({3, 3, 3, 2}).add({5, 1, 4, 4})
671  .add({2, 5, 1, 5}).add({4, 3, 5, 1})
672  .add({1, 5, 2, 5}).add({5, 3, 3, 2})
673  .finalize();
674  (void) new TupleSetTest("A",pos,IntSet(0,6),ts,true);
675  }
676  {
677  TupleSet ts(4);
678  ts.finalize();
679  (void) new TupleSetTest("Empty",pos,IntSet(1,2),ts,true);
680  }
681  {
682  TupleSet ts(4);
683  for (int n=1024*16; n--; )
684  ts.add({1,2,3,4});
685  ts.finalize();
686  (void) new TupleSetTest("Assigned",pos,IntSet(1,4),ts,true);
687  }
688  {
689  TupleSet ts(1);
690  ts.add({1}).add({2}).add({3}).finalize();
691  (void) new TupleSetTest("Single",pos,IntSet(-4,4),ts,true);
692  }
693  {
694  int m = Gecode::Int::Limits::min;
695  TupleSet ts(3);
696  ts.add({m+0,m+1,m+2}).add({m+4,m+1,m+3})
697  .add({m+2,m+3,m+0}).add({m+2,m+3,m+0})
698  .add({m+1,m+2,m+5}).add({m+2,m+3,m+0})
699  .add({m+3,m+6,m+5}).finalize();
700  (void) new TupleSetTest("Min",pos,IntSet(m,m+7),ts,true);
701  }
702  {
703  int M = Gecode::Int::Limits::max;
704  TupleSet ts(3);
705  ts.add({M-0,M-1,M-2}).add({M-4,M-1,M-3})
706  .add({M-2,M-3,M-0}).add({M-2,M-3,M-0})
707  .add({M-1,M-2,M-5}).add({M-2,M-3,M-0})
708  .add({M-3,M-6,M-5}).finalize();
709  (void) new TupleSetTest("Max",pos,IntSet(M-7,M),ts,true);
710  }
711  {
712  int m = Gecode::Int::Limits::min;
713  int M = Gecode::Int::Limits::max;
714  TupleSet ts(3);
715  ts.add({M-0,m+1,M-2}).add({m+4,M-1,M-3})
716  .add({m+2,M-3,m+0}).add({M-2,M-3,M-0})
717  .finalize();
718  (void) new TupleSetTest("MinMax",pos,
719  IntSet(IntArgs({m,m+1,m+4,M-3,M-2,M})),
720  ts,true);
721  }
722  {
723  TupleSet ts(7);
724  for (int i = 0; i < 10000; i++) {
725  IntArgs tuple(7);
726  for (int j = 0; j < 7; j++) {
727  tuple[j] = Base::rand(j+1);
728  }
729  ts.add(tuple);
730  }
731  ts.finalize();
732  (void) new RandomTupleSetTest("Triangle",pos,IntSet(0,6),ts);
733  }
734  {
735  for (int i = 0; i <= 64*6; i+=32)
736  (void) new TupleSetTestSize(i,pos);
737  }
738  {
739  (void) new RandomTupleSetTest("Rand(10,-1,2)", pos,
740  IntSet(-1,2),
741  randomTupleSet(10,-1,2,0.05));
742  (void) new RandomTupleSetTest("Rand(5,-10,10)", pos,
743  IntSet(-10,10),
744  randomTupleSet(5,-10,10,0.05));
745  }
746  {
747  TupleSet t(5);
748  CpltAssignment ass(4, IntSet(1, 4));
749  while (ass()) {
750  IntArgs tuple(5);
751  tuple[4] = 1;
752  for (int i = 4; i--; ) tuple[i] = ass[i];
753  t.add(tuple);
754  ++ass;
755  }
756  t.add({2,2,4,3,4});
757  t.finalize();
758  (void) new TupleSetTest("FewLast",pos,IntSet(1,4),t,false);
759  }
760  {
761  TupleSet t(4);
762  CpltAssignment ass(4, IntSet(1, 6));
763  while (ass()) {
764  t.add({ass[0],0,ass[1],ass[2]});
765  ++ass;
766  }
767  t.add({2,-1,3,4});
768  t.finalize();
769  (void) new TupleSetTest("FewMiddle",pos,IntSet(-1,6),t,false);
770  }
771  {
772  TupleSet t(10);
773  CpltAssignment ass(9, IntSet(1, 4));
774  while (ass()) {
775  if (Base::rand(100) <= 0.25*100) {
776  IntArgs tuple(10);
777  tuple[0] = 2;
778  for (int i = 9; i--; ) tuple[i+1] = ass[i];
779  t.add(tuple);
780  }
781  ++ass;
782  }
783  t.add({1,1,1,1,1,1,1,1,1,1});
784  t.add({1,2,3,4,4,2,1,2,3,3});
785  t.finalize();
786  (void) new RandomTupleSetTest("FewHuge",pos,IntSet(1,4),t);
787  }
788  (void) new TupleSetBase(pos);
789  (void) new TupleSetLarge(0.05,pos);
790  (void) new TupleSetBool(0.3,pos);
791  }
792  }
793  };
794 
796 
800 
802 
803  RegRoland rr1(1);
804  RegRoland rr2(2);
805  RegRoland rr3(3);
806  RegRoland rr4(4);
807 
812 
815 
816  RegOpt ro0(CHAR_MAX-1);
817  RegOpt ro1(CHAR_MAX);
818  RegOpt ro2(static_cast<int>(UCHAR_MAX-1));
819  RegOpt ro3(static_cast<int>(UCHAR_MAX));
820  RegOpt ro4(SHRT_MAX-1);
821  RegOpt ro5(SHRT_MAX);
822  RegOpt ro6(static_cast<int>(USHRT_MAX-1));
823  RegOpt ro7(static_cast<int>(USHRT_MAX));
825 
826  }
827 }}
828 
829 
830 // STATISTICS: test-int
RegRoland(int n)
Create and register test.
virtual void post(Gecode::Space &home, Gecode::IntVarArray &x)
Post constraint on x.
Test with simple regular expression and shared variables (uses unsharing)
int symbol
symbol
Definition: int.hh:2060
NodeType t
Type of node.
Definition: bool-expr.cpp:230
static std::string str(Gecode::IntPropLevel ipl)
Map integer propagation level to string.
Definition: int.hpp:208
Gecode::TupleSet randomTupleSet(int n, int min, int max, double prob)
void finalize(void)
Finalize tuple set.
Definition: tuple-set.hpp:155
NNF * l
Left subtree.
Definition: bool-expr.cpp:240
RegEmptyREG(void)
Create and register test.
virtual void post(Gecode::Space &home, Gecode::IntVarArray &x)
Post constraint on x.
virtual bool solution(const Assignment &x) const
Test whether x is solution
Create(void)
Perform creation and registration.
void channel(Home home, FloatVar x0, IntVar x1)
Post propagator for channeling a float and an integer variable .
Definition: channel.cpp:41
int size(void) const
Return size of array (number of elements)
Definition: array.hpp:908
const FloatNum max
Largest allowed float value.
Definition: float.hh:844
Test for optimizations
virtual void post(Gecode::Space &home, Gecode::IntVarArray &x)
Post constraint on x.
Definition: extensional.cpp:66
int size(void) const
Return number of variables.
Definition: int.hpp:46
int arity(void) const
Arity of tuple set.
Definition: tuple-set.hpp:181
Test with regular expression for distinct constraint
static Gecode::Support::RandomGenerator rand
Random number generator.
Definition: test.hh:134
bool pos
Whether the table is positive or negative.
Regular expressions over integer values.
Definition: minimodel.hh:1518
RegOpt ro3(static_cast< int >(UCHAR_MAX))
virtual void post(Gecode::Space &home, Gecode::IntVarArray &x, Gecode::Reify r)
Post reified constraint on x for r.
Gecode::TupleSet t
Tupleset used for testing.
virtual void post(Gecode::Space &home, Gecode::IntVarArray &x)
Post constraint on x.
RegDistinct(void)
Create and register test.
virtual void post(Gecode::Space &home, Gecode::IntVarArray &x)
Post constraint on x.
bool pos(const View &x)
Test whether x is postive.
Definition: mult.hpp:41
Test with simple regular expression
Definition: extensional.cpp:77
int * Tuple
Type of a tuple.
Definition: int.hh:2196
virtual void post(Gecode::Space &home, Gecode::IntVarArray &x)
Post constraint on x.
virtual Assignment * assignment(void) const
Create and register initial assignment.
Gecode::IntSet dom
Domain of variables.
Definition: int.hh:228
void unshare(Home home, VarArgArray< Var > &x, IntPropLevel ipl)
Replace unassigned shared variables by fresh, yet equal variables.
Definition: unshare.cpp:108
virtual bool solution(const Assignment &x) const
Test whether x is solution
Integer variable array.
Definition: int.hh:763
Test with simple regular expression and shared variables (uses unsharing)
TupleSetTest(const std::string &s, bool p, Gecode::IntSet d0, Gecode::TupleSet ts0, bool td)
Create and register test.
virtual bool solution(const Assignment &x) const
Test whether x is solution
Test with simple regular expression
Definition: extensional.cpp:98
const int max
Largest allowed integer value.
Definition: int.hh:116
Computation spaces.
Definition: core.hpp:1701
Generate random selection of assignments.
Definition: int.hh:96
int i_state
input state
Definition: int.hh:2059
RegOpt ro1(CHAR_MAX)
RegOpt ro0(CHAR_MAX-1)
const int min
Smallest allowed integer value.
Definition: int.hh:118
virtual bool solution(const Assignment &x) const
Test whether x is solution
Gecode::IntSet d(v, 7)
virtual bool solution(const Assignment &x) const
Test whether x is solution
int tuples(void) const
Number of tuples.
Definition: tuple-set.hpp:185
virtual bool solution(const Assignment &x) const
Test whether x is solution
virtual void post(Gecode::Space &home, Gecode::IntVarArray &x, Gecode::Reify r)
Post reified constraint on x for r.
virtual bool solution(const Assignment &x) const
Test whether x is solution
Deterministic finite automaton (DFA)
Definition: int.hh:2048
int p
Number of positive literals for node type.
Definition: bool-expr.cpp:232
const FloatNum min
Smallest allowed float value.
Definition: float.hh:846
RandomTupleSetTest(const std::string &s, bool p, Gecode::IntSet d0, Gecode::TupleSet ts0)
Create and register test.
virtual void post(Gecode::Space &home, Gecode::IntVarArray &x)
Post constraint on x.
int n
Number of negative literals for node type.
Definition: bool-expr.cpp:234
virtual void post(Gecode::Space &home, Gecode::IntVarArray &x)
Post constraint on x.
virtual void post(Gecode::Space &home, Gecode::IntVarArray &x)
Post constraint on x.
Gecode::IntArgs i({1, 2, 3, 4})
virtual void post(Gecode::Space &home, Gecode::IntVarArray &x)
Post constraint on x.
RegOpt ro5(SHRT_MAX)
void extensional(Home home, const IntVarArgs &x, DFA dfa, IntPropLevel)
Post domain consistent propagator for extensional constraint described by a DFA.
TupleSetLarge(double prob, bool p)
Create and register test.
Specification of a DFA transition.
Definition: int.hh:2057
unsigned int size(I &i)
Size of all ranges of range iterator i.
Gecode::TupleSet ts
The tuple set to use.
Reification specification.
Definition: int.hh:876
RegSharedB(void)
Create and register test.
RegOpt ro7(static_cast< int >(USHRT_MAX))
Gecode::DFA tupleset2dfa(Gecode::TupleSet ts)
% Transform a TupleSet into a DFA
bool toDFA
Whether to validate dfa2tupleset.
virtual void post(Gecode::Space &home, Gecode::IntVarArray &x)
Post constraint on x.
RegEmptyDFA(void)
Create and register test.
virtual void post(Gecode::Space &home, Gecode::IntVarArray &x, Gecode::Reify r)
Post reified constraint on x for r.
Integer sets.
Definition: int.hh:174
int o_state
output state Default constructor
Definition: int.hh:2061
virtual void post(Gecode::Space &home, Gecode::IntVarArray &x)
Post constraint on x.
Definition: extensional.cpp:86
virtual bool solution(const Assignment &x) const
Test whether x is solution
Gecode::IntPropLevel ipl
Propagation level.
Definition: int.hh:234
Passing integer variables.
Definition: int.hh:656
Passing integer arguments.
Definition: int.hh:628
Passing Boolean variables.
Definition: int.hh:712
bool same(VarArgArray< Var > x, VarArgArray< Var > y)
Definition: array.hpp:1899
Gecode::TupleSet t
Simple test tupleset.
virtual bool solution(const Assignment &x) const
Test whether x is solution
TupleSetBool(double prob, bool p)
Create and register test.
Class represeting a set of tuples.
Definition: int.hh:2190
RegSharedD(void)
Create and register test.
General test support.
Definition: afc.cpp:39
Post propagator for SetVar SetOpType SetVar y
Definition: set.hh:767
virtual bool solution(const Assignment &x) const
Test whether x is solution
Definition: extensional.cpp:82
Node * x
Pointer to corresponding Boolean expression node.
Definition: bool-expr.cpp:249
virtual void post(Gecode::Space &home, Gecode::IntVarArray &x, Gecode::Reify r)
Post reified constraint on x for r.
virtual bool solution(const Assignment &x) const
Test whether x is solution
bool testsearch
Whether to perform search test.
Definition: int.hh:238
Region r
Definition: region.cpp:65
Base class for assignments
Definition: int.hh:59
Test with simple regular expression and shared variables (uses unsharing)
Domain propagation Options: basic versus advanced propagation.
Definition: int.hh:979
Gecode::TupleSet t
Tupleset used for testing.
Help class to create and register tests with a fixed table size.
virtual void post(Gecode::Space &home, Gecode::IntVarArray &x)
Post constraint on x.
virtual bool solution(const Assignment &x) const
Test whether x is solution
RegOpt(int n0)
Create and register test.
TupleSet & add(const IntArgs &t)
Add tuple t to tuple set.
Definition: tuple-set.hpp:142
Test with simple regular expression from Roland Yap
int n
DFA size characteristic.
RegSimpleC(void)
Create and register test.
virtual bool solution(const Assignment &x) const
Test whether x is solution
Definition: extensional.cpp:59
virtual void post(Gecode::Space &home, Gecode::IntVarArray &x)
Post constraint on x.
Gecode toplevel namespace
virtual bool solution(const Assignment &x) const
Test whether x is solution
RegOpt ro4(SHRT_MAX-1)
Test for empty regular expression
Help class to create and register tests.
int arity
Number of variables.
Definition: int.hh:226
virtual void post(Gecode::Space &home, Gecode::IntVarArray &x)
Post constraint on x.
virtual bool solution(const Assignment &x) const
Test whether x is solution
RegOpt ro6(static_cast< int >(USHRT_MAX-1))
TupleSetBase(bool p)
Create and register test.
bool pos
Whether the table is positive or negative.
bool pos
Whether the table is positive or negative.
RegOpt ro2(static_cast< int >(UCHAR_MAX-1))
bool pos
Whether the table is positive or negative.
RegSharedA(void)
Create and register test.
Test with bool tuple set
virtual void post(Gecode::Space &home, Gecode::IntVarArray &x)
Post constraint on x.
TupleSetTestSize(int size, bool pos)
Perform creation and registration.
RegSharedC(void)
Create and register test.
Test with large tuple set
Test with simple regular expression and shared variables (uses unsharing)
Generate all assignments.
Definition: int.hh:79
virtual bool solution(const Assignment &x) const
Test whether x is solution
RegSimpleA(void)
Create and register test.
Definition: extensional.cpp:57
RegSimpleB(void)
Create and register test.
Definition: extensional.cpp:80
Test with simple regular expression
Definition: extensional.cpp:54