Something went wrong. Try again.
This repository has no description
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- *//* * Main authors: * Mikael Lagerkvist <lagerkvist@gecode.org> * Linnea Ingmar <linnea.ingmar@hotmail.com> * Christian Schulte <schulte@gecode.org> * * Copyright: * Linnea Ingmar, 2017 * Mikael Lagerkvist, 2007 * Christian Schulte, 2005 * * This file is part of Gecode, the generic constraint * development environment: * http://www.gecode.org * * Permission is hereby granted, free of charge, to any person obtaining * a copy of this software and associated documentation files (the * "Software"), to deal in the Software without restriction, including * without limitation the rights to use, copy, modify, merge, publish, * distribute, sublicense, and/or sell copies of the Software, and to * permit persons to whom the Software is furnished to do so, subject to * the following conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. * */
#include "test/int.hh"
#include <gecode/minimodel.hh>#include <climits>
namespace Test { namespace Int {
/// %Tests for extensional (relation) constraints namespace Extensional {
/** * \defgroup TaskTestIntExtensional Extensional (relation) constraints * \ingroup TaskTestInt */ //@{ /// %Test with simple regular expression class RegSimpleA : public Test { public: /// Create and register test RegSimpleA(void) : Test("Extensional::Reg::Simple::A",4,2,2) {} /// %Test whether \a x is solution virtual bool solution(const Assignment& x) const { return (((x[0] == 0) || (x[0] == 2)) && ((x[1] == -1) || (x[1] == 1)) && ((x[2] == 0) || (x[2] == 1)) && ((x[3] == 0) || (x[3] == 1))); } /// Post constraint on \a x virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) { using namespace Gecode; extensional(home, x, (REG(0) | REG(2)) + (REG(-1) | REG(1)) + (REG(7) | REG(0) | REG(1)) + (REG(0) | REG(1))); } };
/// %Test with simple regular expression class RegSimpleB : public Test { public: /// Create and register test RegSimpleB(void) : Test("Extensional::Reg::Simple::B",4,2,2) {} /// %Test whether \a x is solution virtual bool solution(const Assignment& x) const { return (x[0]<x[1]) && (x[1]<x[2]) && (x[2]<x[3]); } /// Post constraint on \a x virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) { using namespace Gecode; extensional(home, x, (REG(-2) + REG(-1) + REG(0) + REG(1)) | (REG(-2) + REG(-1) + REG(0) + REG(2)) | (REG(-2) + REG(-1) + REG(1) + REG(2)) | (REG(-2) + REG(0) + REG(1) + REG(2)) | (REG(-1) + REG(0) + REG(1) + REG(2))); } };
/// %Test with simple regular expression class RegSimpleC : public Test { public: /// Create and register test RegSimpleC(void) : Test("Extensional::Reg::Simple::C",6,0,1) {} /// %Test whether \a x is solution virtual bool solution(const Assignment& x) const { int pos = 0; int s = x.size();
while (pos < s && x[pos] == 0) ++pos; if (pos + 4 > s) return false;
for (int i = 0; i < 2; ++i, ++pos) if (x[pos] != 1) return false; if (pos + 2 > s) return false;
for (int i = 0; i < 1; ++i, ++pos) if (x[pos] != 0) return false; while (pos < s && x[pos] == 0) ++pos; if (pos + 1 > s) return false;
for (int i = 0; i < 1; ++i, ++pos) if (x[pos] != 1) return false; while (pos < s) if (x[pos++] != 0) return false; return true;
} /// Post constraint on \a x virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) { using namespace Gecode; extensional(home, x, *REG(0) + REG(1)(2,2) + +REG(0) + REG(1)(1,1) + *REG(0)); } };
/// %Test with regular expression for distinct constraint class RegDistinct : public Test { public: /// Create and register test RegDistinct(void) : Test("Extensional::Reg::Distinct",4,-1,4) {} /// %Test whether \a x is solution virtual bool solution(const Assignment& x) const { for (int i=0; i<x.size(); i++) { if ((x[i] < 0) || (x[i] > 3)) return false; for (int j=i+1; j<x.size(); j++) if (x[i]==x[j]) return false; } return true; } /// Post constraint on \a x virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) { using namespace Gecode; extensional(home, x, (REG(0)+REG(1)+REG(2)+REG(3)) | (REG(0)+REG(1)+REG(3)+REG(2)) | (REG(0)+REG(2)+REG(1)+REG(3)) | (REG(0)+REG(2)+REG(3)+REG(1)) | (REG(0)+REG(3)+REG(1)+REG(2)) | (REG(0)+REG(3)+REG(2)+REG(1)) | (REG(1)+REG(0)+REG(2)+REG(3)) | (REG(1)+REG(0)+REG(3)+REG(2)) | (REG(1)+REG(2)+REG(0)+REG(3)) | (REG(1)+REG(2)+REG(3)+REG(0)) | (REG(1)+REG(3)+REG(0)+REG(2)) | (REG(1)+REG(3)+REG(2)+REG(0)) | (REG(2)+REG(0)+REG(1)+REG(3)) | (REG(2)+REG(0)+REG(3)+REG(1)) | (REG(2)+REG(1)+REG(0)+REG(3)) | (REG(2)+REG(1)+REG(3)+REG(0)) | (REG(2)+REG(3)+REG(0)+REG(1)) | (REG(2)+REG(3)+REG(1)+REG(0)) | (REG(3)+REG(0)+REG(1)+REG(2)) | (REG(3)+REG(0)+REG(2)+REG(1)) | (REG(3)+REG(1)+REG(0)+REG(2)) | (REG(3)+REG(1)+REG(2)+REG(0)) | (REG(3)+REG(2)+REG(0)+REG(1)) | (REG(3)+REG(2)+REG(1)+REG(0))); } };
/// %Test with simple regular expression from Roland Yap class RegRoland : public Test { public: /// Create and register test RegRoland(int n) : Test("Extensional::Reg::Roland::"+str(n),n,0,1) {} /// %Test whether \a x is solution virtual bool solution(const Assignment& x) const { int n = x.size(); return ((n > 1) && (x[n-2] == 0)) || ((n > 0) && (x[n-1] == 0)); } /// Post constraint on \a x virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) { using namespace Gecode; REG r0(0), r1(1); REG r01 = r0 | r1; extensional(home, x, *r01 + r0 + r01(0,1)); } };
/// %Test with simple regular expression and shared variables (uses unsharing) class RegSharedA : public Test { public: /// Create and register test RegSharedA(void) : Test("Extensional::Reg::Shared::A",4,2,2) {} /// %Test whether \a x is solution virtual bool solution(const Assignment& x) const { return (((x[0] == 0) || (x[0] == 2)) && ((x[1] == -1) || (x[1] == 1)) && ((x[2] == 0) || (x[2] == 1)) && ((x[3] == 0) || (x[3] == 1))); } /// Post constraint on \a x virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) { using namespace Gecode; IntVarArgs y(8); for (int i=0; i<4; i++) y[i]=y[i+4]=x[i]; unshare(home,y); extensional(home, y, ((REG(0) | REG(2)) + (REG(-1) | REG(1)) + (REG(7) | REG(0) | REG(1)) + (REG(0) | REG(1)))(2,2)); } };
/// %Test with simple regular expression and shared variables (uses unsharing) class RegSharedB : public Test { public: /// Create and register test RegSharedB(void) : Test("Extensional::Reg::Shared::B",4,2,2) {} /// %Test whether \a x is solution virtual bool solution(const Assignment& x) const { return (((x[0] == 0) || (x[0] == 2)) && ((x[1] == -1) || (x[1] == 1)) && ((x[2] == 0) || (x[2] == 1)) && ((x[3] == 0) || (x[3] == 1))); } /// Post constraint on \a x virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) { using namespace Gecode; IntVarArgs y(12); for (int i=0; i<4; i++) y[i]=y[i+4]=y[i+8]=x[i]; unshare(home,y); extensional(home, y, ((REG(0) | REG(2)) + (REG(-1) | REG(1)) + (REG(7) | REG(0) | REG(1)) + (REG(0) | REG(1)))(3,3)); } };
/// %Test with simple regular expression and shared variables (uses unsharing) class RegSharedC : public Test { public: /// Create and register test RegSharedC(void) : Test("Extensional::Reg::Shared::C",4,0,1) {} /// %Test whether \a x is solution virtual bool solution(const Assignment& x) const { return (x[1]==1) && (x[2]==0) && (x[3]==1); } /// Post constraint on \a x virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) { using namespace Gecode; Gecode::BoolVarArgs y(8); for (int i=0; i<4; i++) y[i]=y[i+4]=channel(home,x[i]); unshare(home,y); extensional(home,y, ((REG(0) | REG(1)) + REG(1) + REG(0) + REG(1))(2,2)); } };
/// %Test with simple regular expression and shared variables (uses unsharing) class RegSharedD : public Test { public: /// Create and register test RegSharedD(void) : Test("Extensional::Reg::Shared::D",4,0,1) {} /// %Test whether \a x is solution virtual bool solution(const Assignment& x) const { return (x[1]==1) && (x[2]==0) && (x[3]==1); } /// Post constraint on \a x virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) { using namespace Gecode; Gecode::BoolVarArgs y(12); for (int i=0; i<4; i++) y[i]=y[i+4]=y[i+8]=channel(home,x[i]); unshare(home, y); extensional(home, y, ((REG(0) | REG(1)) + REG(1) + REG(0) + REG(1))(3,3)); } };
/// %Test for empty DFA class RegEmptyDFA : public Test { public: /// Create and register test RegEmptyDFA(void) : Test("Extensional::Reg::Empty::DFA",1,0,0) { testsearch = false; } /// %Test whether \a x is solution virtual bool solution(const Assignment& x) const { (void)x; return false; } /// Post constraint on \a x virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) { Gecode::DFA d; Gecode::extensional(home, x, d); } };
/// %Test for empty regular expression class RegEmptyREG : public Test { public: /// Create and register test RegEmptyREG(void) : Test("Extensional::Reg::Empty::REG",1,0,0) { testsearch = false; } /// %Test whether \a x is solution virtual bool solution(const Assignment& x) const { (void)x; return false; } /// Post constraint on \a x virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) { Gecode::REG r; Gecode::extensional(home, x, r); } };
/// %Test for optimizations class RegOpt : public Test { protected: /// DFA size characteristic int n; public: /// Create and register test RegOpt(int n0) : Test("Extensional::Reg::Opt::"+str(n0),1,0,15), n(n0) {} /// %Test whether \a x is solution virtual bool solution(const Assignment& x) const { return (x[0] < n) && ((x[0] & 1) == 0); } /// Post constraint on \a x virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) { using namespace Gecode; DFA::Transition* t = new DFA::Transition[n+1]; DFA::Transition* ti = t; int* f = new int[n+1]; int* fi = f; for (int i=0; i<n; i++) { ti->i_state = 0; ti->symbol = i; ti->o_state = i+1; ti++; if ((i & 1) == 0) { *fi = i+1; fi++; } } ti->i_state = -1; *fi = -1; DFA d(0, t, f, false); delete [] t; delete [] f; extensional(home, x, d); }
};
///% Transform a TupleSet into a DFA Gecode::DFA tupleset2dfa(Gecode::TupleSet ts) { using namespace Gecode; REG expression; for (int i = 0; i<ts.tuples(); i++) { REG r; for (int j = 0; j<ts.arity(); j++) { r += REG(ts[i][j]); } expression |= r; } DFA dfa(expression); return dfa; }
/// %Test with tuple set class TupleSetBase : public Test { protected: /// Simple test tupleset Gecode::TupleSet t; /// Whether the table is positive or negative bool pos; public: /// Create and register test TupleSetBase(bool p) : Test("Extensional::TupleSet::" + str(p) + "::Base", 4,1,5,true,Gecode::IPL_DOM), t(4), pos(p) { using namespace Gecode; IntArgs t1({2, 1, 2, 4}); IntArgs t2({2, 2, 1, 4}); IntArgs t3({4, 3, 4, 1}); IntArgs t4({1, 3, 2, 3}); IntArgs t5({3, 3, 3, 2}); t.add(t1).add(t1).add(t2).add(t2) .add(t3).add(t3).add(t4).add(t4) .add(t5).add(t5).add(t5).add(t5) .add(t5).add(t5).add(t5).add(t5) .add(t1).add(t1).add(t2).add(t2) .add(t3).add(t3).add(t4).add(t4) .add(t5).add(t5).add(t5).add(t5) .add(t5).add(t5).add(t5).add(t5) .finalize(); } /// %Test whether \a x is solution virtual bool solution(const Assignment& x) const { return pos == ((x[0] == 1 && x[1] == 3 && x[2] == 2 && x[3] == 3) || (x[0] == 2 && x[1] == 1 && x[2] == 2 && x[3] == 4) || (x[0] == 2 && x[1] == 2 && x[2] == 1 && x[3] == 4) || (x[0] == 3 && x[1] == 3 && x[2] == 3 && x[3] == 2) || (x[0] == 4 && x[1] == 3 && x[2] == 4 && x[3] == 1)); } /// Post constraint on \a x virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) { using namespace Gecode; TupleSet ts = TupleSet(t.arity(),tupleset2dfa(t)); assert(t == ts); extensional(home, x, t, pos, ipl); } /// Post reified constraint on \a x for \a r virtual void post(Gecode::Space& home, Gecode::IntVarArray& x, Gecode::Reify r) { extensional(home, x, t, pos, r, ipl); } };
/// %Test with tuple set class TupleSetTest : public Test { protected: /// Whether the table is positive or negative bool pos; /// The tuple set to use Gecode::TupleSet ts; /// Whether to validate dfa2tupleset bool toDFA; public: /// Create and register test TupleSetTest(const std::string& s, bool p, Gecode::IntSet d0, Gecode::TupleSet ts0, bool td) : Test("Extensional::TupleSet::" + str(p) + "::" + s, ts0.arity(),d0,true,Gecode::IPL_DOM), pos(p), ts(ts0), toDFA(td) { } /// %Test whether \a x is solution virtual bool solution(const Assignment& x) const { using namespace Gecode; for (int i=ts.tuples(); i--; ) { TupleSet::Tuple t = ts[i]; bool same = true; for (int j=0; (j < ts.arity()) && same; j++) if (t[j] != x[j]) same = false; if (same) return pos; } return !pos; } /// Post constraint on \a x virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) { using namespace Gecode; if (toDFA) { TupleSet t = TupleSet(ts.arity(),tupleset2dfa(ts)); assert(ts == t); } extensional(home, x, ts, pos, ipl); } /// Post reified constraint on \a x for \a r virtual void post(Gecode::Space& home, Gecode::IntVarArray& x, Gecode::Reify r) { using namespace Gecode; extensional(home, x, ts, pos, r, ipl); } };
class RandomTupleSetTest : public TupleSetTest { public: /// Create and register test RandomTupleSetTest(const std::string& s, bool p, Gecode::IntSet d0, Gecode::TupleSet ts0) : TupleSetTest(s,p,d0,ts0,false) { testsearch = false; } /// Create and register initial assignment virtual Assignment* assignment(void) const { using namespace Gecode; return new RandomAssignment(arity, dom, 1000, _rand); } };
/// %Test with large tuple set class TupleSetLarge : public Test { protected: /// Whether the table is positive or negative bool pos; /// Tupleset used for testing mutable Gecode::TupleSet t; public: /// Create and register test TupleSetLarge(double prob, bool p) : Test("Extensional::TupleSet::" + str(p) + "::Large", 5,1,5,true,Gecode::IPL_DOM), pos(p), t(5) { using namespace Gecode;
CpltAssignment ass(5, IntSet(1, 5)); while (ass.has_more()) { if (_rand(100) <= prob*100) { IntArgs tuple(5); for (int i = 5; i--; ) tuple[i] = ass[i]; t.add(tuple); } ass.next(_rand); } t.finalize(); } /// %Test whether \a x is solution virtual bool solution(const Assignment& x) const { using namespace Gecode; for (int i = 0; i < t.tuples(); ++i) { TupleSet::Tuple l = t[i]; bool same = true; for (int j = 0; j < t.arity() && same; ++j) if (l[j] != x[j]) same = false; if (same) return pos; } return !pos; } /// Post constraint on \a x virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) { using namespace Gecode; extensional(home, x, t, pos, ipl); } /// Post reified constraint on \a x for \a r virtual void post(Gecode::Space& home, Gecode::IntVarArray& x, Gecode::Reify r) { using namespace Gecode; extensional(home, x, t, pos, r, ipl); } };
/// %Test with bool tuple set class TupleSetBool : public Test { protected: /// Whether the table is positive or negative bool pos; /// Tupleset used for testing mutable Gecode::TupleSet t; public: /// Create and register test TupleSetBool(double prob, bool p) : Test("Extensional::TupleSet::" + str(p) + "::Bool", 5,0,1,true), pos(p), t(5) { using namespace Gecode;
CpltAssignment ass(5, IntSet(0, 1)); while (ass.has_more()) { if (_rand(100) <= prob*100) { IntArgs tuple(5); for (int i = 5; i--; ) tuple[i] = ass[i]; t.add(tuple); } ass.next(_rand); } t.finalize(); } /// %Test whether \a x is solution virtual bool solution(const Assignment& x) const { using namespace Gecode; for (int i = 0; i < t.tuples(); ++i) { TupleSet::Tuple l = t[i]; bool same = true; for (int j = 0; j < t.arity() && same; ++j) if (l[j] != x[j]) same = false; if (same) return pos; } return !pos; } /// Post constraint on \a x virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) { using namespace Gecode; BoolVarArgs y(x.size()); for (int i = x.size(); i--; ) y[i] = channel(home, x[i]); extensional(home, y, t, pos, ipl); } /// Post reified constraint on \a x for \a r virtual void post(Gecode::Space& home, Gecode::IntVarArray& x, Gecode::Reify r) { using namespace Gecode; BoolVarArgs y(x.size()); for (int i = x.size(); i--; ) y[i] = channel(home, x[i]); extensional(home, y, t, pos, r, ipl); } };
/// Help class to create and register tests with a fixed table size class TupleSetTestSize { public: /// Perform creation and registration TupleSetTestSize(int size, bool pos, Gecode::Support::RandomGenerator& rand) { using namespace Gecode; /// Find the arity needed for creating sufficient number of tuples int arity = 2; int n_tuples = 5*5; while (n_tuples < size) { arity++; n_tuples*=5; } /// Build TupleSet TupleSet ts(arity); CpltAssignment ass(arity, IntSet(0, 4)); for (int i = size; i--; ) { assert(ass.has_more()); IntArgs tuple(arity); for (int j = arity; j--; ) tuple[j] = ass[j]; ts.add(tuple); ass.next(rand); } ts.finalize(); assert(ts.tuples() == size); // Create and register test (void) new TupleSetTest(std::to_string(size),pos,IntSet(0,4),ts, size <= 128); } };
Gecode::TupleSet randomTupleSet(int n, int min, int max, double prob, Gecode::Support::RandomGenerator& rand) { using namespace Gecode; TupleSet t(n); CpltAssignment ass(n, IntSet(min, max)); while (ass.has_more()) { if (rand(100) <= prob*100) { IntArgs tuple(n); for (int i = n; i--; ) tuple[i] = ass[i]; t.add(tuple); } ass.next(rand); } t.finalize(); return t; }
/// Help class to create and register tests class Create { public: /// Perform creation and registration Create(void) { // This code is executed on load, and thus a random number generator source from the supplied // seed is not available. // In order to get interesting data her, but still have deterministic and repeatable execution, a fixed seed // is used for a local random number generator. // TODO: Make this code later on test run, and use the supplied seed/random number generator. Gecode::Support::RandomGenerator rand(42);
using namespace Gecode; for (bool pos : { false, true }) { { TupleSet ts(4); ts.add({2, 1, 2, 4}).add({2, 2, 1, 4}) .add({4, 3, 4, 1}).add({1, 3, 2, 3}) .add({3, 3, 3, 2}).add({5, 1, 4, 4}) .add({2, 5, 1, 5}).add({4, 3, 5, 1}) .add({1, 5, 2, 5}).add({5, 3, 3, 2}) .finalize(); (void) new TupleSetTest("A",pos,IntSet(0,6),ts,true); } { TupleSet ts(4); ts.finalize(); (void) new TupleSetTest("Empty",pos,IntSet(1,2),ts,true); } { TupleSet ts(4); for (int n=1024*16; n--; ) ts.add({1,2,3,4}); ts.finalize(); (void) new TupleSetTest("Assigned",pos,IntSet(1,4),ts,true); } { TupleSet ts(1); ts.add({1}).add({2}).add({3}).finalize(); (void) new TupleSetTest("Single",pos,IntSet(-4,4),ts,true); } { int m = Gecode::Int::Limits::min; TupleSet ts(3); ts.add({m+0,m+1,m+2}).add({m+4,m+1,m+3}) .add({m+2,m+3,m+0}).add({m+2,m+3,m+0}) .add({m+1,m+2,m+5}).add({m+2,m+3,m+0}) .add({m+3,m+6,m+5}).finalize(); (void) new TupleSetTest("Min",pos,IntSet(m,m+7),ts,true); } { int M = Gecode::Int::Limits::max; TupleSet ts(3); ts.add({M-0,M-1,M-2}).add({M-4,M-1,M-3}) .add({M-2,M-3,M-0}).add({M-2,M-3,M-0}) .add({M-1,M-2,M-5}).add({M-2,M-3,M-0}) .add({M-3,M-6,M-5}).finalize(); (void) new TupleSetTest("Max",pos,IntSet(M-7,M),ts,true); } { int m = Gecode::Int::Limits::min; int M = Gecode::Int::Limits::max; TupleSet ts(3); ts.add({M-0,m+1,M-2}).add({m+4,M-1,M-3}) .add({m+2,M-3,m+0}).add({M-2,M-3,M-0}) .finalize(); (void) new TupleSetTest("MinMax",pos, IntSet(IntArgs({m,m+1,m+4,M-3,M-2,M})), ts,true); } { TupleSet ts(7); for (int i = 0; i < 10000; i++) { IntArgs tuple(7); for (int j = 0; j < 7; j++) { tuple[j] = rand(j+1); } ts.add(tuple); } ts.finalize(); (void) new RandomTupleSetTest("Triangle",pos,IntSet(0,6),ts); } { for (int i = 0; i <= 64*6; i+=32) (void) new TupleSetTestSize(i, pos, rand); } { (void) new RandomTupleSetTest("Rand(10,-1,2)", pos, IntSet(-1,2), randomTupleSet(10, -1, 2, 0.05, rand)); (void) new RandomTupleSetTest("Rand(5,-10,10)", pos, IntSet(-10,10), randomTupleSet(5, -10, 10, 0.05, rand)); } { TupleSet t(5); CpltAssignment ass(4, IntSet(1, 4)); while (ass.has_more()) { IntArgs tuple(5); tuple[4] = 1; for (int i = 4; i--; ) tuple[i] = ass[i]; t.add(tuple); ass.next(rand); } t.add({2,2,4,3,4}); t.finalize(); (void) new TupleSetTest("FewLast",pos,IntSet(1,4),t,false); } { TupleSet t(4); CpltAssignment ass(4, IntSet(1, 6)); while (ass.has_more()) { t.add({ass[0],0,ass[1],ass[2]}); ass.next(rand); } t.add({2,-1,3,4}); t.finalize(); (void) new TupleSetTest("FewMiddle",pos,IntSet(-1,6),t,false); } { TupleSet t(10); CpltAssignment ass(9, IntSet(1, 4)); while (ass.has_more()) { if (rand(100) <= 0.25*100) { IntArgs tuple(10); tuple[0] = 2; for (int i = 9; i--; ) tuple[i+1] = ass[i]; t.add(tuple); } ass.next(rand); } t.add({1,1,1,1,1,1,1,1,1,1}); t.add({1,2,3,4,4,2,1,2,3,3}); t.finalize(); (void) new RandomTupleSetTest("FewHuge",pos,IntSet(1,4),t); } (void) new TupleSetBase(pos); (void) new TupleSetLarge(0.05,pos); (void) new TupleSetBool(0.3,pos); } } };
Create c;
RegSimpleA ra; RegSimpleB rb; RegSimpleC rc;
RegDistinct rd;
RegRoland rr1(1); RegRoland rr2(2); RegRoland rr3(3); RegRoland rr4(4);
RegSharedA rsa; RegSharedB rsb; RegSharedC rsc; RegSharedD rsd;
RegEmptyDFA redfa; RegEmptyREG rereg;
RegOpt ro0(CHAR_MAX-1); RegOpt ro1(CHAR_MAX); RegOpt ro2(static_cast<int>(UCHAR_MAX-1)); RegOpt ro3(static_cast<int>(UCHAR_MAX)); RegOpt ro4(SHRT_MAX-1); RegOpt ro5(SHRT_MAX); RegOpt ro6(static_cast<int>(USHRT_MAX-1)); RegOpt ro7(static_cast<int>(USHRT_MAX)); //@}
}}}
// STATISTICS: test-int