rel-op-const.cpp
Go to the documentation of this file.
/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
/*
* Main authors:
* Guido Tack <tack@gecode.org>
*
* Copyright:
* Guido Tack, 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/set.hh"
using namespace Gecode;
namespace Test { namespace Set {
namespace RelOpConst {
static IntSet ds_33(-3,3);
static IntSet ds_22(-2,2);
static IntSet ds_12(-1,2);
static IntSet iss[] = {IntSet(-1,1), IntSet(-4,-4), IntSet(0,2)};
class RelSIS : public SetTest {
private:
IntSet is;
Gecode::SetOpType sot;
Gecode::SetRelType srt;
bool inverse;
template<class I, class J>
bool
sol(I& i, J& j) const {
switch (srt) {
case SRT_EQ: return Iter::Ranges::equal(i,j);
case SRT_NQ: return !Iter::Ranges::equal(i,j);
case SRT_SUB: return Iter::Ranges::subset(i,j);
case SRT_SUP: return Iter::Ranges::subset(j,i);
case SRT_DISJ:
{
Gecode::Iter::Ranges::Inter<I,J> inter(i,j);
return !inter();
}
case SRT_CMPL:
{
Gecode::Set::RangesCompl<J> jc(j);
return Iter::Ranges::equal(i,jc);
}
default: GECODE_NEVER;
}
return false;
}
public:
RelSIS(Gecode::SetOpType sot0, Gecode::SetRelType srt0,
int intSet, bool inverse0)
: SetTest("RelOp::ConstSIS::"+str(sot0)+"::"+str(srt0)+"::"+
str(intSet)+(inverse0 ? "i" :""),2,ds_22,false)
, is(iss[intSet]), sot(sot0), srt(srt0), inverse(inverse0) {}
bool solution(const SetAssignment& x) const {
IntSetRanges isr(is);
CountableSetRanges xr0(x.lub, x[0]);
CountableSetRanges xr1(x.lub, x[1]);
switch (sot) {
case SOT_UNION:
{
Iter::Ranges::Union<IntSetRanges, CountableSetRanges>
u(isr, xr0);
return sol(u,xr1);
}
break;
case SOT_DUNION:
{
Iter::Ranges::Inter<IntSetRanges, CountableSetRanges>
inter(isr, xr0);
if (inter())
return false;
Iter::Ranges::Union<IntSetRanges, CountableSetRanges>
u(isr,xr0);
return sol(u,xr1);
}
break;
case SOT_INTER:
{
Iter::Ranges::Inter<IntSetRanges, CountableSetRanges>
u(isr,xr0);
return sol(u,xr1);
}
break;
case SOT_MINUS:
{
if (!inverse) {
Iter::Ranges::Diff<IntSetRanges, CountableSetRanges>
u(isr,xr0);
return sol(u,xr1);
} else {
Iter::Ranges::Diff<CountableSetRanges, IntSetRanges>
u(xr0,isr);
return sol(u,xr1);
}
}
break;
default: GECODE_NEVER;
}
GECODE_NEVER;
return false;
}
void post(Space& home, SetVarArray& x, IntVarArray&) {
if (!inverse)
Gecode::rel(home, is, sot, x[0], srt, x[1]);
else
Gecode::rel(home, x[0], sot, is, srt, x[1]);
}
};
class RelSSI : public SetTest {
private:
IntSet is;
Gecode::SetOpType sot;
Gecode::SetRelType srt;
template<class I, class J>
bool
sol(I& i, J& j) const {
switch (srt) {
case SRT_EQ: return Iter::Ranges::equal(i,j);
case SRT_NQ: return !Iter::Ranges::equal(i,j);
case SRT_SUB: return Iter::Ranges::subset(i,j);
case SRT_SUP: return Iter::Ranges::subset(j,i);
case SRT_DISJ:
{
Gecode::Iter::Ranges::Inter<I,J> inter(i,j);
return !inter();
}
case SRT_CMPL:
{
Gecode::Set::RangesCompl<J> jc(j);
return Iter::Ranges::equal(i,jc);
}
default: GECODE_NEVER;
}
GECODE_NEVER;
return false;
}
public:
RelSSI(Gecode::SetOpType sot0, Gecode::SetRelType srt0,
int intSet)
: SetTest("RelOp::ConstSSI::"+str(sot0)+"::"+str(srt0)+"::"+
str(intSet),2,ds_22,false)
, is(iss[intSet]), sot(sot0), srt(srt0) {}
bool solution(const SetAssignment& x) const {
CountableSetRanges xr0(x.lub, x[0]);
CountableSetRanges xr1(x.lub, x[1]);
IntSetRanges isr(is);
switch (sot) {
case SOT_UNION:
{
Iter::Ranges::Union<CountableSetRanges, CountableSetRanges>
u(xr0, xr1);
return sol(u,isr);
}
break;
case SOT_DUNION:
{
Iter::Ranges::Inter<CountableSetRanges, CountableSetRanges>
inter(xr0, xr1);
if (inter())
return false;
Iter::Ranges::Union<CountableSetRanges, CountableSetRanges>
u(xr0, xr1);
return sol(u,isr);
}
break;
case SOT_INTER:
{
Iter::Ranges::Inter<CountableSetRanges, CountableSetRanges>
u(xr0,xr1);
return sol(u,isr);
}
break;
case SOT_MINUS:
{
Iter::Ranges::Diff<CountableSetRanges, CountableSetRanges>
u(xr0,xr1);
return sol(u,isr);
}
break;
default: GECODE_NEVER;
}
GECODE_NEVER;
return false;
}
void post(Space& home, SetVarArray& x, IntVarArray&) {
Gecode::rel(home, x[0], sot, x[1], srt, is);
}
};
class RelISI : public SetTest {
private:
IntSet is0;
IntSet is1;
Gecode::SetOpType sot;
Gecode::SetRelType srt;
bool inverse;
template<class I, class J>
bool
sol(I& i, J& j) const {
switch (srt) {
case SRT_EQ: return Iter::Ranges::equal(i,j);
case SRT_NQ: return !Iter::Ranges::equal(i,j);
case SRT_SUB: return Iter::Ranges::subset(i,j);
case SRT_SUP: return Iter::Ranges::subset(j,i);
case SRT_DISJ:
{
Gecode::Iter::Ranges::Inter<I,J> inter(i,j);
return !inter();
}
case SRT_CMPL:
{
Gecode::Set::RangesCompl<J> jc(j);
return Iter::Ranges::equal(i,jc);
}
default: GECODE_NEVER;
}
GECODE_NEVER;
return false;
}
public:
RelISI(Gecode::SetOpType sot0, Gecode::SetRelType srt0,
int intSet0, int intSet1, bool inverse0)
: SetTest("RelOp::ConstISI::"+str(sot0)+"::"+str(srt0)+"::"+
str(intSet0)+"::"+str(intSet1)+
(inverse0 ? "i" : ""),1,ds_33,false)
, is0(iss[intSet0]), is1(iss[intSet1]), sot(sot0), srt(srt0)
, inverse(inverse0) {}
bool solution(const SetAssignment& x) const {
CountableSetRanges xr0(x.lub, x[0]);
IntSetRanges isr0(is0);
IntSetRanges isr1(is1);
switch (sot) {
case SOT_UNION:
{
Iter::Ranges::Union<IntSetRanges, CountableSetRanges>
u(isr0, xr0);
return sol(u,isr1);
}
break;
case SOT_DUNION:
{
Iter::Ranges::Inter<IntSetRanges, CountableSetRanges>
inter(isr0, xr0);
if (inter())
return false;
Iter::Ranges::Union<IntSetRanges, CountableSetRanges>
u(isr0, xr0);
return sol(u,isr1);
}
break;
case SOT_INTER:
{
Iter::Ranges::Inter<IntSetRanges, CountableSetRanges>
u(isr0,xr0);
return sol(u,isr1);
}
break;
case SOT_MINUS:
{
if (!inverse) {
Iter::Ranges::Diff<IntSetRanges, CountableSetRanges>
u(isr0,xr0);
return sol(u,isr1);
} else {
Iter::Ranges::Diff<CountableSetRanges, IntSetRanges>
u(xr0,isr0);
return sol(u,isr1);
}
}
break;
default: GECODE_NEVER;
}
GECODE_NEVER;
return false;
}
void post(Space& home, SetVarArray& x, IntVarArray&) {
if (!inverse)
Gecode::rel(home, is0, sot, x[0], srt, is1);
else
Gecode::rel(home, x[0], sot, is0, srt, is1);
}
};
class Create {
public:
Create(void) {
using namespace Gecode;
for (SetRelTypes srts; srts(); ++srts) {
for (SetOpTypes sots; sots(); ++sots) {
for (int i=0; i<=2; i++) {
(void) new RelSIS(sots.sot(),srts.srt(),i,false);
(void) new RelSIS(sots.sot(),srts.srt(),i,true);
(void) new RelSSI(sots.sot(),srts.srt(),i);
(void) new RelISI(sots.sot(),srts.srt(),i,0,false);
(void) new RelISI(sots.sot(),srts.srt(),i,1,false);
(void) new RelISI(sots.sot(),srts.srt(),i,2,false);
(void) new RelISI(sots.sot(),srts.srt(),i,0,true);
(void) new RelISI(sots.sot(),srts.srt(),i,1,true);
(void) new RelISI(sots.sot(),srts.srt(),i,2,true);
}
}
}
}
};
Create c;
}}}
// STATISTICS: test-set
Gecode::IntSetRanges
Range iterator for integer sets.
Definition int.hh:292
Gecode::IntSet
Integer sets.
Definition int.hh:174
Gecode::IntVarArray
Integer variable array.
Definition int.hh:763
Gecode::Iter::Ranges::Diff
Range iterator for computing set difference.
Definition ranges-diff.hpp:43
Gecode::Iter::Ranges::Inter
Range iterator for computing intersection (binary).
Definition ranges-inter.hpp:44
Gecode::Iter::Ranges::Union
Range iterator for computing union (binary).
Definition ranges-union.hpp:44
Gecode::SetVarArray
Set variable array
Definition set.hh:570
Gecode::Set::RangesCompl
A complement iterator spezialized for the BndSet limits.
Definition var-imp.hpp:293
Gecode::Space
Computation spaces.
Definition core.hpp:1742
Test::Set::CountableSetRanges
Range iterator producing subsets of an IntSet.
Definition set.hh:99
Test::Set::RelOpConst::Create
Help class to create and register tests.
Definition rel-op-const.cpp:340
Test::Set::RelOpConst::Create::Create
Create(void)
Perform creation and registration.
Definition rel-op-const.cpp:343
Test::Set::RelOpConst::RelISI
Test for set relation constraint with constants
Definition rel-op-const.cpp:240
Test::Set::RelOpConst::RelISI::RelISI
RelISI(Gecode::SetOpType sot0, Gecode::SetRelType srt0, int intSet0, int intSet1, bool inverse0)
Create and register test.
Definition rel-op-const.cpp:274
Test::Set::RelOpConst::RelISI::solution
bool solution(const SetAssignment &x) const
Test whether x is solution
Definition rel-op-const.cpp:282
Test::Set::RelOpConst::RelISI::post
void post(Space &home, SetVarArray &x, IntVarArray &)
Post constraint on x.
Definition rel-op-const.cpp:331
Test::Set::RelOpConst::RelSIS
Test for set relation constraint with constants
Definition rel-op-const.cpp:56
Test::Set::RelOpConst::RelSIS::RelSIS
RelSIS(Gecode::SetOpType sot0, Gecode::SetRelType srt0, int intSet, bool inverse0)
Create and register test.
Definition rel-op-const.cpp:88
Test::Set::RelOpConst::RelSIS::solution
bool solution(const SetAssignment &x) const
Test whether x is solution
Definition rel-op-const.cpp:94
Test::Set::RelOpConst::RelSIS::post
void post(Space &home, SetVarArray &x, IntVarArray &)
Post constraint on x.
Definition rel-op-const.cpp:144
Test::Set::RelOpConst::RelSSI
Test for set relation constraint with constants
Definition rel-op-const.cpp:153
Test::Set::RelOpConst::RelSSI::solution
bool solution(const SetAssignment &x) const
Test whether x is solution
Definition rel-op-const.cpp:191
Test::Set::RelOpConst::RelSSI::RelSSI
RelSSI(Gecode::SetOpType sot0, Gecode::SetRelType srt0, int intSet)
Create and register test.
Definition rel-op-const.cpp:185
Test::Set::RelOpConst::RelSSI::post
void post(Space &home, SetVarArray &x, IntVarArray &)
Post constraint on x.
Definition rel-op-const.cpp:234
Test::Set::SetAssignment
Generate all set assignments.
Definition set.hh:142
Test::Set::SetAssignment::lub
Gecode::IntSet lub
The common superset for all domains.
Definition set.hh:154
Test::Set::SetOpTypes
Iterator for Boolean operation types.
Definition set.hh:352
Test::Set::SetRelTypes
Iterator for set relation types.
Definition set.hh:334
Test::Set::SetTest::str
static std::string str(Gecode::SetRelType srt)
Map set relation to string.
Definition set.hpp:46
Test::Set::SetTest::SetTest
SetTest(const std::string &s, int a, const Gecode::IntSet &d, bool r=false, int w=0)
Constructor.
Definition set.hh:304
Gecode::rel
void rel(Home home, FloatVar x0, FloatRelType frt, FloatVar x1)
Post propagator for .
Definition rel.cpp:68
Gecode::SetOpType
SetOpType
Common operations for sets.
Definition set.hh:660
Gecode::SetRelType
SetRelType
Common relation types for sets.
Definition set.hh:643
Gecode::SOT_MINUS
@ SOT_MINUS
Difference.
Definition set.hh:664
Gecode::SOT_DUNION
@ SOT_DUNION
Disjoint union.
Definition set.hh:662
Gecode::SOT_UNION
@ SOT_UNION
Union.
Definition set.hh:661
Gecode::SOT_INTER
@ SOT_INTER
Intersection
Definition set.hh:663
Gecode::SRT_CMPL
@ SRT_CMPL
Complement.
Definition set.hh:649
Gecode::SRT_NQ
@ SRT_NQ
Disequality ( ).
Definition set.hh:645
Gecode::SRT_EQ
@ SRT_EQ
Equality ( ).
Definition set.hh:644
Gecode::SRT_SUP
@ SRT_SUP
Superset ( ).
Definition set.hh:647
Gecode::SRT_DISJ
@ SRT_DISJ
Disjoint ( ).
Definition set.hh:648
Gecode::SRT_SUB
@ SRT_SUB
Subset ( ).
Definition set.hh:646
Gecode::Iter::Ranges::subset
bool subset(I &i, J &j)
Check whether range iterator i is subset of range iterator j.
Definition ranges-operations.hpp:97
Gecode::Iter::Ranges::equal
bool equal(I &i, J &j)
Check whether range iterators i and j are equal.
Definition ranges-operations.hpp:84
Gecode
Gecode toplevel namespace
Gecode::inter
SetExpr inter(const SetVarArgs &)
Intersection of set variables.
Definition set-expr.cpp:696
Test::Set::RelOpConst
Tests for relation/operation constraints with constants
Definition rel-op-const.cpp:41
Test::Set::RelOpConst::c
Create c
Definition rel-op-const.cpp:363
Test::Set
Testing finite sets.
Definition set.cpp:42
Test
General test support.
Definition afc.cpp:39
GECODE_NEVER
#define GECODE_NEVER
Assert that this command is never executed.
Definition macros.hpp:56
set.hh