void
circuit(Home home, const IntVarArgs& x, IntConLevel icl) {
if (x.same(home))
throw Int::ArgumentSame("Graph::circuit");
if (x.size() == 0)
throw Int::TooFewArguments("Graph::circuit");
if (home.failed()) return;
ViewArray<Int::IntView> xv(home,x);
if (icl == ICL_DOM) {
GECODE_ES_FAIL(Graph::Circuit::Dom<Int::IntView>::post(home,xv));
} else {
GECODE_ES_FAIL(Graph::Circuit::Val<Int::IntView>::post(home,xv));
}
}
forceinline void
post_nary(Home home,
ViewArray<View>& x, ViewArray<View>& y, FloatRelType frt,
FloatVal c) {
switch (frt) {
case FRT_EQ:
GECODE_ES_FAIL((Eq<View,View >::post(home,x,y,c)));
break;
case FRT_LQ:
GECODE_ES_FAIL((Lq<View,View >::post(home,x,y,c)));
break;
default: GECODE_NEVER;
}
}
void
wait(Home home, const BoolVarArgs& x, void (*c)(Space& home),
IntConLevel) {
if (home.failed()) return;
ViewArray<Int::BoolView> xv(home,x);
GECODE_ES_FAIL(Kernel::NaryWait<Int::BoolView>::post(home,xv,c));
}
void
when(Home home, BoolVar x,
void (*t)(Space& home), void (*e)(Space& home),
IntConLevel) {
if (home.failed()) return;
GECODE_ES_FAIL(Int::Exec::When::post(home,x,t,e));
}
void dependencies(Gecode::Space& home, MPG::CPRelVar installation, MPG::CPRelVar dependencies) {
if (home.failed()) return;
MPG::CPRel::CPRelView inst(installation);
MPG::CPRel::CPRelView deps(dependencies);
GECODE_ES_FAIL((Dependencies::post(home,inst,deps)));
}
void
channel(Home home, const BoolVarArgs& x, SetVar y) {
if (home.failed()) return;
ViewArray<Int::BoolView> xv(home,x);
GECODE_ES_FAIL((Set::Int::ChannelBool<Set::SetView>
::post(home,xv,y)));
}
void
sequence(Home home, const SetVarArgs& xa) {
if (xa.size()==0)
throw TooFewArguments("Set::seq");
if (home.failed()) return;
ViewArray<SetView> x(home,xa);
GECODE_ES_FAIL(Sequence::Seq::post(home, x));
}
void
atmostOne(Home home, const SetVarArgs& xa, unsigned int c) {
Set::Limits::check(c, "Set::atmostOne");
if (home.failed()) return;
if (xa.size() < 2)
return;
ViewArray<SetView> x(home,xa);
GECODE_ES_FAIL(Distinct::AtmostOne::post(home, x, c));
}
void
max(Home home, SetVar s, IntVar x, Reify r){
GECODE_POST;
switch (r.mode()) {
case RM_EQV:
GECODE_ES_FAIL((Set::Int::ReMaxElement<Set::SetView,RM_EQV>
::post(home,s,x,r.var())));
break;
case RM_IMP:
GECODE_ES_FAIL((Set::Int::ReMaxElement<Set::SetView,RM_IMP>
::post(home,s,x,r.var())));
break;
case RM_PMI:
GECODE_ES_FAIL((Set::Int::ReMaxElement<Set::SetView,RM_PMI>
::post(home,s,x,r.var())));
break;
default: throw Gecode::Int::UnknownReifyMode("Set::max");
}
}
void
channel(Home home, const IntVarArgs& x, const SetVarArgs& y) {
if (home.failed()) return;
ViewArray<Int::CachedView<Int::IntView> > xa(home,x.size());
for (int i=x.size(); i--;)
new (&xa[i]) Int::CachedView<Int::IntView>(x[i]);
ViewArray<Set::CachedView<Set::SetView> > ya(home,y.size());
for (int i=y.size(); i--;)
new (&ya[i]) Set::CachedView<Set::SetView>(y[i]);
GECODE_ES_FAIL((Set::Int::ChannelInt<Set::SetView>::post(home,xa,ya)));
}
forceinline void
rel_sub(Home home, View0 x0, SetOpType op, View1 x1, View2 x2) {
switch(op) {
case SOT_DUNION:
{
EmptyView emptyset;
GECODE_ES_FAIL((SuperOfInter<View0,View1,EmptyView>
::post(home, x0, x1, emptyset)));
// fall through to SOT_UNION
}
case SOT_UNION:
{
SetVar tmp(home);
GECODE_ES_FAIL(
(Rel::Subset<SetView,View2>::post(home,tmp,x2)));
GECODE_ES_FAIL(
(Union<View0,View1,SetView>
::post(home, x0, x1, tmp)));
}
break;
case SOT_INTER:
{
GECODE_ES_FAIL((SuperOfInter<View0,View1,View2>
::post(home, x0,x1,x2)));
}
break;
case SOT_MINUS:
{
ComplementView<View1> cx1(x1);
GECODE_ES_FAIL(
(SuperOfInter<View0,
ComplementView<View1>,View2>
::post(home,x0,cx1,x2)));
}
break;
}
}
void
rel(Home home, SetVar s, IntRelType r, IntVar x) {
GECODE_POST;
switch (r) {
case IRT_EQ:
{
Gecode::Int::IntView xv(x);
Set::SingletonView xsingle(xv);
GECODE_ES_FAIL(
(Set::Rel::Eq<Set::SetView,Set::SingletonView>
::post(home,s,xsingle)));
}
break;
case IRT_NQ:
{
Gecode::Set::SetView sv(s);
GECODE_ME_FAIL( sv.cardMin(home, 1));
Gecode::Int::IntView xv(x);
Set::SingletonView xsingle(xv);
GECODE_ES_FAIL(
(Set::Rel::NoSubset<Set::SingletonView,Set::SetView>
::post(home,xsingle,sv)));
}
break;
case IRT_LQ:
{
IntVar tmp(home, Int::Limits::min, Int::Limits::max);
rel(home, tmp, IRT_LQ, x);
GECODE_ES_FAIL(Set::Int::MaxElement<Set::SetView>::post(home,s,tmp));
}
break;
case IRT_LE:
{
IntVar tmp(home, Int::Limits::min, Int::Limits::max);
rel(home, tmp, IRT_LE, x);
GECODE_ES_FAIL(Set::Int::MaxElement<Set::SetView>::post(home,s,tmp));
}
break;
case IRT_GQ:
{
IntVar tmp(home, Int::Limits::min, Int::Limits::max);
rel(home, tmp, IRT_GQ, x);
GECODE_ES_FAIL(Set::Int::MinElement<Set::SetView>::post(home,s,tmp));
}
break;
case IRT_GR:
{
IntVar tmp(home, Int::Limits::min, Int::Limits::max);
rel(home, tmp, IRT_GR, x);
GECODE_ES_FAIL(Set::Int::MinElement<Set::SetView>::post(home,s,tmp));
}
break;
default:
throw Int::UnknownRelation("Set::rel");
}
}
forceinline void
rel_op_post_nocompl(Home home, View0 x, SetOpType op, View1 y,
SetRelType r, View2 z) {
if (home.failed()) return;
switch(r) {
case SRT_EQ:
rel_eq<View0,View1,View2>(home, x, op, y, z);
break;
case SRT_NQ:
{
SetVar tmp(home);
GECODE_ES_FAIL(
(Rel::Distinct<SetView,View2>
::post(home,tmp,z)));
rel_eq<View0,View1,SetView>(home, x, op, y, tmp);
}
break;
case SRT_SUB:
rel_sub<View0,View1,View2>(home, x, op, y, z);
break;
case SRT_SUP:
rel_sup<View0,View1,View2>(home, x, op, y, z);
break;
case SRT_DISJ:
{
SetVar tmp(home);
EmptyView emptyset;
GECODE_ES_FAIL((SuperOfInter<View2,SetView,EmptyView>
::post(home, z, tmp, emptyset)));
rel_eq<View0,View1,SetView>(home, x, op, y, tmp);
}
break;
default:
GECODE_NEVER;
}
}
void
notMax(Home home, SetVar s, IntVar x){
if (home.failed()) return;
GECODE_ES_FAIL(Set::Int::NotMaxElement<Set::SetView>::post(home,s,x));
}
void
min(Home home, SetVar s, IntVar x){
GECODE_POST;
GECODE_ES_FAIL(Set::Int::MinElement<Set::SetView>::post(home,s,x));
}
void
notMax(Home home, SetVar s, IntVar x){
GECODE_POST;
GECODE_ES_FAIL(Set::Int::NotMaxElement<Set::SetView>::post(home,s,x));
}
void
unshare(Home home, BoolVarArgs& x, IntConLevel) {
if (home.failed()) return;
GECODE_ES_FAIL(Int::Unshare::unshare<BoolVar>(home,x,ICL_DEF));
}
void
unshare(Home home, IntVarArgs& x, IntConLevel icl) {
if (home.failed()) return;
GECODE_ES_FAIL(Int::Unshare::unshare<IntVar>(home,x,icl));
}
void
multibinpacking(Home home,
int n, int m, int k,
const IntVarArgs& y,
const IntVarArgs& x,
const IntSharedArray& D,
const IntSharedArray& B,
IntConLevel)
{
/// Check input sizes
if (n*k != D.size() )
throw ArgumentSizeMismatch("Int::multibinpacking");
if (k != B.size() )
throw ArgumentSizeMismatch("Int::multibinpacking");
if (n != x.size() )
throw ArgumentSizeMismatch("Int::multibinpacking");
if (m*k != y.size() )
throw ArgumentSizeMismatch("Int::multibinpacking");
for (int i=B.size(); i--; )
Limits::nonnegative(B[i],"Int::multibinpacking");
if (home.failed()) return;
/// Post first each single binpacking constraint
/// Capacity constraint for each dimension
for ( int j = 0; j < m; ++j )
for ( int l = 0; l < k; ++l ) {
IntView yi(y[j*k+l]);
GECODE_ME_FAIL(yi.lq(home,B[l]));
}
/// Post a binpacking constraints for each dimension
for ( int l = 0; l < k; ++l ) {
ViewArray<OffsetView> yv(home,m);
for (int j=m; j--; )
yv[j] = OffsetView(y[j*k+l],0);
ViewArray<BinPacking::Item> xs(home,x.size());
for (int i=xs.size(); i--; )
xs[i] = BinPacking::Item(x[i],D[i*k+l]);
Support::quicksort(&xs[0], xs.size());
GECODE_ES_FAIL(Int::BinPacking::Pack::post(home,yv,xs));
}
/// Clique Finding and Alldifferent posting
{
/// Firt construct the conflict graph
graph_t* g = graph_new(n);
for ( int a = 0; a < n-1; ++a ) {
for ( int b = a+1; b < n; ++b ) {
int v = a; /// The variable with smaller domain
int w = b;
unsigned int nl = 0;
if ( x[a].size() > x[b].size() ) {
v = b;
w = a;
}
IntVarValues i(x[v]);
IntVarValues j(x[w]);
while ( i() ) {
if ( i.val() != j.val() ) {
if ( i.val() < j.val() )
break;
else
++i;
} else {
for ( int l = 0; l < k; ++l )
if ( D[a*k+l] + D[b*k+l] > B[l] ) {
nl++;
break;
}
++i; ++j;
}
}
if ( nl >= x[v].size() )
GRAPH_ADD_EDGE(g,a,b);
}
}
/// Consitency cheking: look for the maximum clique
clique_options* opts;
opts = (clique_options*) malloc (sizeof(clique_options));
opts->time_function=NULL;
opts->reorder_function=reorder_by_default;
opts->reorder_map=NULL;
opts->user_function=NULL;
opts->user_data=NULL;
opts->clique_list=NULL;
opts->clique_list_length=0;
set_t s;
s = clique_find_single ( g, 0, 0, TRUE, opts);
if ( s != NULL ) {
if ( set_size(s) > m ) {
set_free(s);
free(opts);
graph_free(g);
GECODE_ES_FAIL(ES_FAILED);
}
if ( true ) { //option == 1 ) { FIXING
for ( int a = 0, j = 0; a < n; ++a ) {
if ( SET_CONTAINS_FAST(s,a) ) {
assert( x[a].in(j) );
IntView xi(x[a]);
GECODE_ME_FAIL(xi.eq(home,j++));
}
}
}
}
if ( s!=NULL )
set_free(s);
/// List every maximal clique in the conflict graph
opts->user_function=record_clique_func;
clique_find_all ( g, 2, 0, TRUE, opts);
for ( int c = 0; c < clique_count; c++ ) {
ViewArray<IntView> xv(home, set_size(clique_list[c]));
for ( int a = 0, idx = 0; a < n; ++a )
if ( SET_CONTAINS_FAST(clique_list[c],a) )
xv[idx++] = x[a];
GECODE_ES_FAIL(Distinct::Dom<IntView>::post(home,xv));
set_free(clique_list[c]);
}
free(opts);
graph_free(g);
}
}
void
wait(Home home, BoolVar x, void (*c)(Space& home),
IntConLevel) {
if (home.failed()) return;
GECODE_ES_FAIL(Kernel::UnaryWait<Int::BoolView>::post(home,x,c));
}
void
max(Home home, SetVar s, IntVar x, BoolVar b){
if (home.failed()) return;
GECODE_ES_FAIL(
Set::Int::ReMaxElement<Set::SetView>::post(home,s,x,b));
}
void
channelSorted(Home home, const IntVarArgs& x, SetVar y) {
if (home.failed()) return;
ViewArray<IntView> xa(home,x);
GECODE_ES_FAIL(Set::Int::Match<Set::SetView>::post(home,y,xa));
}
void
sequence(Home home, const SetVarArgs& xa, SetVar y) {
if (home.failed()) return;
ViewArray<SetView> x(home,xa);
GECODE_ES_FAIL(Sequence::SeqU::post(home, x,y));
}
void
wait(Home home, FloatVar x, void (*c)(Space& home)) {
if (home.failed()) return;
GECODE_ES_FAIL(Kernel::UnaryWait<Float::FloatView>::post(home,x,c));
}
void
wait(Home home, const FloatVarArgs& x, void (*c)(Space& home)) {
if (home.failed()) return;
ViewArray<Float::FloatView> xv(home,x);
GECODE_ES_FAIL(Kernel::NaryWait<Float::FloatView>::post(home,xv,c));
}
void
cardinality(Home home, SetVar s, IntVar x) {
if (home.failed()) return;
GECODE_ES_FAIL(Set::Int::Card<Set::SetView>::post(home,s, x));
}
void weights(Home home, IntSharedArray elements, IntSharedArray weights,
SetVar x, IntVar y) {
GECODE_POST;
GECODE_ES_FAIL(Set::Int::Weights<Set::SetView>::post(home,elements,
weights,x,y));
}
void weights(Home home, IntSharedArray elements, IntSharedArray weights,
SetVar x, IntVar y) {
if (home.failed()) return;
GECODE_ES_FAIL(Set::Int::Weights<Set::SetView>::post(home,elements,
weights,x,y));
}
void
Path::post(Space& home) {
GECODE_ES_FAIL(Meta::NoGoodsProp::post(home,*this));
}
