diff --git a/C/init.c b/C/init.c
index c385c0341..2d878dda4 100755
--- a/C/init.c
+++ b/C/init.c
@@ -1155,6 +1155,14 @@ Yap_InitThread(int new_id)
if (!(new_s = (struct worker_local *)calloc(sizeof(struct worker_local), 1)))
return FALSE;
Yap_local[new_id] = new_s;
+ if (!((REGSTORE *)pthread_getspecific(Yap_yaamregs_key))) {
+ REGSTORE *rs = (REGSTORE *)calloc(sizeof(REGSTORE),1);
+ pthread_setspecific(Yap_yaamregs_key, (const void *)rs);
+ REMOTE_ThreadHandle(new_id).default_yaam_regs = rs;
+ REMOTE_ThreadHandle(new_id).current_yaam_regs = REMOTE_ThreadHandle(new_id).default_yaam_regs;
+ rs->worker_id_ = new_id;
+ rs->worker_local_ = REMOTE(new_id);
+ }
}
InitWorker(new_id);
return TRUE;
diff --git a/C/parser.c b/C/parser.c
index 050e6898e..0b1e30f84 100644
--- a/C/parser.c
+++ b/C/parser.c
@@ -69,8 +69,8 @@ typedef struct jmp_buff_struct {
} JMPBUFF;
static void GNextToken( CACHE_TYPE1 );
-static void checkfor(Term, JMPBUFF * CACHE_TYPE);
-static Term ParseArgs(Atom, Term, JMPBUFF *, Term CACHE_TYPE);
+static void checkfor(wchar_t, JMPBUFF * CACHE_TYPE);
+static Term ParseArgs(Atom, wchar_t, JMPBUFF *, Term CACHE_TYPE);
static Term ParseList(JMPBUFF * CACHE_TYPE);
static Term ParseTerm(int, JMPBUFF * CACHE_TYPE);
@@ -315,16 +315,16 @@ GNextToken( USES_REGS1 )
}
inline static void
-checkfor(Term c, JMPBUFF *FailBuff USES_REGS)
+checkfor(wchar_t c, JMPBUFF *FailBuff USES_REGS)
{
if (LOCAL_tokptr->Tok != Ord(Ponctuation_tok)
- || LOCAL_tokptr->TokInfo != c)
+ || LOCAL_tokptr->TokInfo != (Term)c)
FAIL;
NextToken;
}
static Term
-ParseArgs(Atom a, Term close, JMPBUFF *FailBuff, Term arg1 USES_REGS)
+ParseArgs(Atom a, wchar_t close, JMPBUFF *FailBuff, Term arg1 USES_REGS)
{
int nargs = 0;
Term *p, t;
@@ -405,6 +405,18 @@ ParseArgs(Atom a, Term close, JMPBUFF *FailBuff, Term arg1 USES_REGS)
return t;
}
+static Term MakeAccessor( Term t, Functor f USES_REGS )
+{
+ UInt arity = ArityOfFunctor(FunctorOfTerm(t)), i;
+ Term tf[2], tl= TermNil;
+
+ tf[1] = ArgOfTerm(1, t);
+ for (i = arity; i > 1; i--) {
+ tl = MkPairTerm(ArgOfTerm(i, t), tl);
+ }
+ tf[0] = tl;
+ return Yap_MkApplTerm( f, 2, tf );
+}
static Term
ParseList(JMPBUFF *FailBuff USES_REGS)
@@ -540,7 +552,7 @@ ParseTerm(int prio, JMPBUFF *FailBuff USES_REGS)
}
if (LOCAL_tokptr->Tok == Ord(Ponctuation_tok)
&& Unsigned(LOCAL_tokptr->TokInfo) == 'l')
- t = ParseArgs((Atom) t, (Term)')', FailBuff, 0L PASS_REGS);
+ t = ParseArgs((Atom) t, ')', FailBuff, 0L PASS_REGS);
else
t = MkAtomTerm((Atom)t);
break;
@@ -606,7 +618,7 @@ ParseTerm(int prio, JMPBUFF *FailBuff USES_REGS)
case 'l': /* non solo ( */
NextToken;
t = ParseTerm(1200, FailBuff PASS_REGS);
- checkfor((Term) ')', FailBuff PASS_REGS);
+ checkfor(')', FailBuff PASS_REGS);
break;
case '[':
NextToken;
@@ -617,7 +629,7 @@ ParseTerm(int prio, JMPBUFF *FailBuff USES_REGS)
break;
}
t = ParseList(FailBuff PASS_REGS);
- checkfor((Term) ']', FailBuff PASS_REGS);
+ checkfor(']', FailBuff PASS_REGS);
break;
case '{':
NextToken;
@@ -634,7 +646,7 @@ ParseTerm(int prio, JMPBUFF *FailBuff USES_REGS)
LOCAL_ErrorMessage = "Stack Overflow";
FAIL;
}
- checkfor((Term) '}', FailBuff PASS_REGS);
+ checkfor('}', FailBuff PASS_REGS);
break;
default:
FAIL;
@@ -734,19 +746,21 @@ ParseTerm(int prio, JMPBUFF *FailBuff USES_REGS)
} else if (Unsigned(LOCAL_tokptr->TokInfo) == '(' &&
IsPosfixOp(AtomEmptyBrackets, &opprio, &oplprio PASS_REGS)
&& opprio <= prio && oplprio >= curprio) {
- t = ParseArgs(AtomEmptyBrackets, (Term)')', FailBuff, t PASS_REGS);
+ t = ParseArgs(AtomEmptyBrackets, ')', FailBuff, t PASS_REGS);
curprio = opprio;
continue;
} else if (Unsigned(LOCAL_tokptr->TokInfo) == '[' &&
IsPosfixOp(AtomEmptySquareBrackets, &opprio, &oplprio PASS_REGS)
&& opprio <= prio && oplprio >= curprio) {
- t = ParseArgs(AtomEmptySquareBrackets, (Term)']', FailBuff, t PASS_REGS);
+ t = ParseArgs(AtomEmptySquareBrackets, ']', FailBuff, t PASS_REGS);
+ t = MakeAccessor(t, FunctorEmptySquareBrackets PASS_REGS);
curprio = opprio;
continue;
} else if (Unsigned(LOCAL_tokptr->TokInfo) == '{' &&
IsPosfixOp(AtomEmptyCurlyBrackets, &opprio, &oplprio PASS_REGS)
&& opprio <= prio && oplprio >= curprio) {
- t = ParseArgs(AtomEmptyCurlyBrackets, (Term)'}', FailBuff, t PASS_REGS);
+ t = ParseArgs(AtomEmptyCurlyBrackets, '}', FailBuff, t PASS_REGS);
+ t = MakeAccessor(t, FunctorEmptyCurlyBrackets PASS_REGS);
curprio = opprio;
continue;
}
diff --git a/C/scanner.c b/C/scanner.c
index f51388f8a..b1c1149ef 100644
--- a/C/scanner.c
+++ b/C/scanner.c
@@ -1306,9 +1306,18 @@ Yap_tokenizer(IOSTREAM *inp_stream, int store_comments, Term *tposp)
och = ch;
ch = getchr(inp_stream);
t->TokInfo = och;
- if (t->TokInfo == '(' && !solo_flag) {
- t->TokInfo = 'l';
- solo_flag = TRUE;
+ if (och == '(') {
+ while (chtype(ch) == BS) { ch = getchr(inp_stream); };
+ if (ch == ')') {
+ t->TokInfo = Unsigned(AtomEmptyBrackets);
+ t->Tok = Ord(kind = Name_tok);
+ ch = getchr(inp_stream);
+ solo_flag = FALSE;
+ break;
+ } else if (!solo_flag) {
+ t->TokInfo = 'l';
+ solo_flag = TRUE;
+ }
} else if (och == '[') {
while (chtype(ch) == BS) { ch = getchr(inp_stream); };
if (ch == ']') {
diff --git a/C/threads.c b/C/threads.c
index 29c866060..df5af91cb 100755
--- a/C/threads.c
+++ b/C/threads.c
@@ -94,15 +94,24 @@ store_specs(int new_worker_id, UInt ssize, UInt tsize, UInt sysize, Term *tpgoal
REMOTE_ThreadHandle(new_worker_id).ssize = ssize;
REMOTE_ThreadHandle(new_worker_id).tsize = tsize;
REMOTE_ThreadHandle(new_worker_id).sysize = sysize;
- REMOTE_c_input_stream(new_worker_id) = LOCAL_c_input_stream;
- REMOTE_c_output_stream(new_worker_id) = LOCAL_c_output_stream;
- REMOTE_c_error_stream(new_worker_id) = LOCAL_c_error_stream;
+
+ if ((REGSTORE *)pthread_getspecific(Yap_yaamregs_key)) {
+ REMOTE_c_input_stream(new_worker_id) = LOCAL_c_input_stream;
+ REMOTE_c_output_stream(new_worker_id) = LOCAL_c_output_stream;
+ REMOTE_c_error_stream(new_worker_id) = LOCAL_c_error_stream;
+ } else {
+ // thread is created by a thread that has never run Prolog
+ REMOTE_c_input_stream(new_worker_id) = REMOTE_c_input_stream(0);
+ REMOTE_c_output_stream(new_worker_id) = REMOTE_c_output_stream(0);
+ REMOTE_c_error_stream(new_worker_id) = REMOTE_c_error_stream(0);
+ }
pm = (ssize + tsize)*1024;
if (!(REMOTE_ThreadHandle(new_worker_id).stack_address = malloc(pm))) {
return FALSE;
}
REMOTE_ThreadHandle(new_worker_id).tgoal =
- Yap_StoreTermInDB(Deref(*tpgoal),7);
+ Yap_StoreTermInDB(Deref(*tpgoal), 7);
+
REMOTE_ThreadHandle(new_worker_id).cmod =
CurrentModule;
tdetach = Deref(*tpdetach);
diff --git a/C/write.c b/C/write.c
index 3a1ee7c65..38e3f8c2e 100644
--- a/C/write.c
+++ b/C/write.c
@@ -977,7 +977,16 @@ writeTerm(Term t, int p, int depth, int rinfixarg, struct write_globs *wglb, str
Yap_IsPosfixOp(atom, &op, &lp)) {
Term tleft = ArgOfTerm(1, t);
- int bracket_left =
+ int bracket_left, offset;
+
+ if (Arity != 1) {
+ tleft = ArgOfTerm(1, t);
+ offset = 2;
+ } else {
+ tleft = ArgOfTerm(2, t);
+ offset = 1;
+ }
+ bracket_left =
!IsVarTerm(tleft) &&
IsAtomTerm(tleft) &&
Yap_IsOp(AtomOfTerm(tleft));
@@ -988,7 +997,7 @@ writeTerm(Term t, int p, int depth, int rinfixarg, struct write_globs *wglb, str
if (bracket_left) {
wropen_bracket(wglb, TRUE);
}
- writeTerm(from_pointer(RepAppl(t)+1, &nrwt, wglb), lp, depth + 1, rinfixarg, wglb, &nrwt);
+ writeTerm(from_pointer(RepAppl(t)+offset, &nrwt, wglb), lp, depth + 1, rinfixarg, wglb, &nrwt);
restore_from_write(&nrwt, wglb);
if (bracket_left) {
wrclose_bracket(wglb, TRUE);
@@ -1002,20 +1011,7 @@ writeTerm(Term t, int p, int depth, int rinfixarg, struct write_globs *wglb, str
wrputc('{', wglb->stream);
}
lastw = separator;
- for (op = 2; op <= Arity; ++op) {
- if (op == wglb->MaxArgs) {
- wrputc('.', wglb->stream);
- wrputc('.', wglb->stream);
- wrputc('.', wglb->stream);
- break;
- }
- writeTerm(from_pointer(RepAppl(t)+op, &nrwt, wglb), 999, depth + 1, FALSE, wglb, &nrwt);
- restore_from_write(&nrwt, wglb);
- if (op != Arity) {
- wrputc(',', wglb->stream);
- lastw = separator;
- }
- }
+ write_list(ArgOfTerm(1,t), 0, depth, wglb, rwt);
if (atom == AtomEmptyBrackets) {
wrputc(')', wglb->stream);
} else if (atom == AtomEmptySquareBrackets) {
diff --git a/H/iatoms.h b/H/iatoms.h
index 4e9ad227c..fd5fbb5d6 100644
--- a/H/iatoms.h
+++ b/H/iatoms.h
@@ -382,6 +382,8 @@
FunctorDot7 = Yap_MkFunctor(AtomDot,7);
FunctorDot8 = Yap_MkFunctor(AtomDot,8);
FunctorDot9 = Yap_MkFunctor(AtomDot,9);
+ FunctorEmptySquareBrackets = Yap_MkFunctor(AtomEmptySquareBrackets,2);
+ FunctorEmptyCurlyBrackets = Yap_MkFunctor(AtomEmptyCurlyBrackets,2);
FunctorEq = Yap_MkFunctor(AtomEq,2);
FunctorError = Yap_MkFunctor(AtomError,2);
FunctorEvaluationError = Yap_MkFunctor(AtomEvaluationError,1);
diff --git a/H/ratoms.h b/H/ratoms.h
index 816990b4e..31b466fec 100644
--- a/H/ratoms.h
+++ b/H/ratoms.h
@@ -382,6 +382,8 @@
FunctorDot7 = FuncAdjust(FunctorDot7);
FunctorDot8 = FuncAdjust(FunctorDot8);
FunctorDot9 = FuncAdjust(FunctorDot9);
+ FunctorEmptySquareBrackets = FuncAdjust(FunctorEmptySquareBrackets);
+ FunctorEmptyCurlyBrackets = FuncAdjust(FunctorEmptyCurlyBrackets);
FunctorEq = FuncAdjust(FunctorEq);
FunctorError = FuncAdjust(FunctorError);
FunctorEvaluationError = FuncAdjust(FunctorEvaluationError);
diff --git a/H/tatoms.h b/H/tatoms.h
index 8c8b3998b..2ace62582 100644
--- a/H/tatoms.h
+++ b/H/tatoms.h
@@ -762,6 +762,10 @@
#define FunctorDot8 Yap_heap_regs->FunctorDot8_
Functor FunctorDot9_;
#define FunctorDot9 Yap_heap_regs->FunctorDot9_
+ Functor FunctorEmptySquareBrackets_;
+#define FunctorEmptySquareBrackets Yap_heap_regs->FunctorEmptySquareBrackets_
+ Functor FunctorEmptyCurlyBrackets_;
+#define FunctorEmptyCurlyBrackets Yap_heap_regs->FunctorEmptyCurlyBrackets_
Functor FunctorEq_;
#define FunctorEq Yap_heap_regs->FunctorEq_
Functor FunctorError_;
diff --git a/library/gecode/4.2.0/gecode_yap_auto_generated.yap b/library/gecode/4.2.0/gecode_yap_auto_generated.yap
index 887e81ebf..051cb381e 100644
--- a/library/gecode/4.2.0/gecode_yap_auto_generated.yap
+++ b/library/gecode/4.2.0/gecode_yap_auto_generated.yap
@@ -171,7 +171,7 @@ unary(X0,X1,X2,X3,X4,X5) :-
-> (is_IntArgs(X3,Y3)
-> (is_BoolVarArgs(X4,Y4)
-> (is_IntConLevel(X5,Y5)
- -> gecode_constraint_unary_448(Y0,Y1,Y2,Y3,Y4,Y5)
+ -> gecode_constraint_unary_458(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4,X5),arg=6)))
; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4,X5),arg=5)))
; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4,X5),arg=4)))
@@ -181,7 +181,7 @@ unary(X0,X1,X2,X3,X4,X5) :-
-> (is_IntVarArgs(X3,Y3)
-> (is_BoolVarArgs(X4,Y4)
-> (is_IntConLevel(X5,Y5)
- -> gecode_constraint_unary_444(Y0,Y1,Y2,Y3,Y4,Y5)
+ -> gecode_constraint_unary_454(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4,X5),arg=6)))
; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4,X5),arg=5)))
; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4,X5),arg=4)))
@@ -195,11 +195,11 @@ nvalues(X0,X1,X2,X3,X4) :-
-> (is_IntRelType(X2,Y2)
-> (is_int(X3,Y3)
-> (is_IntConLevel(X4,Y4)
- -> gecode_constraint_nvalues_335(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_nvalues_345(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(nvalues(X0,X1,X2,X3,X4),arg=5)))
; (is_IntVar(X3,Y3)
-> (is_IntConLevel(X4,Y4)
- -> gecode_constraint_nvalues_337(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_nvalues_347(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(nvalues(X0,X1,X2,X3,X4),arg=5)))
; throw(gecode_argument_error(nvalues(X0,X1,X2,X3,X4),arg=4))))
; throw(gecode_argument_error(nvalues(X0,X1,X2,X3,X4),arg=3)))
@@ -207,11 +207,11 @@ nvalues(X0,X1,X2,X3,X4) :-
-> (is_IntRelType(X2,Y2)
-> (is_int(X3,Y3)
-> (is_IntConLevel(X4,Y4)
- -> gecode_constraint_nvalues_331(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_nvalues_341(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(nvalues(X0,X1,X2,X3,X4),arg=5)))
; (is_IntVar(X3,Y3)
-> (is_IntConLevel(X4,Y4)
- -> gecode_constraint_nvalues_333(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_nvalues_343(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(nvalues(X0,X1,X2,X3,X4),arg=5)))
; throw(gecode_argument_error(nvalues(X0,X1,X2,X3,X4),arg=4))))
; throw(gecode_argument_error(nvalues(X0,X1,X2,X3,X4),arg=3)))
@@ -223,25 +223,25 @@ max(X0,X1,X2,X3) :-
-> (is_IntVar(X1,Y1)
-> (is_IntVar(X2,Y2)
-> (is_IntVar(X3,Y3)
- -> gecode_constraint_max_292(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_max_302(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(max(X0,X1,X2,X3),arg=4)))
; throw(gecode_argument_error(max(X0,X1,X2,X3),arg=3)))
; (is_IntVarArgs(X1,Y1)
-> (is_IntVar(X2,Y2)
-> (is_IntConLevel(X3,Y3)
- -> gecode_constraint_max_290(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_max_300(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(max(X0,X1,X2,X3),arg=4)))
; throw(gecode_argument_error(max(X0,X1,X2,X3),arg=3)))
; (is_FloatVar(X1,Y1)
-> (is_FloatVar(X2,Y2)
-> (is_FloatVar(X3,Y3)
- -> gecode_constraint_max_291(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_max_301(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(max(X0,X1,X2,X3),arg=4)))
; throw(gecode_argument_error(max(X0,X1,X2,X3),arg=3)))
; (is_SetVar(X1,Y1)
-> (is_IntVar(X2,Y2)
-> (is_Reify(X3,Y3)
- -> gecode_constraint_max_295(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_max_305(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(max(X0,X1,X2,X3),arg=4)))
; throw(gecode_argument_error(max(X0,X1,X2,X3),arg=3)))
; throw(gecode_argument_error(max(X0,X1,X2,X3),arg=2))))))
@@ -287,7 +287,7 @@ nooverlap(X0,X1,X2,X3,X4) :-
-> (is_IntArgs(X2,Y2)
-> (is_IntVarArgs(X3,Y3)
-> (is_IntArgs(X4,Y4)
- -> gecode_constraint_nooverlap_319(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_nooverlap_329(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4),arg=5)))
; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4),arg=4)))
; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4),arg=3)))
@@ -377,7 +377,7 @@ element(X0,X1,X2,X3) :-
sequence(X0,X1) :-
(is_Space_or_Clause(X0,Y0)
-> (is_SetVarArgs(X1,Y1)
- -> gecode_constraint_sequence_427(Y0,Y1)
+ -> gecode_constraint_sequence_437(Y0,Y1)
; throw(gecode_argument_error(sequence(X0,X1),arg=2)))
; throw(gecode_argument_error(sequence(X0,X1),arg=1))).
@@ -385,7 +385,7 @@ notMax(X0,X1,X2) :-
(is_Space_or_Clause(X0,Y0)
-> (is_SetVar(X1,Y1)
-> (is_IntVar(X2,Y2)
- -> gecode_constraint_notMax_325(Y0,Y1,Y2)
+ -> gecode_constraint_notMax_335(Y0,Y1,Y2)
; throw(gecode_argument_error(notMax(X0,X1,X2),arg=3)))
; throw(gecode_argument_error(notMax(X0,X1,X2),arg=2)))
; throw(gecode_argument_error(notMax(X0,X1,X2),arg=1))).
@@ -396,7 +396,7 @@ ite(X0,X1,X2,X3,X4) :-
-> (is_IntVar(X2,Y2)
-> (is_IntVar(X3,Y3)
-> (is_IntVar(X4,Y4)
- -> gecode_constraint_ite_246(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_ite_256(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(ite(X0,X1,X2,X3,X4),arg=5)))
; throw(gecode_argument_error(ite(X0,X1,X2,X3,X4),arg=4)))
; throw(gecode_argument_error(ite(X0,X1,X2,X3,X4),arg=3)))
@@ -407,7 +407,7 @@ unary(X0,X1,X2) :-
(is_Space_or_Clause(X0,Y0)
-> (is_IntVarArgs(X1,Y1)
-> (is_IntArgs(X2,Y2)
- -> gecode_constraint_unary_441(Y0,Y1,Y2)
+ -> gecode_constraint_unary_451(Y0,Y1,Y2)
; throw(gecode_argument_error(unary(X0,X1,X2),arg=3)))
; throw(gecode_argument_error(unary(X0,X1,X2),arg=2)))
; throw(gecode_argument_error(unary(X0,X1,X2),arg=1))).
@@ -418,7 +418,7 @@ nroot(X0,X1,X2,X3,X4) :-
-> (is_int(X2,Y2)
-> (is_IntVar(X3,Y3)
-> (is_IntConLevel(X4,Y4)
- -> gecode_constraint_nroot_329(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_nroot_339(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(nroot(X0,X1,X2,X3,X4),arg=5)))
; throw(gecode_argument_error(nroot(X0,X1,X2,X3,X4),arg=4)))
; throw(gecode_argument_error(nroot(X0,X1,X2,X3,X4),arg=3)))
@@ -537,9 +537,9 @@ nooverlap(X0,X1,X2,X3,X4,X5,X6,X7) :-
-> (is_IntVarArgs(X5,Y5)
-> (is_IntVarArgs(X6,Y6)
-> (is_BoolVarArgs(X7,Y7)
- -> gecode_constraint_nooverlap_321(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7)
+ -> gecode_constraint_nooverlap_331(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7)
; (is_IntConLevel(X7,Y7)
- -> gecode_constraint_nooverlap_324(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7)
+ -> gecode_constraint_nooverlap_334(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7)
; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6,X7),arg=8))))
; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6,X7),arg=7)))
; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6,X7),arg=6)))
@@ -620,15 +620,15 @@ max(X0,X1,X2) :-
(is_Space_or_Clause(X0,Y0)
-> (is_FloatVarArgs(X1,Y1)
-> (is_FloatVar(X2,Y2)
- -> gecode_constraint_max_288(Y0,Y1,Y2)
+ -> gecode_constraint_max_298(Y0,Y1,Y2)
; throw(gecode_argument_error(max(X0,X1,X2),arg=3)))
; (is_IntVarArgs(X1,Y1)
-> (is_IntVar(X2,Y2)
- -> gecode_constraint_max_289(Y0,Y1,Y2)
+ -> gecode_constraint_max_299(Y0,Y1,Y2)
; throw(gecode_argument_error(max(X0,X1,X2),arg=3)))
; (is_SetVar(X1,Y1)
-> (is_IntVar(X2,Y2)
- -> gecode_constraint_max_294(Y0,Y1,Y2)
+ -> gecode_constraint_max_304(Y0,Y1,Y2)
; throw(gecode_argument_error(max(X0,X1,X2),arg=3)))
; throw(gecode_argument_error(max(X0,X1,X2),arg=2)))))
; throw(gecode_argument_error(max(X0,X1,X2),arg=1))).
@@ -636,9 +636,9 @@ max(X0,X1,X2) :-
unshare(X0,X1) :-
(is_Space_or_Clause(X0,Y0)
-> (is_IntVarArgs(X1,Y1)
- -> gecode_constraint_unshare_453(Y0,Y1)
+ -> gecode_constraint_unshare_463(Y0,Y1)
; (is_BoolVarArgs(X1,Y1)
- -> gecode_constraint_unshare_451(Y0,Y1)
+ -> gecode_constraint_unshare_461(Y0,Y1)
; throw(gecode_argument_error(unshare(X0,X1),arg=2))))
; throw(gecode_argument_error(unshare(X0,X1),arg=1))).
@@ -648,7 +648,7 @@ path(X0,X1,X2,X3,X4) :-
-> (is_IntVarArgs(X2,Y2)
-> (is_IntVar(X3,Y3)
-> (is_IntVar(X4,Y4)
- -> gecode_constraint_path_348(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_path_358(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(path(X0,X1,X2,X3,X4),arg=5)))
; throw(gecode_argument_error(path(X0,X1,X2,X3,X4),arg=4)))
; throw(gecode_argument_error(path(X0,X1,X2,X3,X4),arg=3)))
@@ -656,7 +656,7 @@ path(X0,X1,X2,X3,X4) :-
-> (is_IntVar(X2,Y2)
-> (is_IntVar(X3,Y3)
-> (is_IntConLevel(X4,Y4)
- -> gecode_constraint_path_347(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_path_357(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(path(X0,X1,X2,X3,X4),arg=5)))
; throw(gecode_argument_error(path(X0,X1,X2,X3,X4),arg=4)))
; throw(gecode_argument_error(path(X0,X1,X2,X3,X4),arg=3)))
@@ -709,13 +709,13 @@ mult(X0,X1,X2,X3) :-
-> (is_IntVar(X1,Y1)
-> (is_IntVar(X2,Y2)
-> (is_IntVar(X3,Y3)
- -> gecode_constraint_mult_315(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_mult_325(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(mult(X0,X1,X2,X3),arg=4)))
; throw(gecode_argument_error(mult(X0,X1,X2,X3),arg=3)))
; (is_FloatVar(X1,Y1)
-> (is_FloatVar(X2,Y2)
-> (is_FloatVar(X3,Y3)
- -> gecode_constraint_mult_314(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_mult_324(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(mult(X0,X1,X2,X3),arg=4)))
; throw(gecode_argument_error(mult(X0,X1,X2,X3),arg=3)))
; throw(gecode_argument_error(mult(X0,X1,X2,X3),arg=2))))
@@ -746,7 +746,7 @@ precede(X0,X1,X2,X3,X4) :-
-> (is_int(X2,Y2)
-> (is_int(X3,Y3)
-> (is_IntConLevel(X4,Y4)
- -> gecode_constraint_precede_356(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_precede_366(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(precede(X0,X1,X2,X3,X4),arg=5)))
; throw(gecode_argument_error(precede(X0,X1,X2,X3,X4),arg=4)))
; throw(gecode_argument_error(precede(X0,X1,X2,X3,X4),arg=3)))
@@ -765,17 +765,17 @@ member(X0,X1,X2,X3) :-
-> (is_IntVarArgs(X1,Y1)
-> (is_IntVar(X2,Y2)
-> (is_Reify(X3,Y3)
- -> gecode_constraint_member_302(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_member_312(Y0,Y1,Y2,Y3)
; (is_IntConLevel(X3,Y3)
- -> gecode_constraint_member_301(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_member_311(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(member(X0,X1,X2,X3),arg=4))))
; throw(gecode_argument_error(member(X0,X1,X2,X3),arg=3)))
; (is_BoolVarArgs(X1,Y1)
-> (is_BoolVar(X2,Y2)
-> (is_Reify(X3,Y3)
- -> gecode_constraint_member_298(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_member_308(Y0,Y1,Y2,Y3)
; (is_IntConLevel(X3,Y3)
- -> gecode_constraint_member_297(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_member_307(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(member(X0,X1,X2,X3),arg=4))))
; throw(gecode_argument_error(member(X0,X1,X2,X3),arg=3)))
; throw(gecode_argument_error(member(X0,X1,X2,X3),arg=2))))
@@ -787,7 +787,7 @@ mod(X0,X1,X2,X3,X4) :-
-> (is_IntVar(X2,Y2)
-> (is_IntVar(X3,Y3)
-> (is_IntConLevel(X4,Y4)
- -> gecode_constraint_mod_313(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_mod_323(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(mod(X0,X1,X2,X3,X4),arg=5)))
; throw(gecode_argument_error(mod(X0,X1,X2,X3,X4),arg=4)))
; throw(gecode_argument_error(mod(X0,X1,X2,X3,X4),arg=3)))
@@ -821,30 +821,51 @@ channelSorted(X0,X1,X2) :-
; throw(gecode_argument_error(channelSorted(X0,X1,X2),arg=2)))
; throw(gecode_argument_error(channelSorted(X0,X1,X2),arg=1))).
+extensional(X0,X1,X2,X3,X4) :-
+ (is_Space_or_Clause(X0,Y0)
+ -> (is_IntVarArgs(X1,Y1)
+ -> (is_TupleSet(X2,Y2)
+ -> (is_ExtensionalPropKind(X3,Y3)
+ -> (is_IntConLevel(X4,Y4)
+ -> gecode_constraint_extensional_253(Y0,Y1,Y2,Y3,Y4)
+ ; throw(gecode_argument_error(extensional(X0,X1,X2,X3,X4),arg=5)))
+ ; throw(gecode_argument_error(extensional(X0,X1,X2,X3,X4),arg=4)))
+ ; throw(gecode_argument_error(extensional(X0,X1,X2,X3,X4),arg=3)))
+ ; (is_BoolVarArgs(X1,Y1)
+ -> (is_TupleSet(X2,Y2)
+ -> (is_ExtensionalPropKind(X3,Y3)
+ -> (is_IntConLevel(X4,Y4)
+ -> gecode_constraint_extensional_248(Y0,Y1,Y2,Y3,Y4)
+ ; throw(gecode_argument_error(extensional(X0,X1,X2,X3,X4),arg=5)))
+ ; throw(gecode_argument_error(extensional(X0,X1,X2,X3,X4),arg=4)))
+ ; throw(gecode_argument_error(extensional(X0,X1,X2,X3,X4),arg=3)))
+ ; throw(gecode_argument_error(extensional(X0,X1,X2,X3,X4),arg=2))))
+ ; throw(gecode_argument_error(extensional(X0,X1,X2,X3,X4),arg=1))).
+
linear(X0,X1,X2,X3) :-
(is_Space_or_Clause(X0,Y0)
-> (is_FloatVarArgs(X1,Y1)
-> (is_FloatRelType(X2,Y2)
-> (is_FloatVar(X3,Y3)
- -> gecode_constraint_linear_262(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_linear_272(Y0,Y1,Y2,Y3)
; (is_FloatNum(X3,Y3)
- -> gecode_constraint_linear_260(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_linear_270(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(linear(X0,X1,X2,X3),arg=4))))
; throw(gecode_argument_error(linear(X0,X1,X2,X3),arg=3)))
; (is_BoolVarArgs(X1,Y1)
-> (is_IntRelType(X2,Y2)
-> (is_int(X3,Y3)
- -> gecode_constraint_linear_248(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_linear_258(Y0,Y1,Y2,Y3)
; (is_IntVar(X3,Y3)
- -> gecode_constraint_linear_252(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_linear_262(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(linear(X0,X1,X2,X3),arg=4))))
; throw(gecode_argument_error(linear(X0,X1,X2,X3),arg=3)))
; (is_IntVarArgs(X1,Y1)
-> (is_IntRelType(X2,Y2)
-> (is_int(X3,Y3)
- -> gecode_constraint_linear_280(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_linear_290(Y0,Y1,Y2,Y3)
; (is_IntVar(X3,Y3)
- -> gecode_constraint_linear_284(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_linear_294(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(linear(X0,X1,X2,X3),arg=4))))
; throw(gecode_argument_error(linear(X0,X1,X2,X3),arg=3)))
; throw(gecode_argument_error(linear(X0,X1,X2,X3),arg=2)))))
@@ -863,11 +884,11 @@ rel(X0,X1,X2,X3,X4) :-
-> (is_FloatRelType(X2,Y2)
-> (is_FloatVal(X3,Y3)
-> (is_Reify(X4,Y4)
- -> gecode_constraint_rel_396(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_rel_406(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5)))
; (is_FloatVar(X3,Y3)
-> (is_Reify(X4,Y4)
- -> gecode_constraint_rel_398(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_rel_408(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5)))
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=4))))
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=3)))
@@ -875,13 +896,13 @@ rel(X0,X1,X2,X3,X4) :-
-> (is_SetVarArgs(X2,Y2)
-> (is_IntSet(X3,Y3)
-> (is_SetVar(X4,Y4)
- -> gecode_constraint_rel_412(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_rel_422(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5)))
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=4)))
; (is_IntVarArgs(X2,Y2)
-> (is_IntSet(X3,Y3)
-> (is_SetVar(X4,Y4)
- -> gecode_constraint_rel_410(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_rel_420(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5)))
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=4)))
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=3))))
@@ -889,15 +910,15 @@ rel(X0,X1,X2,X3,X4) :-
-> (is_IntRelType(X2,Y2)
-> (is_int(X3,Y3)
-> (is_IntConLevel(X4,Y4)
- -> gecode_constraint_rel_382(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_rel_392(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5)))
; (is_BoolVarArgs(X3,Y3)
-> (is_IntConLevel(X4,Y4)
- -> gecode_constraint_rel_378(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_rel_388(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5)))
; (is_BoolVar(X3,Y3)
-> (is_IntConLevel(X4,Y4)
- -> gecode_constraint_rel_376(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_rel_386(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5)))
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=4)))))
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=3)))
@@ -905,23 +926,23 @@ rel(X0,X1,X2,X3,X4) :-
-> (is_IntRelType(X2,Y2)
-> (is_int(X3,Y3)
-> (is_Reify(X4,Y4)
- -> gecode_constraint_rel_373(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_rel_383(Y0,Y1,Y2,Y3,Y4)
; (is_IntConLevel(X4,Y4)
- -> gecode_constraint_rel_372(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_rel_382(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5))))
; (is_BoolVar(X3,Y3)
-> (is_Reify(X4,Y4)
- -> gecode_constraint_rel_369(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_rel_379(Y0,Y1,Y2,Y3,Y4)
; (is_IntConLevel(X4,Y4)
- -> gecode_constraint_rel_368(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_rel_378(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5))))
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=4))))
; (is_BoolOpType(X2,Y2)
-> (is_BoolVar(X3,Y3)
-> (is_int(X4,Y4)
- -> gecode_constraint_rel_365(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_rel_375(Y0,Y1,Y2,Y3,Y4)
; (is_BoolVar(X4,Y4)
- -> gecode_constraint_rel_363(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_rel_373(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5))))
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=4)))
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=3))))
@@ -929,15 +950,15 @@ rel(X0,X1,X2,X3,X4) :-
-> (is_IntRelType(X2,Y2)
-> (is_int(X3,Y3)
-> (is_IntConLevel(X4,Y4)
- -> gecode_constraint_rel_392(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_rel_402(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5)))
; (is_IntVar(X3,Y3)
-> (is_IntConLevel(X4,Y4)
- -> gecode_constraint_rel_394(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_rel_404(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5)))
; (is_IntVarArgs(X3,Y3)
-> (is_IntConLevel(X4,Y4)
- -> gecode_constraint_rel_388(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_rel_398(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5)))
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=4)))))
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=3)))
@@ -945,21 +966,21 @@ rel(X0,X1,X2,X3,X4) :-
-> (is_IntRelType(X2,Y2)
-> (is_int(X3,Y3)
-> (is_Reify(X4,Y4)
- -> gecode_constraint_rel_401(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_rel_411(Y0,Y1,Y2,Y3,Y4)
; (is_IntConLevel(X4,Y4)
- -> gecode_constraint_rel_400(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_rel_410(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5))))
; (is_IntVar(X3,Y3)
-> (is_Reify(X4,Y4)
- -> gecode_constraint_rel_405(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_rel_415(Y0,Y1,Y2,Y3,Y4)
; (is_IntConLevel(X4,Y4)
- -> gecode_constraint_rel_404(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_rel_414(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5))))
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=4))))
; (is_SetRelType(X2,Y2)
-> (is_SetVar(X3,Y3)
-> (is_Reify(X4,Y4)
- -> gecode_constraint_rel_409(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_rel_419(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5)))
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=4)))
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=3))))
@@ -967,11 +988,11 @@ rel(X0,X1,X2,X3,X4) :-
-> (is_SetRelType(X2,Y2)
-> (is_IntVar(X3,Y3)
-> (is_Reify(X4,Y4)
- -> gecode_constraint_rel_420(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_rel_430(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5)))
; (is_SetVar(X3,Y3)
-> (is_Reify(X4,Y4)
- -> gecode_constraint_rel_422(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_rel_432(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5)))
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=4))))
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=3)))
@@ -979,11 +1000,11 @@ rel(X0,X1,X2,X3,X4) :-
-> (is_BoolVarArgs(X2,Y2)
-> (is_int(X3,Y3)
-> (is_IntConLevel(X4,Y4)
- -> gecode_constraint_rel_362(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_rel_372(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5)))
; (is_BoolVar(X3,Y3)
-> (is_IntConLevel(X4,Y4)
- -> gecode_constraint_rel_360(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_rel_370(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=5)))
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=4))))
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=3)))
@@ -995,25 +1016,25 @@ min(X0,X1,X2,X3) :-
-> (is_IntVar(X1,Y1)
-> (is_IntVar(X2,Y2)
-> (is_IntVar(X3,Y3)
- -> gecode_constraint_min_308(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_min_318(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(min(X0,X1,X2,X3),arg=4)))
; throw(gecode_argument_error(min(X0,X1,X2,X3),arg=3)))
; (is_IntVarArgs(X1,Y1)
-> (is_IntVar(X2,Y2)
-> (is_IntConLevel(X3,Y3)
- -> gecode_constraint_min_306(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_min_316(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(min(X0,X1,X2,X3),arg=4)))
; throw(gecode_argument_error(min(X0,X1,X2,X3),arg=3)))
; (is_FloatVar(X1,Y1)
-> (is_FloatVar(X2,Y2)
-> (is_FloatVar(X3,Y3)
- -> gecode_constraint_min_307(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_min_317(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(min(X0,X1,X2,X3),arg=4)))
; throw(gecode_argument_error(min(X0,X1,X2,X3),arg=3)))
; (is_SetVar(X1,Y1)
-> (is_IntVar(X2,Y2)
-> (is_Reify(X3,Y3)
- -> gecode_constraint_min_311(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_min_321(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(min(X0,X1,X2,X3),arg=4)))
; throw(gecode_argument_error(min(X0,X1,X2,X3),arg=3)))
; throw(gecode_argument_error(min(X0,X1,X2,X3),arg=2))))))
@@ -1063,11 +1084,11 @@ sqrt(X0,X1,X2) :-
(is_Space_or_Clause(X0,Y0)
-> (is_IntVar(X1,Y1)
-> (is_IntVar(X2,Y2)
- -> gecode_constraint_sqrt_437(Y0,Y1,Y2)
+ -> gecode_constraint_sqrt_447(Y0,Y1,Y2)
; throw(gecode_argument_error(sqrt(X0,X1,X2),arg=3)))
; (is_FloatVar(X1,Y1)
-> (is_FloatVar(X2,Y2)
- -> gecode_constraint_sqrt_436(Y0,Y1,Y2)
+ -> gecode_constraint_sqrt_446(Y0,Y1,Y2)
; throw(gecode_argument_error(sqrt(X0,X1,X2),arg=3)))
; throw(gecode_argument_error(sqrt(X0,X1,X2),arg=2))))
; throw(gecode_argument_error(sqrt(X0,X1,X2),arg=1))).
@@ -1170,17 +1191,17 @@ nvalues(X0,X1,X2,X3) :-
-> (is_IntVarArgs(X1,Y1)
-> (is_IntRelType(X2,Y2)
-> (is_int(X3,Y3)
- -> gecode_constraint_nvalues_334(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_nvalues_344(Y0,Y1,Y2,Y3)
; (is_IntVar(X3,Y3)
- -> gecode_constraint_nvalues_336(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_nvalues_346(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(nvalues(X0,X1,X2,X3),arg=4))))
; throw(gecode_argument_error(nvalues(X0,X1,X2,X3),arg=3)))
; (is_BoolVarArgs(X1,Y1)
-> (is_IntRelType(X2,Y2)
-> (is_int(X3,Y3)
- -> gecode_constraint_nvalues_330(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_nvalues_340(Y0,Y1,Y2,Y3)
; (is_IntVar(X3,Y3)
- -> gecode_constraint_nvalues_332(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_nvalues_342(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(nvalues(X0,X1,X2,X3),arg=4))))
; throw(gecode_argument_error(nvalues(X0,X1,X2,X3),arg=3)))
; throw(gecode_argument_error(nvalues(X0,X1,X2,X3),arg=2))))
@@ -1205,13 +1226,13 @@ linear(X0,X1,X2,X3,X4,X5,X6) :-
-> (is_int(X4,Y4)
-> (is_Reify(X5,Y5)
-> (is_IntConLevel(X6,Y6)
- -> gecode_constraint_linear_275(Y0,Y1,Y2,Y3,Y4,Y5,Y6)
+ -> gecode_constraint_linear_285(Y0,Y1,Y2,Y3,Y4,Y5,Y6)
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5,X6),arg=7)))
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5,X6),arg=6)))
; (is_IntVar(X4,Y4)
-> (is_Reify(X5,Y5)
-> (is_IntConLevel(X6,Y6)
- -> gecode_constraint_linear_279(Y0,Y1,Y2,Y3,Y4,Y5,Y6)
+ -> gecode_constraint_linear_289(Y0,Y1,Y2,Y3,Y4,Y5,Y6)
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5,X6),arg=7)))
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5,X6),arg=6)))
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5,X6),arg=5))))
@@ -1221,13 +1242,13 @@ linear(X0,X1,X2,X3,X4,X5,X6) :-
-> (is_int(X4,Y4)
-> (is_Reify(X5,Y5)
-> (is_IntConLevel(X6,Y6)
- -> gecode_constraint_linear_267(Y0,Y1,Y2,Y3,Y4,Y5,Y6)
+ -> gecode_constraint_linear_277(Y0,Y1,Y2,Y3,Y4,Y5,Y6)
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5,X6),arg=7)))
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5,X6),arg=6)))
; (is_IntVar(X4,Y4)
-> (is_Reify(X5,Y5)
-> (is_IntConLevel(X6,Y6)
- -> gecode_constraint_linear_271(Y0,Y1,Y2,Y3,Y4,Y5,Y6)
+ -> gecode_constraint_linear_281(Y0,Y1,Y2,Y3,Y4,Y5,Y6)
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5,X6),arg=7)))
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5,X6),arg=6)))
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5,X6),arg=5))))
@@ -1278,13 +1299,13 @@ rel(X0,X1,X2,X3,X4,X5) :-
-> (is_int(X3,Y3)
-> (is_Reify(X4,Y4)
-> (is_IntConLevel(X5,Y5)
- -> gecode_constraint_rel_402(Y0,Y1,Y2,Y3,Y4,Y5)
+ -> gecode_constraint_rel_412(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=6)))
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=5)))
; (is_IntVar(X3,Y3)
-> (is_Reify(X4,Y4)
-> (is_IntConLevel(X5,Y5)
- -> gecode_constraint_rel_406(Y0,Y1,Y2,Y3,Y4,Y5)
+ -> gecode_constraint_rel_416(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=6)))
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=5)))
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=4))))
@@ -1294,9 +1315,9 @@ rel(X0,X1,X2,X3,X4,X5) :-
-> (is_SetVar(X3,Y3)
-> (is_SetRelType(X4,Y4)
-> (is_IntSet(X5,Y5)
- -> gecode_constraint_rel_385(Y0,Y1,Y2,Y3,Y4,Y5)
+ -> gecode_constraint_rel_395(Y0,Y1,Y2,Y3,Y4,Y5)
; (is_SetVar(X5,Y5)
- -> gecode_constraint_rel_386(Y0,Y1,Y2,Y3,Y4,Y5)
+ -> gecode_constraint_rel_396(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=6))))
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=5)))
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=4)))
@@ -1306,13 +1327,13 @@ rel(X0,X1,X2,X3,X4,X5) :-
-> (is_int(X3,Y3)
-> (is_Reify(X4,Y4)
-> (is_IntConLevel(X5,Y5)
- -> gecode_constraint_rel_374(Y0,Y1,Y2,Y3,Y4,Y5)
+ -> gecode_constraint_rel_384(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=6)))
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=5)))
; (is_BoolVar(X3,Y3)
-> (is_Reify(X4,Y4)
-> (is_IntConLevel(X5,Y5)
- -> gecode_constraint_rel_370(Y0,Y1,Y2,Y3,Y4,Y5)
+ -> gecode_constraint_rel_380(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=6)))
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=5)))
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=4))))
@@ -1320,11 +1341,11 @@ rel(X0,X1,X2,X3,X4,X5) :-
-> (is_BoolVar(X3,Y3)
-> (is_int(X4,Y4)
-> (is_IntConLevel(X5,Y5)
- -> gecode_constraint_rel_366(Y0,Y1,Y2,Y3,Y4,Y5)
+ -> gecode_constraint_rel_376(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=6)))
; (is_BoolVar(X4,Y4)
-> (is_IntConLevel(X5,Y5)
- -> gecode_constraint_rel_364(Y0,Y1,Y2,Y3,Y4,Y5)
+ -> gecode_constraint_rel_374(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=6)))
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=5))))
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=4)))
@@ -1334,17 +1355,17 @@ rel(X0,X1,X2,X3,X4,X5) :-
-> (is_IntSet(X3,Y3)
-> (is_SetRelType(X4,Y4)
-> (is_IntSet(X5,Y5)
- -> gecode_constraint_rel_415(Y0,Y1,Y2,Y3,Y4,Y5)
+ -> gecode_constraint_rel_425(Y0,Y1,Y2,Y3,Y4,Y5)
; (is_SetVar(X5,Y5)
- -> gecode_constraint_rel_416(Y0,Y1,Y2,Y3,Y4,Y5)
+ -> gecode_constraint_rel_426(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=6))))
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=5)))
; (is_SetVar(X3,Y3)
-> (is_SetRelType(X4,Y4)
-> (is_IntSet(X5,Y5)
- -> gecode_constraint_rel_417(Y0,Y1,Y2,Y3,Y4,Y5)
+ -> gecode_constraint_rel_427(Y0,Y1,Y2,Y3,Y4,Y5)
; (is_SetVar(X5,Y5)
- -> gecode_constraint_rel_418(Y0,Y1,Y2,Y3,Y4,Y5)
+ -> gecode_constraint_rel_428(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=6))))
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=5)))
; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=4))))
@@ -1358,7 +1379,7 @@ weights(X0,X1,X2,X3,X4) :-
-> (is_IntArgs(X2,Y2)
-> (is_SetVar(X3,Y3)
-> (is_IntVar(X4,Y4)
- -> gecode_constraint_weights_455(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_weights_465(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(weights(X0,X1,X2,X3,X4),arg=5)))
; throw(gecode_argument_error(weights(X0,X1,X2,X3,X4),arg=4)))
; throw(gecode_argument_error(weights(X0,X1,X2,X3,X4),arg=3)))
@@ -1371,7 +1392,7 @@ max(X0,X1,X2,X3,X4) :-
-> (is_IntVar(X2,Y2)
-> (is_IntVar(X3,Y3)
-> (is_IntConLevel(X4,Y4)
- -> gecode_constraint_max_293(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_max_303(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(max(X0,X1,X2,X3,X4),arg=5)))
; throw(gecode_argument_error(max(X0,X1,X2,X3,X4),arg=4)))
; throw(gecode_argument_error(max(X0,X1,X2,X3,X4),arg=3)))
@@ -1388,7 +1409,7 @@ path(X0,X1,X2,X3,X4,X5,X6,X7,X8) :-
-> (is_IntVarArgs(X6,Y6)
-> (is_IntVar(X7,Y7)
-> (is_IntConLevel(X8,Y8)
- -> gecode_constraint_path_343(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7,Y8)
+ -> gecode_constraint_path_353(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7,Y8)
; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=9)))
; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=8)))
; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=7)))
@@ -1404,19 +1425,19 @@ unary(X0,X1,X2,X3) :-
-> (is_TaskTypeArgs(X1,Y1)
-> (is_IntVarArgs(X2,Y2)
-> (is_IntArgs(X3,Y3)
- -> gecode_constraint_unary_449(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_unary_459(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(unary(X0,X1,X2,X3),arg=4)))
; throw(gecode_argument_error(unary(X0,X1,X2,X3),arg=3)))
; (is_IntVarArgs(X1,Y1)
-> (is_IntVarArgs(X2,Y2)
-> (is_IntVarArgs(X3,Y3)
- -> gecode_constraint_unary_445(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_unary_455(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(unary(X0,X1,X2,X3),arg=4)))
; (is_IntArgs(X2,Y2)
-> (is_BoolVarArgs(X3,Y3)
- -> gecode_constraint_unary_439(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_unary_449(Y0,Y1,Y2,Y3)
; (is_IntConLevel(X3,Y3)
- -> gecode_constraint_unary_442(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_unary_452(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(unary(X0,X1,X2,X3),arg=4))))
; throw(gecode_argument_error(unary(X0,X1,X2,X3),arg=3))))
; throw(gecode_argument_error(unary(X0,X1,X2,X3),arg=2))))
@@ -1427,13 +1448,13 @@ nroot(X0,X1,X2,X3) :-
-> (is_IntVar(X1,Y1)
-> (is_int(X2,Y2)
-> (is_IntVar(X3,Y3)
- -> gecode_constraint_nroot_328(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_nroot_338(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(nroot(X0,X1,X2,X3),arg=4)))
; throw(gecode_argument_error(nroot(X0,X1,X2,X3),arg=3)))
; (is_FloatVar(X1,Y1)
-> (is_int(X2,Y2)
-> (is_FloatVar(X3,Y3)
- -> gecode_constraint_nroot_327(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_nroot_337(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(nroot(X0,X1,X2,X3),arg=4)))
; throw(gecode_argument_error(nroot(X0,X1,X2,X3),arg=3)))
; throw(gecode_argument_error(nroot(X0,X1,X2,X3),arg=2))))
@@ -1445,7 +1466,7 @@ sorted(X0,X1,X2,X3,X4) :-
-> (is_IntVarArgs(X2,Y2)
-> (is_IntVarArgs(X3,Y3)
-> (is_IntConLevel(X4,Y4)
- -> gecode_constraint_sorted_430(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_sorted_440(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(sorted(X0,X1,X2,X3,X4),arg=5)))
; throw(gecode_argument_error(sorted(X0,X1,X2,X3,X4),arg=4)))
; throw(gecode_argument_error(sorted(X0,X1,X2,X3,X4),arg=3)))
@@ -1635,11 +1656,11 @@ rel(X0,X1,X2) :-
(is_Space_or_Clause(X0,Y0)
-> (is_IntVarArgs(X1,Y1)
-> (is_IntRelType(X2,Y2)
- -> gecode_constraint_rel_389(Y0,Y1,Y2)
+ -> gecode_constraint_rel_399(Y0,Y1,Y2)
; throw(gecode_argument_error(rel(X0,X1,X2),arg=3)))
; (is_BoolVarArgs(X1,Y1)
-> (is_IntRelType(X2,Y2)
- -> gecode_constraint_rel_379(Y0,Y1,Y2)
+ -> gecode_constraint_rel_389(Y0,Y1,Y2)
; throw(gecode_argument_error(rel(X0,X1,X2),arg=3)))
; throw(gecode_argument_error(rel(X0,X1,X2),arg=2))))
; throw(gecode_argument_error(rel(X0,X1,X2),arg=1))).
@@ -1649,7 +1670,7 @@ path(X0,X1,X2,X3) :-
-> (is_IntVarArgs(X1,Y1)
-> (is_IntVar(X2,Y2)
-> (is_IntVar(X3,Y3)
- -> gecode_constraint_path_346(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_path_356(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(path(X0,X1,X2,X3),arg=4)))
; throw(gecode_argument_error(path(X0,X1,X2,X3),arg=3)))
; throw(gecode_argument_error(path(X0,X1,X2,X3),arg=2)))
@@ -1714,7 +1735,7 @@ mult(X0,X1,X2,X3,X4) :-
-> (is_IntVar(X2,Y2)
-> (is_IntVar(X3,Y3)
-> (is_IntConLevel(X4,Y4)
- -> gecode_constraint_mult_316(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_mult_326(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(mult(X0,X1,X2,X3,X4),arg=5)))
; throw(gecode_argument_error(mult(X0,X1,X2,X3,X4),arg=4)))
; throw(gecode_argument_error(mult(X0,X1,X2,X3,X4),arg=3)))
@@ -1768,17 +1789,17 @@ precede(X0,X1,X2,X3) :-
-> (is_SetVarArgs(X1,Y1)
-> (is_int(X2,Y2)
-> (is_int(X3,Y3)
- -> gecode_constraint_precede_358(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_precede_368(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(precede(X0,X1,X2,X3),arg=4)))
; throw(gecode_argument_error(precede(X0,X1,X2,X3),arg=3)))
; (is_IntVarArgs(X1,Y1)
-> (is_int(X2,Y2)
-> (is_int(X3,Y3)
- -> gecode_constraint_precede_355(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_precede_365(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(precede(X0,X1,X2,X3),arg=4)))
; (is_IntArgs(X2,Y2)
-> (is_IntConLevel(X3,Y3)
- -> gecode_constraint_precede_354(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_precede_364(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(precede(X0,X1,X2,X3),arg=4)))
; throw(gecode_argument_error(precede(X0,X1,X2,X3),arg=3))))
; throw(gecode_argument_error(precede(X0,X1,X2,X3),arg=2))))
@@ -1891,7 +1912,7 @@ member(X0,X1,X2,X3,X4) :-
-> (is_IntVar(X2,Y2)
-> (is_Reify(X3,Y3)
-> (is_IntConLevel(X4,Y4)
- -> gecode_constraint_member_303(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_member_313(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(member(X0,X1,X2,X3,X4),arg=5)))
; throw(gecode_argument_error(member(X0,X1,X2,X3,X4),arg=4)))
; throw(gecode_argument_error(member(X0,X1,X2,X3,X4),arg=3)))
@@ -1899,7 +1920,7 @@ member(X0,X1,X2,X3,X4) :-
-> (is_BoolVar(X2,Y2)
-> (is_Reify(X3,Y3)
-> (is_IntConLevel(X4,Y4)
- -> gecode_constraint_member_299(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_member_309(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(member(X0,X1,X2,X3,X4),arg=5)))
; throw(gecode_argument_error(member(X0,X1,X2,X3,X4),arg=4)))
; throw(gecode_argument_error(member(X0,X1,X2,X3,X4),arg=3)))
@@ -1911,7 +1932,7 @@ mod(X0,X1,X2,X3) :-
-> (is_IntVar(X1,Y1)
-> (is_IntVar(X2,Y2)
-> (is_IntVar(X3,Y3)
- -> gecode_constraint_mod_312(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_mod_322(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(mod(X0,X1,X2,X3),arg=4)))
; throw(gecode_argument_error(mod(X0,X1,X2,X3),arg=3)))
; throw(gecode_argument_error(mod(X0,X1,X2,X3),arg=2)))
@@ -1921,11 +1942,11 @@ sqr(X0,X1,X2) :-
(is_Space_or_Clause(X0,Y0)
-> (is_IntVar(X1,Y1)
-> (is_IntVar(X2,Y2)
- -> gecode_constraint_sqr_434(Y0,Y1,Y2)
+ -> gecode_constraint_sqr_444(Y0,Y1,Y2)
; throw(gecode_argument_error(sqr(X0,X1,X2),arg=3)))
; (is_FloatVar(X1,Y1)
-> (is_FloatVar(X2,Y2)
- -> gecode_constraint_sqr_433(Y0,Y1,Y2)
+ -> gecode_constraint_sqr_443(Y0,Y1,Y2)
; throw(gecode_argument_error(sqr(X0,X1,X2),arg=3)))
; throw(gecode_argument_error(sqr(X0,X1,X2),arg=2))))
; throw(gecode_argument_error(sqr(X0,X1,X2),arg=1))).
@@ -1938,7 +1959,7 @@ sequence(X0,X1,X2,X3,X4,X5,X6) :-
-> (is_int(X4,Y4)
-> (is_int(X5,Y5)
-> (is_IntConLevel(X6,Y6)
- -> gecode_constraint_sequence_426(Y0,Y1,Y2,Y3,Y4,Y5,Y6)
+ -> gecode_constraint_sequence_436(Y0,Y1,Y2,Y3,Y4,Y5,Y6)
; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5,X6),arg=7)))
; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5,X6),arg=6)))
; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5,X6),arg=5)))
@@ -1950,7 +1971,7 @@ sequence(X0,X1,X2,X3,X4,X5,X6) :-
-> (is_int(X4,Y4)
-> (is_int(X5,Y5)
-> (is_IntConLevel(X6,Y6)
- -> gecode_constraint_sequence_424(Y0,Y1,Y2,Y3,Y4,Y5,Y6)
+ -> gecode_constraint_sequence_434(Y0,Y1,Y2,Y3,Y4,Y5,Y6)
; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5,X6),arg=7)))
; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5,X6),arg=6)))
; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5,X6),arg=5)))
@@ -1967,7 +1988,7 @@ path(X0,X1,X2,X3,X4,X5,X6) :-
-> (is_IntVar(X4,Y4)
-> (is_IntVar(X5,Y5)
-> (is_IntVar(X6,Y6)
- -> gecode_constraint_path_344(Y0,Y1,Y2,Y3,Y4,Y5,Y6)
+ -> gecode_constraint_path_354(Y0,Y1,Y2,Y3,Y4,Y5,Y6)
; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6),arg=7)))
; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6),arg=6)))
; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6),arg=5)))
@@ -1977,11 +1998,11 @@ path(X0,X1,X2,X3,X4,X5,X6) :-
-> (is_IntVar(X4,Y4)
-> (is_IntVar(X5,Y5)
-> (is_IntConLevel(X6,Y6)
- -> gecode_constraint_path_341(Y0,Y1,Y2,Y3,Y4,Y5,Y6)
+ -> gecode_constraint_path_351(Y0,Y1,Y2,Y3,Y4,Y5,Y6)
; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6),arg=7)))
; (is_IntVarArgs(X5,Y5)
-> (is_IntVar(X6,Y6)
- -> gecode_constraint_path_338(Y0,Y1,Y2,Y3,Y4,Y5,Y6)
+ -> gecode_constraint_path_348(Y0,Y1,Y2,Y3,Y4,Y5,Y6)
; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6),arg=7)))
; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6),arg=6))))
; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6),arg=5)))
@@ -2009,11 +2030,36 @@ sorted(X0,X1,X2) :-
(is_Space_or_Clause(X0,Y0)
-> (is_IntVarArgs(X1,Y1)
-> (is_IntVarArgs(X2,Y2)
- -> gecode_constraint_sorted_431(Y0,Y1,Y2)
+ -> gecode_constraint_sorted_441(Y0,Y1,Y2)
; throw(gecode_argument_error(sorted(X0,X1,X2),arg=3)))
; throw(gecode_argument_error(sorted(X0,X1,X2),arg=2)))
; throw(gecode_argument_error(sorted(X0,X1,X2),arg=1))).
+extensional(X0,X1,X2,X3) :-
+ (is_Space_or_Clause(X0,Y0)
+ -> (is_IntVarArgs(X1,Y1)
+ -> (is_TupleSet(X2,Y2)
+ -> (is_ExtensionalPropKind(X3,Y3)
+ -> gecode_constraint_extensional_252(Y0,Y1,Y2,Y3)
+ ; throw(gecode_argument_error(extensional(X0,X1,X2,X3),arg=4)))
+ ; (is_DFA(X2,Y2)
+ -> (is_IntConLevel(X3,Y3)
+ -> gecode_constraint_extensional_255(Y0,Y1,Y2,Y3)
+ ; throw(gecode_argument_error(extensional(X0,X1,X2,X3),arg=4)))
+ ; throw(gecode_argument_error(extensional(X0,X1,X2,X3),arg=3))))
+ ; (is_BoolVarArgs(X1,Y1)
+ -> (is_TupleSet(X2,Y2)
+ -> (is_ExtensionalPropKind(X3,Y3)
+ -> gecode_constraint_extensional_247(Y0,Y1,Y2,Y3)
+ ; throw(gecode_argument_error(extensional(X0,X1,X2,X3),arg=4)))
+ ; (is_DFA(X2,Y2)
+ -> (is_IntConLevel(X3,Y3)
+ -> gecode_constraint_extensional_250(Y0,Y1,Y2,Y3)
+ ; throw(gecode_argument_error(extensional(X0,X1,X2,X3),arg=4)))
+ ; throw(gecode_argument_error(extensional(X0,X1,X2,X3),arg=3))))
+ ; throw(gecode_argument_error(extensional(X0,X1,X2,X3),arg=2))))
+ ; throw(gecode_argument_error(extensional(X0,X1,X2,X3),arg=1))).
+
circuit(X0,X1,X2) :-
(is_Space_or_Clause(X0,Y0)
-> (is_int(X1,Y1)
@@ -2205,6 +2251,23 @@ binpacking(X0,X1,X2,X3,X4) :-
; throw(gecode_argument_error(binpacking(X0,X1,X2,X3,X4),arg=2)))
; throw(gecode_argument_error(binpacking(X0,X1,X2,X3,X4),arg=1))).
+extensional(X0,X1,X2) :-
+ (is_Space_or_Clause(X0,Y0)
+ -> (is_IntVarArgs(X1,Y1)
+ -> (is_TupleSet(X2,Y2)
+ -> gecode_constraint_extensional_251(Y0,Y1,Y2)
+ ; (is_DFA(X2,Y2)
+ -> gecode_constraint_extensional_254(Y0,Y1,Y2)
+ ; throw(gecode_argument_error(extensional(X0,X1,X2),arg=3))))
+ ; (is_BoolVarArgs(X1,Y1)
+ -> (is_TupleSet(X2,Y2)
+ -> gecode_constraint_extensional_246(Y0,Y1,Y2)
+ ; (is_DFA(X2,Y2)
+ -> gecode_constraint_extensional_249(Y0,Y1,Y2)
+ ; throw(gecode_argument_error(extensional(X0,X1,X2),arg=3))))
+ ; throw(gecode_argument_error(extensional(X0,X1,X2),arg=2))))
+ ; throw(gecode_argument_error(extensional(X0,X1,X2),arg=1))).
+
linear(X0,X1,X2,X3,X4,X5) :-
(is_Space_or_Clause(X0,Y0)
-> (is_IntVarArgs(X1,Y1)
@@ -2212,13 +2275,13 @@ linear(X0,X1,X2,X3,X4,X5) :-
-> (is_int(X3,Y3)
-> (is_Reify(X4,Y4)
-> (is_IntConLevel(X5,Y5)
- -> gecode_constraint_linear_283(Y0,Y1,Y2,Y3,Y4,Y5)
+ -> gecode_constraint_linear_293(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=6)))
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=5)))
; (is_IntVar(X3,Y3)
-> (is_Reify(X4,Y4)
-> (is_IntConLevel(X5,Y5)
- -> gecode_constraint_linear_287(Y0,Y1,Y2,Y3,Y4,Y5)
+ -> gecode_constraint_linear_297(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=6)))
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=5)))
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=4))))
@@ -2228,13 +2291,13 @@ linear(X0,X1,X2,X3,X4,X5) :-
-> (is_int(X3,Y3)
-> (is_Reify(X4,Y4)
-> (is_IntConLevel(X5,Y5)
- -> gecode_constraint_linear_251(Y0,Y1,Y2,Y3,Y4,Y5)
+ -> gecode_constraint_linear_261(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=6)))
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=5)))
; (is_IntVar(X3,Y3)
-> (is_Reify(X4,Y4)
-> (is_IntConLevel(X5,Y5)
- -> gecode_constraint_linear_255(Y0,Y1,Y2,Y3,Y4,Y5)
+ -> gecode_constraint_linear_265(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=6)))
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=5)))
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=4))))
@@ -2244,11 +2307,11 @@ linear(X0,X1,X2,X3,X4,X5) :-
-> (is_FloatRelType(X3,Y3)
-> (is_FloatVar(X4,Y4)
-> (is_Reify(X5,Y5)
- -> gecode_constraint_linear_259(Y0,Y1,Y2,Y3,Y4,Y5)
+ -> gecode_constraint_linear_269(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=6)))
; (is_FloatNum(X4,Y4)
-> (is_Reify(X5,Y5)
- -> gecode_constraint_linear_257(Y0,Y1,Y2,Y3,Y4,Y5)
+ -> gecode_constraint_linear_267(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=6)))
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=5))))
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=4)))
@@ -2258,15 +2321,15 @@ linear(X0,X1,X2,X3,X4,X5) :-
-> (is_IntRelType(X3,Y3)
-> (is_int(X4,Y4)
-> (is_Reify(X5,Y5)
- -> gecode_constraint_linear_274(Y0,Y1,Y2,Y3,Y4,Y5)
+ -> gecode_constraint_linear_284(Y0,Y1,Y2,Y3,Y4,Y5)
; (is_IntConLevel(X5,Y5)
- -> gecode_constraint_linear_273(Y0,Y1,Y2,Y3,Y4,Y5)
+ -> gecode_constraint_linear_283(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=6))))
; (is_IntVar(X4,Y4)
-> (is_Reify(X5,Y5)
- -> gecode_constraint_linear_278(Y0,Y1,Y2,Y3,Y4,Y5)
+ -> gecode_constraint_linear_288(Y0,Y1,Y2,Y3,Y4,Y5)
; (is_IntConLevel(X5,Y5)
- -> gecode_constraint_linear_277(Y0,Y1,Y2,Y3,Y4,Y5)
+ -> gecode_constraint_linear_287(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=6))))
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=5))))
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=4)))
@@ -2274,15 +2337,15 @@ linear(X0,X1,X2,X3,X4,X5) :-
-> (is_IntRelType(X3,Y3)
-> (is_int(X4,Y4)
-> (is_Reify(X5,Y5)
- -> gecode_constraint_linear_266(Y0,Y1,Y2,Y3,Y4,Y5)
+ -> gecode_constraint_linear_276(Y0,Y1,Y2,Y3,Y4,Y5)
; (is_IntConLevel(X5,Y5)
- -> gecode_constraint_linear_265(Y0,Y1,Y2,Y3,Y4,Y5)
+ -> gecode_constraint_linear_275(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=6))))
; (is_IntVar(X4,Y4)
-> (is_Reify(X5,Y5)
- -> gecode_constraint_linear_270(Y0,Y1,Y2,Y3,Y4,Y5)
+ -> gecode_constraint_linear_280(Y0,Y1,Y2,Y3,Y4,Y5)
; (is_IntConLevel(X5,Y5)
- -> gecode_constraint_linear_269(Y0,Y1,Y2,Y3,Y4,Y5)
+ -> gecode_constraint_linear_279(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=6))))
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=5))))
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=4)))
@@ -2298,7 +2361,7 @@ nooverlap(X0,X1,X2,X3,X4,X5,X6) :-
-> (is_IntVarArgs(X4,Y4)
-> (is_IntVarArgs(X5,Y5)
-> (is_IntVarArgs(X6,Y6)
- -> gecode_constraint_nooverlap_323(Y0,Y1,Y2,Y3,Y4,Y5,Y6)
+ -> gecode_constraint_nooverlap_333(Y0,Y1,Y2,Y3,Y4,Y5,Y6)
; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6),arg=7)))
; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6),arg=6)))
; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6),arg=5)))
@@ -2308,7 +2371,7 @@ nooverlap(X0,X1,X2,X3,X4,X5,X6) :-
-> (is_IntArgs(X4,Y4)
-> (is_BoolVarArgs(X5,Y5)
-> (is_IntConLevel(X6,Y6)
- -> gecode_constraint_nooverlap_318(Y0,Y1,Y2,Y3,Y4,Y5,Y6)
+ -> gecode_constraint_nooverlap_328(Y0,Y1,Y2,Y3,Y4,Y5,Y6)
; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6),arg=7)))
; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6),arg=6)))
; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6),arg=5)))
@@ -2335,7 +2398,7 @@ sqr(X0,X1,X2,X3) :-
-> (is_IntVar(X1,Y1)
-> (is_IntVar(X2,Y2)
-> (is_IntConLevel(X3,Y3)
- -> gecode_constraint_sqr_435(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_sqr_445(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(sqr(X0,X1,X2,X3),arg=4)))
; throw(gecode_argument_error(sqr(X0,X1,X2,X3),arg=3)))
; throw(gecode_argument_error(sqr(X0,X1,X2,X3),arg=2)))
@@ -2350,11 +2413,11 @@ path(X0,X1,X2,X3,X4,X5,X6,X7) :-
-> (is_IntVar(X5,Y5)
-> (is_IntVar(X6,Y6)
-> (is_IntConLevel(X7,Y7)
- -> gecode_constraint_path_345(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7)
+ -> gecode_constraint_path_355(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7)
; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7),arg=8)))
; (is_IntVarArgs(X6,Y6)
-> (is_IntVar(X7,Y7)
- -> gecode_constraint_path_342(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7)
+ -> gecode_constraint_path_352(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7)
; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7),arg=8)))
; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7),arg=7))))
; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7),arg=6)))
@@ -2366,7 +2429,7 @@ path(X0,X1,X2,X3,X4,X5,X6,X7) :-
-> (is_IntVarArgs(X5,Y5)
-> (is_IntVar(X6,Y6)
-> (is_IntConLevel(X7,Y7)
- -> gecode_constraint_path_339(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7)
+ -> gecode_constraint_path_349(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7)
; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7),arg=8)))
; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7),arg=7)))
; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7),arg=6)))
@@ -2382,9 +2445,9 @@ unary(X0,X1,X2,X3,X4) :-
-> (is_IntVarArgs(X2,Y2)
-> (is_IntArgs(X3,Y3)
-> (is_BoolVarArgs(X4,Y4)
- -> gecode_constraint_unary_447(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_unary_457(Y0,Y1,Y2,Y3,Y4)
; (is_IntConLevel(X4,Y4)
- -> gecode_constraint_unary_450(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_unary_460(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4),arg=5))))
; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4),arg=4)))
; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4),arg=3)))
@@ -2392,15 +2455,15 @@ unary(X0,X1,X2,X3,X4) :-
-> (is_IntVarArgs(X2,Y2)
-> (is_IntVarArgs(X3,Y3)
-> (is_BoolVarArgs(X4,Y4)
- -> gecode_constraint_unary_443(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_unary_453(Y0,Y1,Y2,Y3,Y4)
; (is_IntConLevel(X4,Y4)
- -> gecode_constraint_unary_446(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_unary_456(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4),arg=5))))
; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4),arg=4)))
; (is_IntArgs(X2,Y2)
-> (is_BoolVarArgs(X3,Y3)
-> (is_IntConLevel(X4,Y4)
- -> gecode_constraint_unary_440(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_unary_450(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4),arg=5)))
; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4),arg=4)))
; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4),arg=3))))
@@ -2412,9 +2475,9 @@ sorted(X0,X1,X2,X3) :-
-> (is_IntVarArgs(X1,Y1)
-> (is_IntVarArgs(X2,Y2)
-> (is_IntVarArgs(X3,Y3)
- -> gecode_constraint_sorted_429(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_sorted_439(Y0,Y1,Y2,Y3)
; (is_IntConLevel(X3,Y3)
- -> gecode_constraint_sorted_432(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_sorted_442(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(sorted(X0,X1,X2,X3),arg=4))))
; throw(gecode_argument_error(sorted(X0,X1,X2,X3),arg=3)))
; throw(gecode_argument_error(sorted(X0,X1,X2,X3),arg=2)))
@@ -2599,7 +2662,7 @@ sequence(X0,X1,X2) :-
(is_Space_or_Clause(X0,Y0)
-> (is_SetVarArgs(X1,Y1)
-> (is_SetVar(X2,Y2)
- -> gecode_constraint_sequence_428(Y0,Y1,Y2)
+ -> gecode_constraint_sequence_438(Y0,Y1,Y2)
; throw(gecode_argument_error(sequence(X0,X1,X2),arg=3)))
; throw(gecode_argument_error(sequence(X0,X1,X2),arg=2)))
; throw(gecode_argument_error(sequence(X0,X1,X2),arg=1))).
@@ -2669,13 +2732,13 @@ pow(X0,X1,X2,X3) :-
-> (is_IntVar(X1,Y1)
-> (is_int(X2,Y2)
-> (is_IntVar(X3,Y3)
- -> gecode_constraint_pow_351(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_pow_361(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(pow(X0,X1,X2,X3),arg=4)))
; throw(gecode_argument_error(pow(X0,X1,X2,X3),arg=3)))
; (is_FloatVar(X1,Y1)
-> (is_int(X2,Y2)
-> (is_FloatVar(X3,Y3)
- -> gecode_constraint_pow_350(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_pow_360(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(pow(X0,X1,X2,X3),arg=4)))
; throw(gecode_argument_error(pow(X0,X1,X2,X3),arg=3)))
; throw(gecode_argument_error(pow(X0,X1,X2,X3),arg=2))))
@@ -2685,11 +2748,11 @@ precede(X0,X1,X2) :-
(is_Space_or_Clause(X0,Y0)
-> (is_SetVarArgs(X1,Y1)
-> (is_IntArgs(X2,Y2)
- -> gecode_constraint_precede_357(Y0,Y1,Y2)
+ -> gecode_constraint_precede_367(Y0,Y1,Y2)
; throw(gecode_argument_error(precede(X0,X1,X2),arg=3)))
; (is_IntVarArgs(X1,Y1)
-> (is_IntArgs(X2,Y2)
- -> gecode_constraint_precede_353(Y0,Y1,Y2)
+ -> gecode_constraint_precede_363(Y0,Y1,Y2)
; throw(gecode_argument_error(precede(X0,X1,X2),arg=3)))
; throw(gecode_argument_error(precede(X0,X1,X2),arg=2))))
; throw(gecode_argument_error(precede(X0,X1,X2),arg=1))).
@@ -2766,15 +2829,15 @@ min(X0,X1,X2) :-
(is_Space_or_Clause(X0,Y0)
-> (is_FloatVarArgs(X1,Y1)
-> (is_FloatVar(X2,Y2)
- -> gecode_constraint_min_304(Y0,Y1,Y2)
+ -> gecode_constraint_min_314(Y0,Y1,Y2)
; throw(gecode_argument_error(min(X0,X1,X2),arg=3)))
; (is_IntVarArgs(X1,Y1)
-> (is_IntVar(X2,Y2)
- -> gecode_constraint_min_305(Y0,Y1,Y2)
+ -> gecode_constraint_min_315(Y0,Y1,Y2)
; throw(gecode_argument_error(min(X0,X1,X2),arg=3)))
; (is_SetVar(X1,Y1)
-> (is_IntVar(X2,Y2)
- -> gecode_constraint_min_310(Y0,Y1,Y2)
+ -> gecode_constraint_min_320(Y0,Y1,Y2)
; throw(gecode_argument_error(min(X0,X1,X2),arg=3)))
; throw(gecode_argument_error(min(X0,X1,X2),arg=2)))))
; throw(gecode_argument_error(min(X0,X1,X2),arg=1))).
@@ -2784,7 +2847,7 @@ sqrt(X0,X1,X2,X3) :-
-> (is_IntVar(X1,Y1)
-> (is_IntVar(X2,Y2)
-> (is_IntConLevel(X3,Y3)
- -> gecode_constraint_sqrt_438(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_sqrt_448(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(sqrt(X0,X1,X2,X3),arg=4)))
; throw(gecode_argument_error(sqrt(X0,X1,X2,X3),arg=3)))
; throw(gecode_argument_error(sqrt(X0,X1,X2,X3),arg=2)))
@@ -2797,7 +2860,7 @@ sequence(X0,X1,X2,X3,X4,X5) :-
-> (is_int(X3,Y3)
-> (is_int(X4,Y4)
-> (is_int(X5,Y5)
- -> gecode_constraint_sequence_425(Y0,Y1,Y2,Y3,Y4,Y5)
+ -> gecode_constraint_sequence_435(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5),arg=6)))
; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5),arg=5)))
; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5),arg=4)))
@@ -2807,7 +2870,7 @@ sequence(X0,X1,X2,X3,X4,X5) :-
-> (is_int(X3,Y3)
-> (is_int(X4,Y4)
-> (is_int(X5,Y5)
- -> gecode_constraint_sequence_423(Y0,Y1,Y2,Y3,Y4,Y5)
+ -> gecode_constraint_sequence_433(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5),arg=6)))
; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5),arg=5)))
; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5),arg=4)))
@@ -2819,11 +2882,11 @@ unshare(X0,X1,X2) :-
(is_Space_or_Clause(X0,Y0)
-> (is_IntVarArgs(X1,Y1)
-> (is_IntConLevel(X2,Y2)
- -> gecode_constraint_unshare_454(Y0,Y1,Y2)
+ -> gecode_constraint_unshare_464(Y0,Y1,Y2)
; throw(gecode_argument_error(unshare(X0,X1,X2),arg=3)))
; (is_BoolVarArgs(X1,Y1)
-> (is_IntConLevel(X2,Y2)
- -> gecode_constraint_unshare_452(Y0,Y1,Y2)
+ -> gecode_constraint_unshare_462(Y0,Y1,Y2)
; throw(gecode_argument_error(unshare(X0,X1,X2),arg=3)))
; throw(gecode_argument_error(unshare(X0,X1,X2),arg=2))))
; throw(gecode_argument_error(unshare(X0,X1,X2),arg=1))).
@@ -2835,7 +2898,7 @@ path(X0,X1,X2,X3,X4,X5) :-
-> (is_IntVar(X3,Y3)
-> (is_IntVar(X4,Y4)
-> (is_IntConLevel(X5,Y5)
- -> gecode_constraint_path_349(Y0,Y1,Y2,Y3,Y4,Y5)
+ -> gecode_constraint_path_359(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5),arg=6)))
; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5),arg=5)))
; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5),arg=4)))
@@ -2845,7 +2908,7 @@ path(X0,X1,X2,X3,X4,X5) :-
-> (is_IntVar(X3,Y3)
-> (is_IntVar(X4,Y4)
-> (is_IntVar(X5,Y5)
- -> gecode_constraint_path_340(Y0,Y1,Y2,Y3,Y4,Y5)
+ -> gecode_constraint_path_350(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5),arg=6)))
; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5),arg=5)))
; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5),arg=4)))
@@ -2933,7 +2996,7 @@ nooverlap(X0,X1,X2,X3,X4,X5,X6,X7,X8) :-
-> (is_IntVarArgs(X6,Y6)
-> (is_BoolVarArgs(X7,Y7)
-> (is_IntConLevel(X8,Y8)
- -> gecode_constraint_nooverlap_322(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7,Y8)
+ -> gecode_constraint_nooverlap_332(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7,Y8)
; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=9)))
; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=8)))
; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=7)))
@@ -2969,11 +3032,11 @@ member(X0,X1,X2) :-
(is_Space_or_Clause(X0,Y0)
-> (is_IntVarArgs(X1,Y1)
-> (is_IntVar(X2,Y2)
- -> gecode_constraint_member_300(Y0,Y1,Y2)
+ -> gecode_constraint_member_310(Y0,Y1,Y2)
; throw(gecode_argument_error(member(X0,X1,X2),arg=3)))
; (is_BoolVarArgs(X1,Y1)
-> (is_BoolVar(X2,Y2)
- -> gecode_constraint_member_296(Y0,Y1,Y2)
+ -> gecode_constraint_member_306(Y0,Y1,Y2)
; throw(gecode_argument_error(member(X0,X1,X2),arg=3)))
; throw(gecode_argument_error(member(X0,X1,X2),arg=2))))
; throw(gecode_argument_error(member(X0,X1,X2),arg=1))).
@@ -3039,7 +3102,7 @@ pow(X0,X1,X2,X3,X4) :-
-> (is_int(X2,Y2)
-> (is_IntVar(X3,Y3)
-> (is_IntConLevel(X4,Y4)
- -> gecode_constraint_pow_352(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_pow_362(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(pow(X0,X1,X2,X3,X4),arg=5)))
; throw(gecode_argument_error(pow(X0,X1,X2,X3,X4),arg=4)))
; throw(gecode_argument_error(pow(X0,X1,X2,X3,X4),arg=3)))
@@ -3050,7 +3113,7 @@ notMin(X0,X1,X2) :-
(is_Space_or_Clause(X0,Y0)
-> (is_SetVar(X1,Y1)
-> (is_IntVar(X2,Y2)
- -> gecode_constraint_notMin_326(Y0,Y1,Y2)
+ -> gecode_constraint_notMin_336(Y0,Y1,Y2)
; throw(gecode_argument_error(notMin(X0,X1,X2),arg=3)))
; throw(gecode_argument_error(notMin(X0,X1,X2),arg=2)))
; throw(gecode_argument_error(notMin(X0,X1,X2),arg=1))).
@@ -3184,75 +3247,75 @@ dom(X0,X1,X2) :-
linear(X0,X1,X2,X3,X4) :-
(is_Space_or_Clause(X0,Y0)
- -> (is_FloatVarArgs(X1,Y1)
- -> (is_FloatRelType(X2,Y2)
- -> (is_FloatVar(X3,Y3)
+ -> (is_IntVarArgs(X1,Y1)
+ -> (is_IntRelType(X2,Y2)
+ -> (is_int(X3,Y3)
-> (is_Reify(X4,Y4)
- -> gecode_constraint_linear_263(Y0,Y1,Y2,Y3,Y4)
- ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=5)))
- ; (is_FloatNum(X3,Y3)
+ -> gecode_constraint_linear_292(Y0,Y1,Y2,Y3,Y4)
+ ; (is_IntConLevel(X4,Y4)
+ -> gecode_constraint_linear_291(Y0,Y1,Y2,Y3,Y4)
+ ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=5))))
+ ; (is_IntVar(X3,Y3)
-> (is_Reify(X4,Y4)
- -> gecode_constraint_linear_261(Y0,Y1,Y2,Y3,Y4)
- ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=5)))
+ -> gecode_constraint_linear_296(Y0,Y1,Y2,Y3,Y4)
+ ; (is_IntConLevel(X4,Y4)
+ -> gecode_constraint_linear_295(Y0,Y1,Y2,Y3,Y4)
+ ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=5))))
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=4))))
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=3)))
- ; (is_BoolVarArgs(X1,Y1)
- -> (is_IntRelType(X2,Y2)
- -> (is_int(X3,Y3)
+ ; (is_FloatVarArgs(X1,Y1)
+ -> (is_FloatRelType(X2,Y2)
+ -> (is_FloatVar(X3,Y3)
-> (is_Reify(X4,Y4)
- -> gecode_constraint_linear_250(Y0,Y1,Y2,Y3,Y4)
- ; (is_IntConLevel(X4,Y4)
- -> gecode_constraint_linear_249(Y0,Y1,Y2,Y3,Y4)
- ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=5))))
- ; (is_IntVar(X3,Y3)
+ -> gecode_constraint_linear_273(Y0,Y1,Y2,Y3,Y4)
+ ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=5)))
+ ; (is_FloatNum(X3,Y3)
-> (is_Reify(X4,Y4)
- -> gecode_constraint_linear_254(Y0,Y1,Y2,Y3,Y4)
- ; (is_IntConLevel(X4,Y4)
- -> gecode_constraint_linear_253(Y0,Y1,Y2,Y3,Y4)
- ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=5))))
+ -> gecode_constraint_linear_271(Y0,Y1,Y2,Y3,Y4)
+ ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=5)))
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=4))))
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=3)))
- ; (is_FloatValArgs(X1,Y1)
- -> (is_FloatVarArgs(X2,Y2)
- -> (is_FloatRelType(X3,Y3)
- -> (is_FloatVar(X4,Y4)
- -> gecode_constraint_linear_258(Y0,Y1,Y2,Y3,Y4)
- ; (is_FloatNum(X4,Y4)
- -> gecode_constraint_linear_256(Y0,Y1,Y2,Y3,Y4)
+ ; (is_BoolVarArgs(X1,Y1)
+ -> (is_IntRelType(X2,Y2)
+ -> (is_int(X3,Y3)
+ -> (is_Reify(X4,Y4)
+ -> gecode_constraint_linear_260(Y0,Y1,Y2,Y3,Y4)
+ ; (is_IntConLevel(X4,Y4)
+ -> gecode_constraint_linear_259(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=5))))
- ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=4)))
- ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=3)))
- ; (is_IntVarArgs(X1,Y1)
- -> (is_IntRelType(X2,Y2)
- -> (is_int(X3,Y3)
+ ; (is_IntVar(X3,Y3)
-> (is_Reify(X4,Y4)
- -> gecode_constraint_linear_282(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_linear_264(Y0,Y1,Y2,Y3,Y4)
; (is_IntConLevel(X4,Y4)
- -> gecode_constraint_linear_281(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_linear_263(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=5))))
- ; (is_IntVar(X3,Y3)
- -> (is_Reify(X4,Y4)
- -> gecode_constraint_linear_286(Y0,Y1,Y2,Y3,Y4)
- ; (is_IntConLevel(X4,Y4)
- -> gecode_constraint_linear_285(Y0,Y1,Y2,Y3,Y4)
- ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=5))))
- ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=4))))
+ ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=4))))
+ ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=3)))
+ ; (is_FloatValArgs(X1,Y1)
+ -> (is_FloatVarArgs(X2,Y2)
+ -> (is_FloatRelType(X3,Y3)
+ -> (is_FloatVar(X4,Y4)
+ -> gecode_constraint_linear_268(Y0,Y1,Y2,Y3,Y4)
+ ; (is_FloatNum(X4,Y4)
+ -> gecode_constraint_linear_266(Y0,Y1,Y2,Y3,Y4)
+ ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=5))))
+ ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=4)))
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=3)))
; (is_IntArgs(X1,Y1)
-> (is_IntVarArgs(X2,Y2)
-> (is_IntRelType(X3,Y3)
-> (is_int(X4,Y4)
- -> gecode_constraint_linear_272(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_linear_282(Y0,Y1,Y2,Y3,Y4)
; (is_IntVar(X4,Y4)
- -> gecode_constraint_linear_276(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_linear_286(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=5))))
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=4)))
; (is_BoolVarArgs(X2,Y2)
-> (is_IntRelType(X3,Y3)
-> (is_int(X4,Y4)
- -> gecode_constraint_linear_264(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_linear_274(Y0,Y1,Y2,Y3,Y4)
; (is_IntVar(X4,Y4)
- -> gecode_constraint_linear_268(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_linear_278(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=5))))
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=4)))
; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=3))))
@@ -3266,9 +3329,9 @@ nooverlap(X0,X1,X2,X3,X4,X5) :-
-> (is_IntVarArgs(X3,Y3)
-> (is_IntArgs(X4,Y4)
-> (is_BoolVarArgs(X5,Y5)
- -> gecode_constraint_nooverlap_317(Y0,Y1,Y2,Y3,Y4,Y5)
+ -> gecode_constraint_nooverlap_327(Y0,Y1,Y2,Y3,Y4,Y5)
; (is_IntConLevel(X5,Y5)
- -> gecode_constraint_nooverlap_320(Y0,Y1,Y2,Y3,Y4,Y5)
+ -> gecode_constraint_nooverlap_330(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5),arg=6))))
; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5),arg=5)))
; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5),arg=4)))
@@ -3320,93 +3383,93 @@ rel(X0,X1,X2,X3) :-
-> (is_FloatVar(X1,Y1)
-> (is_FloatRelType(X2,Y2)
-> (is_FloatVal(X3,Y3)
- -> gecode_constraint_rel_395(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_rel_405(Y0,Y1,Y2,Y3)
; (is_FloatVar(X3,Y3)
- -> gecode_constraint_rel_397(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_rel_407(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=4))))
; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=3)))
; (is_SetOpType(X1,Y1)
-> (is_SetVarArgs(X2,Y2)
-> (is_SetVar(X3,Y3)
- -> gecode_constraint_rel_413(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_rel_423(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=4)))
; (is_IntVarArgs(X2,Y2)
-> (is_SetVar(X3,Y3)
- -> gecode_constraint_rel_411(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_rel_421(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=4)))
; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=3))))
; (is_FloatVarArgs(X1,Y1)
-> (is_FloatRelType(X2,Y2)
-> (is_FloatVal(X3,Y3)
- -> gecode_constraint_rel_383(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_rel_393(Y0,Y1,Y2,Y3)
; (is_FloatVar(X3,Y3)
- -> gecode_constraint_rel_384(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_rel_394(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=4))))
; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=3)))
; (is_BoolVarArgs(X1,Y1)
-> (is_IntRelType(X2,Y2)
-> (is_int(X3,Y3)
- -> gecode_constraint_rel_381(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_rel_391(Y0,Y1,Y2,Y3)
; (is_BoolVarArgs(X3,Y3)
- -> gecode_constraint_rel_377(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_rel_387(Y0,Y1,Y2,Y3)
; (is_BoolVar(X3,Y3)
- -> gecode_constraint_rel_375(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_rel_385(Y0,Y1,Y2,Y3)
; (is_IntConLevel(X3,Y3)
- -> gecode_constraint_rel_380(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_rel_390(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=4))))))
; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=3)))
; (is_BoolVar(X1,Y1)
-> (is_IntRelType(X2,Y2)
-> (is_int(X3,Y3)
- -> gecode_constraint_rel_371(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_rel_381(Y0,Y1,Y2,Y3)
; (is_BoolVar(X3,Y3)
- -> gecode_constraint_rel_367(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_rel_377(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=4))))
; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=3)))
; (is_IntVarArgs(X1,Y1)
-> (is_IntRelType(X2,Y2)
-> (is_int(X3,Y3)
- -> gecode_constraint_rel_391(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_rel_401(Y0,Y1,Y2,Y3)
; (is_IntVar(X3,Y3)
- -> gecode_constraint_rel_393(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_rel_403(Y0,Y1,Y2,Y3)
; (is_IntVarArgs(X3,Y3)
- -> gecode_constraint_rel_387(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_rel_397(Y0,Y1,Y2,Y3)
; (is_IntConLevel(X3,Y3)
- -> gecode_constraint_rel_390(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_rel_400(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=4))))))
; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=3)))
; (is_IntVar(X1,Y1)
-> (is_IntRelType(X2,Y2)
-> (is_int(X3,Y3)
- -> gecode_constraint_rel_399(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_rel_409(Y0,Y1,Y2,Y3)
; (is_IntVar(X3,Y3)
- -> gecode_constraint_rel_403(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_rel_413(Y0,Y1,Y2,Y3)
; (is_SetVar(X3,Y3)
- -> gecode_constraint_rel_407(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_rel_417(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=4)))))
; (is_SetRelType(X2,Y2)
-> (is_SetVar(X3,Y3)
- -> gecode_constraint_rel_408(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_rel_418(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=4)))
; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=3))))
; (is_SetVar(X1,Y1)
-> (is_IntRelType(X2,Y2)
-> (is_IntVar(X3,Y3)
- -> gecode_constraint_rel_414(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_rel_424(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=4)))
; (is_SetRelType(X2,Y2)
-> (is_IntVar(X3,Y3)
- -> gecode_constraint_rel_419(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_rel_429(Y0,Y1,Y2,Y3)
; (is_SetVar(X3,Y3)
- -> gecode_constraint_rel_421(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_rel_431(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=4))))
; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=3))))
; (is_BoolOpType(X1,Y1)
-> (is_BoolVarArgs(X2,Y2)
-> (is_int(X3,Y3)
- -> gecode_constraint_rel_361(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_rel_371(Y0,Y1,Y2,Y3)
; (is_BoolVar(X3,Y3)
- -> gecode_constraint_rel_359(Y0,Y1,Y2,Y3)
+ -> gecode_constraint_rel_369(Y0,Y1,Y2,Y3)
; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=4))))
; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=3)))
; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=2)))))))))))
@@ -3418,7 +3481,7 @@ min(X0,X1,X2,X3,X4) :-
-> (is_IntVar(X2,Y2)
-> (is_IntVar(X3,Y3)
-> (is_IntConLevel(X4,Y4)
- -> gecode_constraint_min_309(Y0,Y1,Y2,Y3,Y4)
+ -> gecode_constraint_min_319(Y0,Y1,Y2,Y3,Y4)
; throw(gecode_argument_error(min(X0,X1,X2,X3,X4),arg=5)))
; throw(gecode_argument_error(min(X0,X1,X2,X3,X4),arg=4)))
; throw(gecode_argument_error(min(X0,X1,X2,X3,X4),arg=3)))
@@ -3443,7 +3506,7 @@ ite(X0,X1,X2,X3,X4,X5) :-
-> (is_IntVar(X3,Y3)
-> (is_IntVar(X4,Y4)
-> (is_IntConLevel(X5,Y5)
- -> gecode_constraint_ite_247(Y0,Y1,Y2,Y3,Y4,Y5)
+ -> gecode_constraint_ite_257(Y0,Y1,Y2,Y3,Y4,Y5)
; throw(gecode_argument_error(ite(X0,X1,X2,X3,X4,X5),arg=6)))
; throw(gecode_argument_error(ite(X0,X1,X2,X3,X4,X5),arg=5)))
; throw(gecode_argument_error(ite(X0,X1,X2,X3,X4,X5),arg=4)))
diff --git a/library/gecode/4.2.0/gecode_yap_cc_impl_auto_generated.icc b/library/gecode/4.2.0/gecode_yap_cc_impl_auto_generated.icc
index 7ac1ab8ba..b264e3b68 100644
--- a/library/gecode/4.2.0/gecode_yap_cc_impl_auto_generated.icc
+++ b/library/gecode/4.2.0/gecode_yap_cc_impl_auto_generated.icc
@@ -174,7 +174,7 @@ static SetOpType gecode_SetOpType_from_term(YAP_Term X)
cerr << "this should never happen" << endl; exit(1);
}
-static int gecode_constraint_unary_448(void)
+static int gecode_constraint_unary_458(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
TaskTypeArgs X2 = gecode_TaskTypeArgs_from_term(YAP_ARG2);
@@ -186,7 +186,7 @@ static int gecode_constraint_unary_448(void)
return TRUE;
}
-static int gecode_constraint_unary_444(void)
+static int gecode_constraint_unary_454(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -198,7 +198,7 @@ static int gecode_constraint_unary_444(void)
return TRUE;
}
-static int gecode_constraint_nvalues_335(void)
+static int gecode_constraint_nvalues_345(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -209,7 +209,7 @@ static int gecode_constraint_nvalues_335(void)
return TRUE;
}
-static int gecode_constraint_nvalues_337(void)
+static int gecode_constraint_nvalues_347(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -220,7 +220,7 @@ static int gecode_constraint_nvalues_337(void)
return TRUE;
}
-static int gecode_constraint_nvalues_331(void)
+static int gecode_constraint_nvalues_341(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2);
@@ -231,7 +231,7 @@ static int gecode_constraint_nvalues_331(void)
return TRUE;
}
-static int gecode_constraint_nvalues_333(void)
+static int gecode_constraint_nvalues_343(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2);
@@ -242,7 +242,7 @@ static int gecode_constraint_nvalues_333(void)
return TRUE;
}
-static int gecode_constraint_max_292(void)
+static int gecode_constraint_max_302(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2);
@@ -252,7 +252,7 @@ static int gecode_constraint_max_292(void)
return TRUE;
}
-static int gecode_constraint_max_290(void)
+static int gecode_constraint_max_300(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -262,7 +262,7 @@ static int gecode_constraint_max_290(void)
return TRUE;
}
-static int gecode_constraint_max_291(void)
+static int gecode_constraint_max_301(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
FloatVar X2 = gecode_FloatVar_from_term(space,YAP_ARG2);
@@ -272,7 +272,7 @@ static int gecode_constraint_max_291(void)
return TRUE;
}
-static int gecode_constraint_max_295(void)
+static int gecode_constraint_max_305(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2);
@@ -315,7 +315,7 @@ static int gecode_constraint_convex_91(void)
return TRUE;
}
-static int gecode_constraint_nooverlap_319(void)
+static int gecode_constraint_nooverlap_329(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -488,7 +488,7 @@ static int gecode_constraint_element_228(void)
return TRUE;
}
-static int gecode_constraint_sequence_427(void)
+static int gecode_constraint_sequence_437(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
SetVarArgs X2 = gecode_SetVarArgs_from_term(space,YAP_ARG2);
@@ -496,7 +496,7 @@ static int gecode_constraint_sequence_427(void)
return TRUE;
}
-static int gecode_constraint_notMax_325(void)
+static int gecode_constraint_notMax_335(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2);
@@ -505,7 +505,7 @@ static int gecode_constraint_notMax_325(void)
return TRUE;
}
-static int gecode_constraint_ite_246(void)
+static int gecode_constraint_ite_256(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2);
@@ -516,7 +516,7 @@ static int gecode_constraint_ite_246(void)
return TRUE;
}
-static int gecode_constraint_unary_441(void)
+static int gecode_constraint_unary_451(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -525,7 +525,7 @@ static int gecode_constraint_unary_441(void)
return TRUE;
}
-static int gecode_constraint_nroot_329(void)
+static int gecode_constraint_nroot_339(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2);
@@ -696,7 +696,7 @@ static int gecode_constraint_channel_60(void)
return TRUE;
}
-static int gecode_constraint_nooverlap_321(void)
+static int gecode_constraint_nooverlap_331(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -710,7 +710,7 @@ static int gecode_constraint_nooverlap_321(void)
return TRUE;
}
-static int gecode_constraint_nooverlap_324(void)
+static int gecode_constraint_nooverlap_334(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -802,7 +802,7 @@ static int gecode_constraint_element_232(void)
return TRUE;
}
-static int gecode_constraint_max_288(void)
+static int gecode_constraint_max_298(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
FloatVarArgs X2 = gecode_FloatVarArgs_from_term(space,YAP_ARG2);
@@ -811,7 +811,7 @@ static int gecode_constraint_max_288(void)
return TRUE;
}
-static int gecode_constraint_max_289(void)
+static int gecode_constraint_max_299(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -820,7 +820,7 @@ static int gecode_constraint_max_289(void)
return TRUE;
}
-static int gecode_constraint_max_294(void)
+static int gecode_constraint_max_304(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2);
@@ -829,7 +829,7 @@ static int gecode_constraint_max_294(void)
return TRUE;
}
-static int gecode_constraint_unshare_453(void)
+static int gecode_constraint_unshare_463(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -837,7 +837,7 @@ static int gecode_constraint_unshare_453(void)
return TRUE;
}
-static int gecode_constraint_unshare_451(void)
+static int gecode_constraint_unshare_461(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2);
@@ -845,7 +845,7 @@ static int gecode_constraint_unshare_451(void)
return TRUE;
}
-static int gecode_constraint_path_348(void)
+static int gecode_constraint_path_358(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
int X2 = gecode_int_from_term(YAP_ARG2);
@@ -856,7 +856,7 @@ static int gecode_constraint_path_348(void)
return TRUE;
}
-static int gecode_constraint_path_347(void)
+static int gecode_constraint_path_357(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -906,7 +906,7 @@ static int gecode_constraint_branch_40(void)
return TRUE;
}
-static int gecode_constraint_mult_315(void)
+static int gecode_constraint_mult_325(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2);
@@ -916,7 +916,7 @@ static int gecode_constraint_mult_315(void)
return TRUE;
}
-static int gecode_constraint_mult_314(void)
+static int gecode_constraint_mult_324(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
FloatVar X2 = gecode_FloatVar_from_term(space,YAP_ARG2);
@@ -950,7 +950,7 @@ static int gecode_constraint_clause_87(void)
return TRUE;
}
-static int gecode_constraint_precede_356(void)
+static int gecode_constraint_precede_366(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -969,7 +969,7 @@ static int gecode_constraint_distinct_160(void)
return TRUE;
}
-static int gecode_constraint_member_302(void)
+static int gecode_constraint_member_312(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -979,7 +979,7 @@ static int gecode_constraint_member_302(void)
return TRUE;
}
-static int gecode_constraint_member_301(void)
+static int gecode_constraint_member_311(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -989,7 +989,7 @@ static int gecode_constraint_member_301(void)
return TRUE;
}
-static int gecode_constraint_member_298(void)
+static int gecode_constraint_member_308(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2);
@@ -999,7 +999,7 @@ static int gecode_constraint_member_298(void)
return TRUE;
}
-static int gecode_constraint_member_297(void)
+static int gecode_constraint_member_307(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2);
@@ -1009,7 +1009,7 @@ static int gecode_constraint_member_297(void)
return TRUE;
}
-static int gecode_constraint_mod_313(void)
+static int gecode_constraint_mod_323(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2);
@@ -1047,7 +1047,29 @@ static int gecode_constraint_channelSorted_73(void)
return TRUE;
}
-static int gecode_constraint_linear_262(void)
+static int gecode_constraint_extensional_253(void)
+{
+ GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
+ IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
+ TupleSet X3 = gecode_TupleSet_from_term(YAP_ARG3);
+ ExtensionalPropKind X4 = gecode_ExtensionalPropKind_from_term(YAP_ARG4);
+ IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5);
+ extensional(*space,X2,X3,X4,X5);
+ return TRUE;
+}
+
+static int gecode_constraint_extensional_248(void)
+{
+ GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
+ BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2);
+ TupleSet X3 = gecode_TupleSet_from_term(YAP_ARG3);
+ ExtensionalPropKind X4 = gecode_ExtensionalPropKind_from_term(YAP_ARG4);
+ IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5);
+ extensional(*space,X2,X3,X4,X5);
+ return TRUE;
+}
+
+static int gecode_constraint_linear_272(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
FloatVarArgs X2 = gecode_FloatVarArgs_from_term(space,YAP_ARG2);
@@ -1057,7 +1079,7 @@ static int gecode_constraint_linear_262(void)
return TRUE;
}
-static int gecode_constraint_linear_260(void)
+static int gecode_constraint_linear_270(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
FloatVarArgs X2 = gecode_FloatVarArgs_from_term(space,YAP_ARG2);
@@ -1067,7 +1089,7 @@ static int gecode_constraint_linear_260(void)
return TRUE;
}
-static int gecode_constraint_linear_248(void)
+static int gecode_constraint_linear_258(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2);
@@ -1077,7 +1099,7 @@ static int gecode_constraint_linear_248(void)
return TRUE;
}
-static int gecode_constraint_linear_252(void)
+static int gecode_constraint_linear_262(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2);
@@ -1087,7 +1109,7 @@ static int gecode_constraint_linear_252(void)
return TRUE;
}
-static int gecode_constraint_linear_280(void)
+static int gecode_constraint_linear_290(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -1097,7 +1119,7 @@ static int gecode_constraint_linear_280(void)
return TRUE;
}
-static int gecode_constraint_linear_284(void)
+static int gecode_constraint_linear_294(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -1115,7 +1137,7 @@ static int gecode_constraint_circuit_82(void)
return TRUE;
}
-static int gecode_constraint_rel_396(void)
+static int gecode_constraint_rel_406(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
FloatVar X2 = gecode_FloatVar_from_term(space,YAP_ARG2);
@@ -1126,7 +1148,7 @@ static int gecode_constraint_rel_396(void)
return TRUE;
}
-static int gecode_constraint_rel_398(void)
+static int gecode_constraint_rel_408(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
FloatVar X2 = gecode_FloatVar_from_term(space,YAP_ARG2);
@@ -1137,7 +1159,7 @@ static int gecode_constraint_rel_398(void)
return TRUE;
}
-static int gecode_constraint_rel_412(void)
+static int gecode_constraint_rel_422(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
SetOpType X2 = gecode_SetOpType_from_term(YAP_ARG2);
@@ -1148,7 +1170,7 @@ static int gecode_constraint_rel_412(void)
return TRUE;
}
-static int gecode_constraint_rel_410(void)
+static int gecode_constraint_rel_420(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
SetOpType X2 = gecode_SetOpType_from_term(YAP_ARG2);
@@ -1159,7 +1181,7 @@ static int gecode_constraint_rel_410(void)
return TRUE;
}
-static int gecode_constraint_rel_382(void)
+static int gecode_constraint_rel_392(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2);
@@ -1170,7 +1192,7 @@ static int gecode_constraint_rel_382(void)
return TRUE;
}
-static int gecode_constraint_rel_378(void)
+static int gecode_constraint_rel_388(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2);
@@ -1181,7 +1203,7 @@ static int gecode_constraint_rel_378(void)
return TRUE;
}
-static int gecode_constraint_rel_376(void)
+static int gecode_constraint_rel_386(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2);
@@ -1192,7 +1214,7 @@ static int gecode_constraint_rel_376(void)
return TRUE;
}
-static int gecode_constraint_rel_373(void)
+static int gecode_constraint_rel_383(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2);
@@ -1203,7 +1225,7 @@ static int gecode_constraint_rel_373(void)
return TRUE;
}
-static int gecode_constraint_rel_372(void)
+static int gecode_constraint_rel_382(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2);
@@ -1214,7 +1236,7 @@ static int gecode_constraint_rel_372(void)
return TRUE;
}
-static int gecode_constraint_rel_369(void)
+static int gecode_constraint_rel_379(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2);
@@ -1225,7 +1247,7 @@ static int gecode_constraint_rel_369(void)
return TRUE;
}
-static int gecode_constraint_rel_368(void)
+static int gecode_constraint_rel_378(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2);
@@ -1236,7 +1258,7 @@ static int gecode_constraint_rel_368(void)
return TRUE;
}
-static int gecode_constraint_rel_365(void)
+static int gecode_constraint_rel_375(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2);
@@ -1247,7 +1269,7 @@ static int gecode_constraint_rel_365(void)
return TRUE;
}
-static int gecode_constraint_rel_363(void)
+static int gecode_constraint_rel_373(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2);
@@ -1258,7 +1280,7 @@ static int gecode_constraint_rel_363(void)
return TRUE;
}
-static int gecode_constraint_rel_392(void)
+static int gecode_constraint_rel_402(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -1269,7 +1291,7 @@ static int gecode_constraint_rel_392(void)
return TRUE;
}
-static int gecode_constraint_rel_394(void)
+static int gecode_constraint_rel_404(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -1280,7 +1302,7 @@ static int gecode_constraint_rel_394(void)
return TRUE;
}
-static int gecode_constraint_rel_388(void)
+static int gecode_constraint_rel_398(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -1291,7 +1313,7 @@ static int gecode_constraint_rel_388(void)
return TRUE;
}
-static int gecode_constraint_rel_401(void)
+static int gecode_constraint_rel_411(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2);
@@ -1302,7 +1324,7 @@ static int gecode_constraint_rel_401(void)
return TRUE;
}
-static int gecode_constraint_rel_400(void)
+static int gecode_constraint_rel_410(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2);
@@ -1313,7 +1335,7 @@ static int gecode_constraint_rel_400(void)
return TRUE;
}
-static int gecode_constraint_rel_405(void)
+static int gecode_constraint_rel_415(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2);
@@ -1324,7 +1346,7 @@ static int gecode_constraint_rel_405(void)
return TRUE;
}
-static int gecode_constraint_rel_404(void)
+static int gecode_constraint_rel_414(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2);
@@ -1335,7 +1357,7 @@ static int gecode_constraint_rel_404(void)
return TRUE;
}
-static int gecode_constraint_rel_409(void)
+static int gecode_constraint_rel_419(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2);
@@ -1346,7 +1368,7 @@ static int gecode_constraint_rel_409(void)
return TRUE;
}
-static int gecode_constraint_rel_420(void)
+static int gecode_constraint_rel_430(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2);
@@ -1357,7 +1379,7 @@ static int gecode_constraint_rel_420(void)
return TRUE;
}
-static int gecode_constraint_rel_422(void)
+static int gecode_constraint_rel_432(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2);
@@ -1368,7 +1390,7 @@ static int gecode_constraint_rel_422(void)
return TRUE;
}
-static int gecode_constraint_rel_362(void)
+static int gecode_constraint_rel_372(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolOpType X2 = gecode_BoolOpType_from_term(YAP_ARG2);
@@ -1379,7 +1401,7 @@ static int gecode_constraint_rel_362(void)
return TRUE;
}
-static int gecode_constraint_rel_360(void)
+static int gecode_constraint_rel_370(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolOpType X2 = gecode_BoolOpType_from_term(YAP_ARG2);
@@ -1390,7 +1412,7 @@ static int gecode_constraint_rel_360(void)
return TRUE;
}
-static int gecode_constraint_min_308(void)
+static int gecode_constraint_min_318(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2);
@@ -1400,7 +1422,7 @@ static int gecode_constraint_min_308(void)
return TRUE;
}
-static int gecode_constraint_min_306(void)
+static int gecode_constraint_min_316(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -1410,7 +1432,7 @@ static int gecode_constraint_min_306(void)
return TRUE;
}
-static int gecode_constraint_min_307(void)
+static int gecode_constraint_min_317(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
FloatVar X2 = gecode_FloatVar_from_term(space,YAP_ARG2);
@@ -1420,7 +1442,7 @@ static int gecode_constraint_min_307(void)
return TRUE;
}
-static int gecode_constraint_min_311(void)
+static int gecode_constraint_min_321(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2);
@@ -1500,7 +1522,7 @@ static int gecode_constraint_count_96(void)
return TRUE;
}
-static int gecode_constraint_sqrt_437(void)
+static int gecode_constraint_sqrt_447(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2);
@@ -1509,7 +1531,7 @@ static int gecode_constraint_sqrt_437(void)
return TRUE;
}
-static int gecode_constraint_sqrt_436(void)
+static int gecode_constraint_sqrt_446(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
FloatVar X2 = gecode_FloatVar_from_term(space,YAP_ARG2);
@@ -1638,7 +1660,7 @@ static int gecode_constraint_cumulatives_143(void)
return TRUE;
}
-static int gecode_constraint_nvalues_334(void)
+static int gecode_constraint_nvalues_344(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -1648,7 +1670,7 @@ static int gecode_constraint_nvalues_334(void)
return TRUE;
}
-static int gecode_constraint_nvalues_336(void)
+static int gecode_constraint_nvalues_346(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -1658,7 +1680,7 @@ static int gecode_constraint_nvalues_336(void)
return TRUE;
}
-static int gecode_constraint_nvalues_330(void)
+static int gecode_constraint_nvalues_340(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2);
@@ -1668,7 +1690,7 @@ static int gecode_constraint_nvalues_330(void)
return TRUE;
}
-static int gecode_constraint_nvalues_332(void)
+static int gecode_constraint_nvalues_342(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2);
@@ -1688,7 +1710,7 @@ static int gecode_constraint_binpacking_54(void)
return TRUE;
}
-static int gecode_constraint_linear_275(void)
+static int gecode_constraint_linear_285(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2);
@@ -1701,7 +1723,7 @@ static int gecode_constraint_linear_275(void)
return TRUE;
}
-static int gecode_constraint_linear_279(void)
+static int gecode_constraint_linear_289(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2);
@@ -1714,7 +1736,7 @@ static int gecode_constraint_linear_279(void)
return TRUE;
}
-static int gecode_constraint_linear_267(void)
+static int gecode_constraint_linear_277(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2);
@@ -1727,7 +1749,7 @@ static int gecode_constraint_linear_267(void)
return TRUE;
}
-static int gecode_constraint_linear_271(void)
+static int gecode_constraint_linear_281(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2);
@@ -1778,7 +1800,7 @@ static int gecode_constraint_div_162(void)
return TRUE;
}
-static int gecode_constraint_rel_402(void)
+static int gecode_constraint_rel_412(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2);
@@ -1790,7 +1812,7 @@ static int gecode_constraint_rel_402(void)
return TRUE;
}
-static int gecode_constraint_rel_406(void)
+static int gecode_constraint_rel_416(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2);
@@ -1802,7 +1824,7 @@ static int gecode_constraint_rel_406(void)
return TRUE;
}
-static int gecode_constraint_rel_385(void)
+static int gecode_constraint_rel_395(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntSet X2 = gecode_IntSet_from_term(YAP_ARG2);
@@ -1814,7 +1836,7 @@ static int gecode_constraint_rel_385(void)
return TRUE;
}
-static int gecode_constraint_rel_386(void)
+static int gecode_constraint_rel_396(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntSet X2 = gecode_IntSet_from_term(YAP_ARG2);
@@ -1826,7 +1848,7 @@ static int gecode_constraint_rel_386(void)
return TRUE;
}
-static int gecode_constraint_rel_374(void)
+static int gecode_constraint_rel_384(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2);
@@ -1838,7 +1860,7 @@ static int gecode_constraint_rel_374(void)
return TRUE;
}
-static int gecode_constraint_rel_370(void)
+static int gecode_constraint_rel_380(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2);
@@ -1850,7 +1872,7 @@ static int gecode_constraint_rel_370(void)
return TRUE;
}
-static int gecode_constraint_rel_366(void)
+static int gecode_constraint_rel_376(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2);
@@ -1862,7 +1884,7 @@ static int gecode_constraint_rel_366(void)
return TRUE;
}
-static int gecode_constraint_rel_364(void)
+static int gecode_constraint_rel_374(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2);
@@ -1874,7 +1896,7 @@ static int gecode_constraint_rel_364(void)
return TRUE;
}
-static int gecode_constraint_rel_415(void)
+static int gecode_constraint_rel_425(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2);
@@ -1886,7 +1908,7 @@ static int gecode_constraint_rel_415(void)
return TRUE;
}
-static int gecode_constraint_rel_416(void)
+static int gecode_constraint_rel_426(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2);
@@ -1898,7 +1920,7 @@ static int gecode_constraint_rel_416(void)
return TRUE;
}
-static int gecode_constraint_rel_417(void)
+static int gecode_constraint_rel_427(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2);
@@ -1910,7 +1932,7 @@ static int gecode_constraint_rel_417(void)
return TRUE;
}
-static int gecode_constraint_rel_418(void)
+static int gecode_constraint_rel_428(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2);
@@ -1922,7 +1944,7 @@ static int gecode_constraint_rel_418(void)
return TRUE;
}
-static int gecode_constraint_weights_455(void)
+static int gecode_constraint_weights_465(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2);
@@ -1933,7 +1955,7 @@ static int gecode_constraint_weights_455(void)
return TRUE;
}
-static int gecode_constraint_max_293(void)
+static int gecode_constraint_max_303(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2);
@@ -1944,7 +1966,7 @@ static int gecode_constraint_max_293(void)
return TRUE;
}
-static int gecode_constraint_path_343(void)
+static int gecode_constraint_path_353(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2);
@@ -1959,7 +1981,7 @@ static int gecode_constraint_path_343(void)
return TRUE;
}
-static int gecode_constraint_unary_449(void)
+static int gecode_constraint_unary_459(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
TaskTypeArgs X2 = gecode_TaskTypeArgs_from_term(YAP_ARG2);
@@ -1969,7 +1991,7 @@ static int gecode_constraint_unary_449(void)
return TRUE;
}
-static int gecode_constraint_unary_445(void)
+static int gecode_constraint_unary_455(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -1979,7 +2001,7 @@ static int gecode_constraint_unary_445(void)
return TRUE;
}
-static int gecode_constraint_unary_439(void)
+static int gecode_constraint_unary_449(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -1989,7 +2011,7 @@ static int gecode_constraint_unary_439(void)
return TRUE;
}
-static int gecode_constraint_unary_442(void)
+static int gecode_constraint_unary_452(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -1999,7 +2021,7 @@ static int gecode_constraint_unary_442(void)
return TRUE;
}
-static int gecode_constraint_nroot_328(void)
+static int gecode_constraint_nroot_338(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2);
@@ -2009,7 +2031,7 @@ static int gecode_constraint_nroot_328(void)
return TRUE;
}
-static int gecode_constraint_nroot_327(void)
+static int gecode_constraint_nroot_337(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
FloatVar X2 = gecode_FloatVar_from_term(space,YAP_ARG2);
@@ -2019,7 +2041,7 @@ static int gecode_constraint_nroot_327(void)
return TRUE;
}
-static int gecode_constraint_sorted_430(void)
+static int gecode_constraint_sorted_440(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -2337,7 +2359,7 @@ static int gecode_constraint_assign_14(void)
return TRUE;
}
-static int gecode_constraint_rel_389(void)
+static int gecode_constraint_rel_399(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -2346,7 +2368,7 @@ static int gecode_constraint_rel_389(void)
return TRUE;
}
-static int gecode_constraint_rel_379(void)
+static int gecode_constraint_rel_389(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2);
@@ -2355,7 +2377,7 @@ static int gecode_constraint_rel_379(void)
return TRUE;
}
-static int gecode_constraint_path_346(void)
+static int gecode_constraint_path_356(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -2445,7 +2467,7 @@ static int gecode_constraint_branch_49(void)
return TRUE;
}
-static int gecode_constraint_mult_316(void)
+static int gecode_constraint_mult_326(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2);
@@ -2514,7 +2536,7 @@ static int gecode_constraint_clause_86(void)
return TRUE;
}
-static int gecode_constraint_precede_358(void)
+static int gecode_constraint_precede_368(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
SetVarArgs X2 = gecode_SetVarArgs_from_term(space,YAP_ARG2);
@@ -2524,7 +2546,7 @@ static int gecode_constraint_precede_358(void)
return TRUE;
}
-static int gecode_constraint_precede_355(void)
+static int gecode_constraint_precede_365(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -2534,7 +2556,7 @@ static int gecode_constraint_precede_355(void)
return TRUE;
}
-static int gecode_constraint_precede_354(void)
+static int gecode_constraint_precede_364(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -2704,7 +2726,7 @@ static int gecode_constraint_distinct_158(void)
return TRUE;
}
-static int gecode_constraint_member_303(void)
+static int gecode_constraint_member_313(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -2715,7 +2737,7 @@ static int gecode_constraint_member_303(void)
return TRUE;
}
-static int gecode_constraint_member_299(void)
+static int gecode_constraint_member_309(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2);
@@ -2726,7 +2748,7 @@ static int gecode_constraint_member_299(void)
return TRUE;
}
-static int gecode_constraint_mod_312(void)
+static int gecode_constraint_mod_322(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2);
@@ -2736,7 +2758,7 @@ static int gecode_constraint_mod_312(void)
return TRUE;
}
-static int gecode_constraint_sqr_434(void)
+static int gecode_constraint_sqr_444(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2);
@@ -2745,7 +2767,7 @@ static int gecode_constraint_sqr_434(void)
return TRUE;
}
-static int gecode_constraint_sqr_433(void)
+static int gecode_constraint_sqr_443(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
FloatVar X2 = gecode_FloatVar_from_term(space,YAP_ARG2);
@@ -2754,7 +2776,7 @@ static int gecode_constraint_sqr_433(void)
return TRUE;
}
-static int gecode_constraint_sequence_426(void)
+static int gecode_constraint_sequence_436(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -2767,7 +2789,7 @@ static int gecode_constraint_sequence_426(void)
return TRUE;
}
-static int gecode_constraint_sequence_424(void)
+static int gecode_constraint_sequence_434(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2);
@@ -2780,7 +2802,7 @@ static int gecode_constraint_sequence_424(void)
return TRUE;
}
-static int gecode_constraint_path_344(void)
+static int gecode_constraint_path_354(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2);
@@ -2793,7 +2815,7 @@ static int gecode_constraint_path_344(void)
return TRUE;
}
-static int gecode_constraint_path_341(void)
+static int gecode_constraint_path_351(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2);
@@ -2806,7 +2828,7 @@ static int gecode_constraint_path_341(void)
return TRUE;
}
-static int gecode_constraint_path_338(void)
+static int gecode_constraint_path_348(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2);
@@ -2831,7 +2853,7 @@ static int gecode_constraint_divmod_166(void)
return TRUE;
}
-static int gecode_constraint_sorted_431(void)
+static int gecode_constraint_sorted_441(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -2840,6 +2862,46 @@ static int gecode_constraint_sorted_431(void)
return TRUE;
}
+static int gecode_constraint_extensional_252(void)
+{
+ GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
+ IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
+ TupleSet X3 = gecode_TupleSet_from_term(YAP_ARG3);
+ ExtensionalPropKind X4 = gecode_ExtensionalPropKind_from_term(YAP_ARG4);
+ extensional(*space,X2,X3,X4);
+ return TRUE;
+}
+
+static int gecode_constraint_extensional_255(void)
+{
+ GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
+ IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
+ DFA X3 = gecode_DFA_from_term(YAP_ARG3);
+ IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4);
+ extensional(*space,X2,X3,X4);
+ return TRUE;
+}
+
+static int gecode_constraint_extensional_247(void)
+{
+ GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
+ BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2);
+ TupleSet X3 = gecode_TupleSet_from_term(YAP_ARG3);
+ ExtensionalPropKind X4 = gecode_ExtensionalPropKind_from_term(YAP_ARG4);
+ extensional(*space,X2,X3,X4);
+ return TRUE;
+}
+
+static int gecode_constraint_extensional_250(void)
+{
+ GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
+ BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2);
+ DFA X3 = gecode_DFA_from_term(YAP_ARG3);
+ IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4);
+ extensional(*space,X2,X3,X4);
+ return TRUE;
+}
+
static int gecode_constraint_circuit_84(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
@@ -3174,7 +3236,43 @@ static int gecode_constraint_binpacking_55(void)
return TRUE;
}
-static int gecode_constraint_linear_283(void)
+static int gecode_constraint_extensional_251(void)
+{
+ GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
+ IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
+ TupleSet X3 = gecode_TupleSet_from_term(YAP_ARG3);
+ extensional(*space,X2,X3);
+ return TRUE;
+}
+
+static int gecode_constraint_extensional_254(void)
+{
+ GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
+ IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
+ DFA X3 = gecode_DFA_from_term(YAP_ARG3);
+ extensional(*space,X2,X3);
+ return TRUE;
+}
+
+static int gecode_constraint_extensional_246(void)
+{
+ GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
+ BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2);
+ TupleSet X3 = gecode_TupleSet_from_term(YAP_ARG3);
+ extensional(*space,X2,X3);
+ return TRUE;
+}
+
+static int gecode_constraint_extensional_249(void)
+{
+ GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
+ BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2);
+ DFA X3 = gecode_DFA_from_term(YAP_ARG3);
+ extensional(*space,X2,X3);
+ return TRUE;
+}
+
+static int gecode_constraint_linear_293(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -3186,7 +3284,7 @@ static int gecode_constraint_linear_283(void)
return TRUE;
}
-static int gecode_constraint_linear_287(void)
+static int gecode_constraint_linear_297(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -3198,7 +3296,7 @@ static int gecode_constraint_linear_287(void)
return TRUE;
}
-static int gecode_constraint_linear_251(void)
+static int gecode_constraint_linear_261(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2);
@@ -3210,7 +3308,7 @@ static int gecode_constraint_linear_251(void)
return TRUE;
}
-static int gecode_constraint_linear_255(void)
+static int gecode_constraint_linear_265(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2);
@@ -3222,7 +3320,7 @@ static int gecode_constraint_linear_255(void)
return TRUE;
}
-static int gecode_constraint_linear_259(void)
+static int gecode_constraint_linear_269(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
FloatValArgs X2 = gecode_FloatValArgs_from_term(YAP_ARG2);
@@ -3234,7 +3332,7 @@ static int gecode_constraint_linear_259(void)
return TRUE;
}
-static int gecode_constraint_linear_257(void)
+static int gecode_constraint_linear_267(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
FloatValArgs X2 = gecode_FloatValArgs_from_term(YAP_ARG2);
@@ -3246,7 +3344,7 @@ static int gecode_constraint_linear_257(void)
return TRUE;
}
-static int gecode_constraint_linear_274(void)
+static int gecode_constraint_linear_284(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2);
@@ -3258,7 +3356,7 @@ static int gecode_constraint_linear_274(void)
return TRUE;
}
-static int gecode_constraint_linear_273(void)
+static int gecode_constraint_linear_283(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2);
@@ -3270,7 +3368,7 @@ static int gecode_constraint_linear_273(void)
return TRUE;
}
-static int gecode_constraint_linear_278(void)
+static int gecode_constraint_linear_288(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2);
@@ -3282,7 +3380,7 @@ static int gecode_constraint_linear_278(void)
return TRUE;
}
-static int gecode_constraint_linear_277(void)
+static int gecode_constraint_linear_287(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2);
@@ -3294,7 +3392,7 @@ static int gecode_constraint_linear_277(void)
return TRUE;
}
-static int gecode_constraint_linear_266(void)
+static int gecode_constraint_linear_276(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2);
@@ -3306,7 +3404,7 @@ static int gecode_constraint_linear_266(void)
return TRUE;
}
-static int gecode_constraint_linear_265(void)
+static int gecode_constraint_linear_275(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2);
@@ -3318,7 +3416,7 @@ static int gecode_constraint_linear_265(void)
return TRUE;
}
-static int gecode_constraint_linear_270(void)
+static int gecode_constraint_linear_280(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2);
@@ -3330,7 +3428,7 @@ static int gecode_constraint_linear_270(void)
return TRUE;
}
-static int gecode_constraint_linear_269(void)
+static int gecode_constraint_linear_279(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2);
@@ -3342,7 +3440,7 @@ static int gecode_constraint_linear_269(void)
return TRUE;
}
-static int gecode_constraint_nooverlap_323(void)
+static int gecode_constraint_nooverlap_333(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -3355,7 +3453,7 @@ static int gecode_constraint_nooverlap_323(void)
return TRUE;
}
-static int gecode_constraint_nooverlap_318(void)
+static int gecode_constraint_nooverlap_328(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -3379,7 +3477,7 @@ static int gecode_constraint_div_164(void)
return TRUE;
}
-static int gecode_constraint_sqr_435(void)
+static int gecode_constraint_sqr_445(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2);
@@ -3389,7 +3487,7 @@ static int gecode_constraint_sqr_435(void)
return TRUE;
}
-static int gecode_constraint_path_345(void)
+static int gecode_constraint_path_355(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2);
@@ -3403,7 +3501,7 @@ static int gecode_constraint_path_345(void)
return TRUE;
}
-static int gecode_constraint_path_342(void)
+static int gecode_constraint_path_352(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2);
@@ -3417,7 +3515,7 @@ static int gecode_constraint_path_342(void)
return TRUE;
}
-static int gecode_constraint_path_339(void)
+static int gecode_constraint_path_349(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2);
@@ -3431,7 +3529,7 @@ static int gecode_constraint_path_339(void)
return TRUE;
}
-static int gecode_constraint_unary_447(void)
+static int gecode_constraint_unary_457(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
TaskTypeArgs X2 = gecode_TaskTypeArgs_from_term(YAP_ARG2);
@@ -3442,40 +3540,40 @@ static int gecode_constraint_unary_447(void)
return TRUE;
}
+static int gecode_constraint_unary_460(void)
+{
+ GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
+ TaskTypeArgs X2 = gecode_TaskTypeArgs_from_term(YAP_ARG2);
+ IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3);
+ IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4);
+ IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5);
+ unary(*space,X2,X3,X4,X5);
+ return TRUE;
+}
+
+static int gecode_constraint_unary_453(void)
+{
+ GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
+ IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
+ IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3);
+ IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4);
+ BoolVarArgs X5 = gecode_BoolVarArgs_from_term(space,YAP_ARG5);
+ unary(*space,X2,X3,X4,X5);
+ return TRUE;
+}
+
+static int gecode_constraint_unary_456(void)
+{
+ GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
+ IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
+ IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3);
+ IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4);
+ IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5);
+ unary(*space,X2,X3,X4,X5);
+ return TRUE;
+}
+
static int gecode_constraint_unary_450(void)
-{
- GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
- TaskTypeArgs X2 = gecode_TaskTypeArgs_from_term(YAP_ARG2);
- IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3);
- IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4);
- IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5);
- unary(*space,X2,X3,X4,X5);
- return TRUE;
-}
-
-static int gecode_constraint_unary_443(void)
-{
- GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
- IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
- IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3);
- IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4);
- BoolVarArgs X5 = gecode_BoolVarArgs_from_term(space,YAP_ARG5);
- unary(*space,X2,X3,X4,X5);
- return TRUE;
-}
-
-static int gecode_constraint_unary_446(void)
-{
- GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
- IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
- IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3);
- IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4);
- IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5);
- unary(*space,X2,X3,X4,X5);
- return TRUE;
-}
-
-static int gecode_constraint_unary_440(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -3486,7 +3584,7 @@ static int gecode_constraint_unary_440(void)
return TRUE;
}
-static int gecode_constraint_sorted_429(void)
+static int gecode_constraint_sorted_439(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -3496,7 +3594,7 @@ static int gecode_constraint_sorted_429(void)
return TRUE;
}
-static int gecode_constraint_sorted_432(void)
+static int gecode_constraint_sorted_442(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -3763,7 +3861,7 @@ static int gecode_constraint_element_229(void)
return TRUE;
}
-static int gecode_constraint_sequence_428(void)
+static int gecode_constraint_sequence_438(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
SetVarArgs X2 = gecode_SetVarArgs_from_term(space,YAP_ARG2);
@@ -3862,7 +3960,7 @@ static int gecode_constraint_circuit_79(void)
return TRUE;
}
-static int gecode_constraint_pow_351(void)
+static int gecode_constraint_pow_361(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2);
@@ -3872,7 +3970,7 @@ static int gecode_constraint_pow_351(void)
return TRUE;
}
-static int gecode_constraint_pow_350(void)
+static int gecode_constraint_pow_360(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
FloatVar X2 = gecode_FloatVar_from_term(space,YAP_ARG2);
@@ -3882,7 +3980,7 @@ static int gecode_constraint_pow_350(void)
return TRUE;
}
-static int gecode_constraint_precede_357(void)
+static int gecode_constraint_precede_367(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
SetVarArgs X2 = gecode_SetVarArgs_from_term(space,YAP_ARG2);
@@ -3891,7 +3989,7 @@ static int gecode_constraint_precede_357(void)
return TRUE;
}
-static int gecode_constraint_precede_353(void)
+static int gecode_constraint_precede_363(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -4006,7 +4104,7 @@ static int gecode_constraint_distinct_159(void)
return TRUE;
}
-static int gecode_constraint_min_304(void)
+static int gecode_constraint_min_314(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
FloatVarArgs X2 = gecode_FloatVarArgs_from_term(space,YAP_ARG2);
@@ -4015,7 +4113,7 @@ static int gecode_constraint_min_304(void)
return TRUE;
}
-static int gecode_constraint_min_305(void)
+static int gecode_constraint_min_315(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -4024,7 +4122,7 @@ static int gecode_constraint_min_305(void)
return TRUE;
}
-static int gecode_constraint_min_310(void)
+static int gecode_constraint_min_320(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2);
@@ -4033,7 +4131,7 @@ static int gecode_constraint_min_310(void)
return TRUE;
}
-static int gecode_constraint_sqrt_438(void)
+static int gecode_constraint_sqrt_448(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2);
@@ -4043,7 +4141,7 @@ static int gecode_constraint_sqrt_438(void)
return TRUE;
}
-static int gecode_constraint_sequence_425(void)
+static int gecode_constraint_sequence_435(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -4055,7 +4153,7 @@ static int gecode_constraint_sequence_425(void)
return TRUE;
}
-static int gecode_constraint_sequence_423(void)
+static int gecode_constraint_sequence_433(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2);
@@ -4067,7 +4165,7 @@ static int gecode_constraint_sequence_423(void)
return TRUE;
}
-static int gecode_constraint_unshare_454(void)
+static int gecode_constraint_unshare_464(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -4076,7 +4174,7 @@ static int gecode_constraint_unshare_454(void)
return TRUE;
}
-static int gecode_constraint_unshare_452(void)
+static int gecode_constraint_unshare_462(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2);
@@ -4085,7 +4183,7 @@ static int gecode_constraint_unshare_452(void)
return TRUE;
}
-static int gecode_constraint_path_349(void)
+static int gecode_constraint_path_359(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
int X2 = gecode_int_from_term(YAP_ARG2);
@@ -4097,7 +4195,7 @@ static int gecode_constraint_path_349(void)
return TRUE;
}
-static int gecode_constraint_path_340(void)
+static int gecode_constraint_path_350(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2);
@@ -4204,7 +4302,7 @@ static int gecode_constraint_branch_39(void)
return TRUE;
}
-static int gecode_constraint_nooverlap_322(void)
+static int gecode_constraint_nooverlap_332(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -4241,7 +4339,7 @@ static int gecode_constraint_cumulative_132(void)
return TRUE;
}
-static int gecode_constraint_member_300(void)
+static int gecode_constraint_member_310(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -4250,7 +4348,7 @@ static int gecode_constraint_member_300(void)
return TRUE;
}
-static int gecode_constraint_member_296(void)
+static int gecode_constraint_member_306(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2);
@@ -4355,7 +4453,7 @@ static int gecode_constraint_count_95(void)
return TRUE;
}
-static int gecode_constraint_pow_352(void)
+static int gecode_constraint_pow_362(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2);
@@ -4366,7 +4464,7 @@ static int gecode_constraint_pow_352(void)
return TRUE;
}
-static int gecode_constraint_notMin_326(void)
+static int gecode_constraint_notMin_336(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2);
@@ -4593,7 +4691,51 @@ static int gecode_constraint_dom_211(void)
return TRUE;
}
-static int gecode_constraint_linear_263(void)
+static int gecode_constraint_linear_292(void)
+{
+ GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
+ IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
+ IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3);
+ int X4 = gecode_int_from_term(YAP_ARG4);
+ Reify X5 = gecode_Reify_from_term(YAP_ARG5);
+ linear(*space,X2,X3,X4,X5);
+ return TRUE;
+}
+
+static int gecode_constraint_linear_291(void)
+{
+ GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
+ IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
+ IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3);
+ int X4 = gecode_int_from_term(YAP_ARG4);
+ IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5);
+ linear(*space,X2,X3,X4,X5);
+ return TRUE;
+}
+
+static int gecode_constraint_linear_296(void)
+{
+ GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
+ IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
+ IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3);
+ IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4);
+ Reify X5 = gecode_Reify_from_term(YAP_ARG5);
+ linear(*space,X2,X3,X4,X5);
+ return TRUE;
+}
+
+static int gecode_constraint_linear_295(void)
+{
+ GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
+ IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
+ IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3);
+ IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4);
+ IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5);
+ linear(*space,X2,X3,X4,X5);
+ return TRUE;
+}
+
+static int gecode_constraint_linear_273(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
FloatVarArgs X2 = gecode_FloatVarArgs_from_term(space,YAP_ARG2);
@@ -4604,7 +4746,7 @@ static int gecode_constraint_linear_263(void)
return TRUE;
}
-static int gecode_constraint_linear_261(void)
+static int gecode_constraint_linear_271(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
FloatVarArgs X2 = gecode_FloatVarArgs_from_term(space,YAP_ARG2);
@@ -4615,7 +4757,7 @@ static int gecode_constraint_linear_261(void)
return TRUE;
}
-static int gecode_constraint_linear_250(void)
+static int gecode_constraint_linear_260(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2);
@@ -4626,7 +4768,7 @@ static int gecode_constraint_linear_250(void)
return TRUE;
}
-static int gecode_constraint_linear_249(void)
+static int gecode_constraint_linear_259(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2);
@@ -4637,7 +4779,7 @@ static int gecode_constraint_linear_249(void)
return TRUE;
}
-static int gecode_constraint_linear_254(void)
+static int gecode_constraint_linear_264(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2);
@@ -4648,7 +4790,7 @@ static int gecode_constraint_linear_254(void)
return TRUE;
}
-static int gecode_constraint_linear_253(void)
+static int gecode_constraint_linear_263(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2);
@@ -4659,7 +4801,7 @@ static int gecode_constraint_linear_253(void)
return TRUE;
}
-static int gecode_constraint_linear_258(void)
+static int gecode_constraint_linear_268(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
FloatValArgs X2 = gecode_FloatValArgs_from_term(YAP_ARG2);
@@ -4670,7 +4812,7 @@ static int gecode_constraint_linear_258(void)
return TRUE;
}
-static int gecode_constraint_linear_256(void)
+static int gecode_constraint_linear_266(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
FloatValArgs X2 = gecode_FloatValArgs_from_term(YAP_ARG2);
@@ -4684,59 +4826,15 @@ static int gecode_constraint_linear_256(void)
static int gecode_constraint_linear_282(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
- IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
- IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3);
- int X4 = gecode_int_from_term(YAP_ARG4);
- Reify X5 = gecode_Reify_from_term(YAP_ARG5);
- linear(*space,X2,X3,X4,X5);
- return TRUE;
-}
-
-static int gecode_constraint_linear_281(void)
-{
- GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
- IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
- IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3);
- int X4 = gecode_int_from_term(YAP_ARG4);
- IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5);
+ IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2);
+ IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3);
+ IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4);
+ int X5 = gecode_int_from_term(YAP_ARG5);
linear(*space,X2,X3,X4,X5);
return TRUE;
}
static int gecode_constraint_linear_286(void)
-{
- GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
- IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
- IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3);
- IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4);
- Reify X5 = gecode_Reify_from_term(YAP_ARG5);
- linear(*space,X2,X3,X4,X5);
- return TRUE;
-}
-
-static int gecode_constraint_linear_285(void)
-{
- GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
- IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
- IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3);
- IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4);
- IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5);
- linear(*space,X2,X3,X4,X5);
- return TRUE;
-}
-
-static int gecode_constraint_linear_272(void)
-{
- GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
- IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2);
- IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3);
- IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4);
- int X5 = gecode_int_from_term(YAP_ARG5);
- linear(*space,X2,X3,X4,X5);
- return TRUE;
-}
-
-static int gecode_constraint_linear_276(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2);
@@ -4747,7 +4845,7 @@ static int gecode_constraint_linear_276(void)
return TRUE;
}
-static int gecode_constraint_linear_264(void)
+static int gecode_constraint_linear_274(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2);
@@ -4758,7 +4856,7 @@ static int gecode_constraint_linear_264(void)
return TRUE;
}
-static int gecode_constraint_linear_268(void)
+static int gecode_constraint_linear_278(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2);
@@ -4769,7 +4867,7 @@ static int gecode_constraint_linear_268(void)
return TRUE;
}
-static int gecode_constraint_nooverlap_317(void)
+static int gecode_constraint_nooverlap_327(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -4781,7 +4879,7 @@ static int gecode_constraint_nooverlap_317(void)
return TRUE;
}
-static int gecode_constraint_nooverlap_320(void)
+static int gecode_constraint_nooverlap_330(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
@@ -4841,7 +4939,7 @@ static int gecode_constraint_element_239(void)
return TRUE;
}
-static int gecode_constraint_rel_395(void)
+static int gecode_constraint_rel_405(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
FloatVar X2 = gecode_FloatVar_from_term(space,YAP_ARG2);
@@ -4851,7 +4949,7 @@ static int gecode_constraint_rel_395(void)
return TRUE;
}
-static int gecode_constraint_rel_397(void)
+static int gecode_constraint_rel_407(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
FloatVar X2 = gecode_FloatVar_from_term(space,YAP_ARG2);
@@ -4861,7 +4959,7 @@ static int gecode_constraint_rel_397(void)
return TRUE;
}
-static int gecode_constraint_rel_413(void)
+static int gecode_constraint_rel_423(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
SetOpType X2 = gecode_SetOpType_from_term(YAP_ARG2);
@@ -4871,7 +4969,7 @@ static int gecode_constraint_rel_413(void)
return TRUE;
}
-static int gecode_constraint_rel_411(void)
+static int gecode_constraint_rel_421(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
SetOpType X2 = gecode_SetOpType_from_term(YAP_ARG2);
@@ -4881,7 +4979,7 @@ static int gecode_constraint_rel_411(void)
return TRUE;
}
-static int gecode_constraint_rel_383(void)
+static int gecode_constraint_rel_393(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
FloatVarArgs X2 = gecode_FloatVarArgs_from_term(space,YAP_ARG2);
@@ -4891,7 +4989,7 @@ static int gecode_constraint_rel_383(void)
return TRUE;
}
-static int gecode_constraint_rel_384(void)
+static int gecode_constraint_rel_394(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
FloatVarArgs X2 = gecode_FloatVarArgs_from_term(space,YAP_ARG2);
@@ -4901,7 +4999,7 @@ static int gecode_constraint_rel_384(void)
return TRUE;
}
-static int gecode_constraint_rel_381(void)
+static int gecode_constraint_rel_391(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2);
@@ -4911,7 +5009,7 @@ static int gecode_constraint_rel_381(void)
return TRUE;
}
-static int gecode_constraint_rel_377(void)
+static int gecode_constraint_rel_387(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2);
@@ -4921,7 +5019,7 @@ static int gecode_constraint_rel_377(void)
return TRUE;
}
-static int gecode_constraint_rel_375(void)
+static int gecode_constraint_rel_385(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2);
@@ -4931,80 +5029,40 @@ static int gecode_constraint_rel_375(void)
return TRUE;
}
-static int gecode_constraint_rel_380(void)
-{
- GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
- BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2);
- IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3);
- IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4);
- rel(*space,X2,X3,X4);
- return TRUE;
-}
-
-static int gecode_constraint_rel_371(void)
-{
- GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
- BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2);
- IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3);
- int X4 = gecode_int_from_term(YAP_ARG4);
- rel(*space,X2,X3,X4);
- return TRUE;
-}
-
-static int gecode_constraint_rel_367(void)
-{
- GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
- BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2);
- IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3);
- BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4);
- rel(*space,X2,X3,X4);
- return TRUE;
-}
-
-static int gecode_constraint_rel_391(void)
-{
- GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
- IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
- IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3);
- int X4 = gecode_int_from_term(YAP_ARG4);
- rel(*space,X2,X3,X4);
- return TRUE;
-}
-
-static int gecode_constraint_rel_393(void)
-{
- GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
- IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
- IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3);
- IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4);
- rel(*space,X2,X3,X4);
- return TRUE;
-}
-
-static int gecode_constraint_rel_387(void)
-{
- GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
- IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
- IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3);
- IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4);
- rel(*space,X2,X3,X4);
- return TRUE;
-}
-
static int gecode_constraint_rel_390(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
- IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
+ BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2);
IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3);
IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4);
rel(*space,X2,X3,X4);
return TRUE;
}
-static int gecode_constraint_rel_399(void)
+static int gecode_constraint_rel_381(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
- IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2);
+ BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2);
+ IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3);
+ int X4 = gecode_int_from_term(YAP_ARG4);
+ rel(*space,X2,X3,X4);
+ return TRUE;
+}
+
+static int gecode_constraint_rel_377(void)
+{
+ GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
+ BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2);
+ IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3);
+ BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4);
+ rel(*space,X2,X3,X4);
+ return TRUE;
+}
+
+static int gecode_constraint_rel_401(void)
+{
+ GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
+ IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3);
int X4 = gecode_int_from_term(YAP_ARG4);
rel(*space,X2,X3,X4);
@@ -5012,6 +5070,46 @@ static int gecode_constraint_rel_399(void)
}
static int gecode_constraint_rel_403(void)
+{
+ GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
+ IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
+ IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3);
+ IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4);
+ rel(*space,X2,X3,X4);
+ return TRUE;
+}
+
+static int gecode_constraint_rel_397(void)
+{
+ GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
+ IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
+ IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3);
+ IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4);
+ rel(*space,X2,X3,X4);
+ return TRUE;
+}
+
+static int gecode_constraint_rel_400(void)
+{
+ GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
+ IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2);
+ IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3);
+ IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4);
+ rel(*space,X2,X3,X4);
+ return TRUE;
+}
+
+static int gecode_constraint_rel_409(void)
+{
+ GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
+ IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2);
+ IntRelType X3 = gecode_IntRelType_from_term(YAP_ARG3);
+ int X4 = gecode_int_from_term(YAP_ARG4);
+ rel(*space,X2,X3,X4);
+ return TRUE;
+}
+
+static int gecode_constraint_rel_413(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2);
@@ -5021,7 +5119,7 @@ static int gecode_constraint_rel_403(void)
return TRUE;
}
-static int gecode_constraint_rel_407(void)
+static int gecode_constraint_rel_417(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2);
@@ -5031,7 +5129,7 @@ static int gecode_constraint_rel_407(void)
return TRUE;
}
-static int gecode_constraint_rel_408(void)
+static int gecode_constraint_rel_418(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2);
@@ -5041,7 +5139,7 @@ static int gecode_constraint_rel_408(void)
return TRUE;
}
-static int gecode_constraint_rel_414(void)
+static int gecode_constraint_rel_424(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2);
@@ -5051,7 +5149,7 @@ static int gecode_constraint_rel_414(void)
return TRUE;
}
-static int gecode_constraint_rel_419(void)
+static int gecode_constraint_rel_429(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2);
@@ -5061,7 +5159,7 @@ static int gecode_constraint_rel_419(void)
return TRUE;
}
-static int gecode_constraint_rel_421(void)
+static int gecode_constraint_rel_431(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2);
@@ -5071,7 +5169,7 @@ static int gecode_constraint_rel_421(void)
return TRUE;
}
-static int gecode_constraint_rel_361(void)
+static int gecode_constraint_rel_371(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolOpType X2 = gecode_BoolOpType_from_term(YAP_ARG2);
@@ -5081,7 +5179,7 @@ static int gecode_constraint_rel_361(void)
return TRUE;
}
-static int gecode_constraint_rel_359(void)
+static int gecode_constraint_rel_369(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolOpType X2 = gecode_BoolOpType_from_term(YAP_ARG2);
@@ -5091,7 +5189,7 @@ static int gecode_constraint_rel_359(void)
return TRUE;
}
-static int gecode_constraint_min_309(void)
+static int gecode_constraint_min_319(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2);
@@ -5120,7 +5218,7 @@ static int gecode_constraint_count_98(void)
return TRUE;
}
-static int gecode_constraint_ite_247(void)
+static int gecode_constraint_ite_257(void)
{
GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2);
diff --git a/library/gecode/4.2.0/gecode_yap_cc_init_auto_generated.icc b/library/gecode/4.2.0/gecode_yap_cc_init_auto_generated.icc
index c16574db8..96c3bbe9d 100644
--- a/library/gecode/4.2.0/gecode_yap_cc_init_auto_generated.icc
+++ b/library/gecode/4.2.0/gecode_yap_cc_init_auto_generated.icc
@@ -173,20 +173,20 @@
gecode_SOT_MINUS = YAP_MkAtomTerm(X);
YAP_AtomGetHold(X); }
-YAP_UserCPredicate("gecode_constraint_unary_448", gecode_constraint_unary_448, 6);
-YAP_UserCPredicate("gecode_constraint_unary_444", gecode_constraint_unary_444, 6);
-YAP_UserCPredicate("gecode_constraint_nvalues_335", gecode_constraint_nvalues_335, 5);
-YAP_UserCPredicate("gecode_constraint_nvalues_337", gecode_constraint_nvalues_337, 5);
-YAP_UserCPredicate("gecode_constraint_nvalues_331", gecode_constraint_nvalues_331, 5);
-YAP_UserCPredicate("gecode_constraint_nvalues_333", gecode_constraint_nvalues_333, 5);
-YAP_UserCPredicate("gecode_constraint_max_292", gecode_constraint_max_292, 4);
-YAP_UserCPredicate("gecode_constraint_max_290", gecode_constraint_max_290, 4);
-YAP_UserCPredicate("gecode_constraint_max_291", gecode_constraint_max_291, 4);
-YAP_UserCPredicate("gecode_constraint_max_295", gecode_constraint_max_295, 4);
+YAP_UserCPredicate("gecode_constraint_unary_458", gecode_constraint_unary_458, 6);
+YAP_UserCPredicate("gecode_constraint_unary_454", gecode_constraint_unary_454, 6);
+YAP_UserCPredicate("gecode_constraint_nvalues_345", gecode_constraint_nvalues_345, 5);
+YAP_UserCPredicate("gecode_constraint_nvalues_347", gecode_constraint_nvalues_347, 5);
+YAP_UserCPredicate("gecode_constraint_nvalues_341", gecode_constraint_nvalues_341, 5);
+YAP_UserCPredicate("gecode_constraint_nvalues_343", gecode_constraint_nvalues_343, 5);
+YAP_UserCPredicate("gecode_constraint_max_302", gecode_constraint_max_302, 4);
+YAP_UserCPredicate("gecode_constraint_max_300", gecode_constraint_max_300, 4);
+YAP_UserCPredicate("gecode_constraint_max_301", gecode_constraint_max_301, 4);
+YAP_UserCPredicate("gecode_constraint_max_305", gecode_constraint_max_305, 4);
YAP_UserCPredicate("gecode_constraint_dom_200", gecode_constraint_dom_200, 6);
YAP_UserCPredicate("gecode_constraint_dom_209", gecode_constraint_dom_209, 6);
YAP_UserCPredicate("gecode_constraint_convex_91", gecode_constraint_convex_91, 3);
-YAP_UserCPredicate("gecode_constraint_nooverlap_319", gecode_constraint_nooverlap_319, 5);
+YAP_UserCPredicate("gecode_constraint_nooverlap_329", gecode_constraint_nooverlap_329, 5);
YAP_UserCPredicate("gecode_constraint_assign_15", gecode_constraint_assign_15, 3);
YAP_UserCPredicate("gecode_constraint_assign_6", gecode_constraint_assign_6, 3);
YAP_UserCPredicate("gecode_constraint_assign_3", gecode_constraint_assign_3, 3);
@@ -204,11 +204,11 @@ YAP_UserCPredicate("gecode_constraint_element_227", gecode_constraint_element_22
YAP_UserCPredicate("gecode_constraint_element_230", gecode_constraint_element_230, 4);
YAP_UserCPredicate("gecode_constraint_element_236", gecode_constraint_element_236, 4);
YAP_UserCPredicate("gecode_constraint_element_228", gecode_constraint_element_228, 4);
-YAP_UserCPredicate("gecode_constraint_sequence_427", gecode_constraint_sequence_427, 2);
-YAP_UserCPredicate("gecode_constraint_notMax_325", gecode_constraint_notMax_325, 3);
-YAP_UserCPredicate("gecode_constraint_ite_246", gecode_constraint_ite_246, 5);
-YAP_UserCPredicate("gecode_constraint_unary_441", gecode_constraint_unary_441, 3);
-YAP_UserCPredicate("gecode_constraint_nroot_329", gecode_constraint_nroot_329, 5);
+YAP_UserCPredicate("gecode_constraint_sequence_437", gecode_constraint_sequence_437, 2);
+YAP_UserCPredicate("gecode_constraint_notMax_335", gecode_constraint_notMax_335, 3);
+YAP_UserCPredicate("gecode_constraint_ite_256", gecode_constraint_ite_256, 5);
+YAP_UserCPredicate("gecode_constraint_unary_451", gecode_constraint_unary_451, 3);
+YAP_UserCPredicate("gecode_constraint_nroot_339", gecode_constraint_nroot_339, 5);
YAP_UserCPredicate("gecode_constraint_circuit_85", gecode_constraint_circuit_85, 4);
YAP_UserCPredicate("gecode_constraint_circuit_76", gecode_constraint_circuit_76, 4);
YAP_UserCPredicate("gecode_constraint_dom_199", gecode_constraint_dom_199, 5);
@@ -224,74 +224,76 @@ YAP_UserCPredicate("gecode_constraint_dom_206", gecode_constraint_dom_206, 5);
YAP_UserCPredicate("gecode_constraint_channel_66", gecode_constraint_channel_66, 4);
YAP_UserCPredicate("gecode_constraint_channel_62", gecode_constraint_channel_62, 4);
YAP_UserCPredicate("gecode_constraint_channel_60", gecode_constraint_channel_60, 4);
-YAP_UserCPredicate("gecode_constraint_nooverlap_321", gecode_constraint_nooverlap_321, 8);
-YAP_UserCPredicate("gecode_constraint_nooverlap_324", gecode_constraint_nooverlap_324, 8);
+YAP_UserCPredicate("gecode_constraint_nooverlap_331", gecode_constraint_nooverlap_331, 8);
+YAP_UserCPredicate("gecode_constraint_nooverlap_334", gecode_constraint_nooverlap_334, 8);
YAP_UserCPredicate("gecode_constraint_element_222", gecode_constraint_element_222, 7);
YAP_UserCPredicate("gecode_constraint_element_216", gecode_constraint_element_216, 7);
YAP_UserCPredicate("gecode_constraint_element_218", gecode_constraint_element_218, 7);
YAP_UserCPredicate("gecode_constraint_element_226", gecode_constraint_element_226, 7);
YAP_UserCPredicate("gecode_constraint_element_234", gecode_constraint_element_234, 7);
YAP_UserCPredicate("gecode_constraint_element_232", gecode_constraint_element_232, 7);
-YAP_UserCPredicate("gecode_constraint_max_288", gecode_constraint_max_288, 3);
-YAP_UserCPredicate("gecode_constraint_max_289", gecode_constraint_max_289, 3);
-YAP_UserCPredicate("gecode_constraint_max_294", gecode_constraint_max_294, 3);
-YAP_UserCPredicate("gecode_constraint_unshare_453", gecode_constraint_unshare_453, 2);
-YAP_UserCPredicate("gecode_constraint_unshare_451", gecode_constraint_unshare_451, 2);
-YAP_UserCPredicate("gecode_constraint_path_348", gecode_constraint_path_348, 5);
-YAP_UserCPredicate("gecode_constraint_path_347", gecode_constraint_path_347, 5);
+YAP_UserCPredicate("gecode_constraint_max_298", gecode_constraint_max_298, 3);
+YAP_UserCPredicate("gecode_constraint_max_299", gecode_constraint_max_299, 3);
+YAP_UserCPredicate("gecode_constraint_max_304", gecode_constraint_max_304, 3);
+YAP_UserCPredicate("gecode_constraint_unshare_463", gecode_constraint_unshare_463, 2);
+YAP_UserCPredicate("gecode_constraint_unshare_461", gecode_constraint_unshare_461, 2);
+YAP_UserCPredicate("gecode_constraint_path_358", gecode_constraint_path_358, 5);
+YAP_UserCPredicate("gecode_constraint_path_357", gecode_constraint_path_357, 5);
YAP_UserCPredicate("gecode_constraint_branch_34", gecode_constraint_branch_34, 7);
YAP_UserCPredicate("gecode_constraint_branch_28", gecode_constraint_branch_28, 7);
YAP_UserCPredicate("gecode_constraint_branch_40", gecode_constraint_branch_40, 7);
-YAP_UserCPredicate("gecode_constraint_mult_315", gecode_constraint_mult_315, 4);
-YAP_UserCPredicate("gecode_constraint_mult_314", gecode_constraint_mult_314, 4);
+YAP_UserCPredicate("gecode_constraint_mult_325", gecode_constraint_mult_325, 4);
+YAP_UserCPredicate("gecode_constraint_mult_324", gecode_constraint_mult_324, 4);
YAP_UserCPredicate("gecode_constraint_clause_89", gecode_constraint_clause_89, 6);
YAP_UserCPredicate("gecode_constraint_clause_87", gecode_constraint_clause_87, 6);
-YAP_UserCPredicate("gecode_constraint_precede_356", gecode_constraint_precede_356, 5);
+YAP_UserCPredicate("gecode_constraint_precede_366", gecode_constraint_precede_366, 5);
YAP_UserCPredicate("gecode_constraint_distinct_160", gecode_constraint_distinct_160, 2);
-YAP_UserCPredicate("gecode_constraint_member_302", gecode_constraint_member_302, 4);
-YAP_UserCPredicate("gecode_constraint_member_301", gecode_constraint_member_301, 4);
-YAP_UserCPredicate("gecode_constraint_member_298", gecode_constraint_member_298, 4);
-YAP_UserCPredicate("gecode_constraint_member_297", gecode_constraint_member_297, 4);
-YAP_UserCPredicate("gecode_constraint_mod_313", gecode_constraint_mod_313, 5);
+YAP_UserCPredicate("gecode_constraint_member_312", gecode_constraint_member_312, 4);
+YAP_UserCPredicate("gecode_constraint_member_311", gecode_constraint_member_311, 4);
+YAP_UserCPredicate("gecode_constraint_member_308", gecode_constraint_member_308, 4);
+YAP_UserCPredicate("gecode_constraint_member_307", gecode_constraint_member_307, 4);
+YAP_UserCPredicate("gecode_constraint_mod_323", gecode_constraint_mod_323, 5);
YAP_UserCPredicate("gecode_constraint_cardinality_57", gecode_constraint_cardinality_57, 3);
YAP_UserCPredicate("gecode_constraint_atmostOne_53", gecode_constraint_atmostOne_53, 3);
YAP_UserCPredicate("gecode_constraint_channelSorted_73", gecode_constraint_channelSorted_73, 3);
+YAP_UserCPredicate("gecode_constraint_extensional_253", gecode_constraint_extensional_253, 5);
+YAP_UserCPredicate("gecode_constraint_extensional_248", gecode_constraint_extensional_248, 5);
+YAP_UserCPredicate("gecode_constraint_linear_272", gecode_constraint_linear_272, 4);
+YAP_UserCPredicate("gecode_constraint_linear_270", gecode_constraint_linear_270, 4);
+YAP_UserCPredicate("gecode_constraint_linear_258", gecode_constraint_linear_258, 4);
YAP_UserCPredicate("gecode_constraint_linear_262", gecode_constraint_linear_262, 4);
-YAP_UserCPredicate("gecode_constraint_linear_260", gecode_constraint_linear_260, 4);
-YAP_UserCPredicate("gecode_constraint_linear_248", gecode_constraint_linear_248, 4);
-YAP_UserCPredicate("gecode_constraint_linear_252", gecode_constraint_linear_252, 4);
-YAP_UserCPredicate("gecode_constraint_linear_280", gecode_constraint_linear_280, 4);
-YAP_UserCPredicate("gecode_constraint_linear_284", gecode_constraint_linear_284, 4);
+YAP_UserCPredicate("gecode_constraint_linear_290", gecode_constraint_linear_290, 4);
+YAP_UserCPredicate("gecode_constraint_linear_294", gecode_constraint_linear_294, 4);
YAP_UserCPredicate("gecode_constraint_circuit_82", gecode_constraint_circuit_82, 2);
-YAP_UserCPredicate("gecode_constraint_rel_396", gecode_constraint_rel_396, 5);
-YAP_UserCPredicate("gecode_constraint_rel_398", gecode_constraint_rel_398, 5);
-YAP_UserCPredicate("gecode_constraint_rel_412", gecode_constraint_rel_412, 5);
-YAP_UserCPredicate("gecode_constraint_rel_410", gecode_constraint_rel_410, 5);
-YAP_UserCPredicate("gecode_constraint_rel_382", gecode_constraint_rel_382, 5);
-YAP_UserCPredicate("gecode_constraint_rel_378", gecode_constraint_rel_378, 5);
-YAP_UserCPredicate("gecode_constraint_rel_376", gecode_constraint_rel_376, 5);
-YAP_UserCPredicate("gecode_constraint_rel_373", gecode_constraint_rel_373, 5);
-YAP_UserCPredicate("gecode_constraint_rel_372", gecode_constraint_rel_372, 5);
-YAP_UserCPredicate("gecode_constraint_rel_369", gecode_constraint_rel_369, 5);
-YAP_UserCPredicate("gecode_constraint_rel_368", gecode_constraint_rel_368, 5);
-YAP_UserCPredicate("gecode_constraint_rel_365", gecode_constraint_rel_365, 5);
-YAP_UserCPredicate("gecode_constraint_rel_363", gecode_constraint_rel_363, 5);
-YAP_UserCPredicate("gecode_constraint_rel_392", gecode_constraint_rel_392, 5);
-YAP_UserCPredicate("gecode_constraint_rel_394", gecode_constraint_rel_394, 5);
-YAP_UserCPredicate("gecode_constraint_rel_388", gecode_constraint_rel_388, 5);
-YAP_UserCPredicate("gecode_constraint_rel_401", gecode_constraint_rel_401, 5);
-YAP_UserCPredicate("gecode_constraint_rel_400", gecode_constraint_rel_400, 5);
-YAP_UserCPredicate("gecode_constraint_rel_405", gecode_constraint_rel_405, 5);
-YAP_UserCPredicate("gecode_constraint_rel_404", gecode_constraint_rel_404, 5);
-YAP_UserCPredicate("gecode_constraint_rel_409", gecode_constraint_rel_409, 5);
-YAP_UserCPredicate("gecode_constraint_rel_420", gecode_constraint_rel_420, 5);
+YAP_UserCPredicate("gecode_constraint_rel_406", gecode_constraint_rel_406, 5);
+YAP_UserCPredicate("gecode_constraint_rel_408", gecode_constraint_rel_408, 5);
YAP_UserCPredicate("gecode_constraint_rel_422", gecode_constraint_rel_422, 5);
-YAP_UserCPredicate("gecode_constraint_rel_362", gecode_constraint_rel_362, 5);
-YAP_UserCPredicate("gecode_constraint_rel_360", gecode_constraint_rel_360, 5);
-YAP_UserCPredicate("gecode_constraint_min_308", gecode_constraint_min_308, 4);
-YAP_UserCPredicate("gecode_constraint_min_306", gecode_constraint_min_306, 4);
-YAP_UserCPredicate("gecode_constraint_min_307", gecode_constraint_min_307, 4);
-YAP_UserCPredicate("gecode_constraint_min_311", gecode_constraint_min_311, 4);
+YAP_UserCPredicate("gecode_constraint_rel_420", gecode_constraint_rel_420, 5);
+YAP_UserCPredicate("gecode_constraint_rel_392", gecode_constraint_rel_392, 5);
+YAP_UserCPredicate("gecode_constraint_rel_388", gecode_constraint_rel_388, 5);
+YAP_UserCPredicate("gecode_constraint_rel_386", gecode_constraint_rel_386, 5);
+YAP_UserCPredicate("gecode_constraint_rel_383", gecode_constraint_rel_383, 5);
+YAP_UserCPredicate("gecode_constraint_rel_382", gecode_constraint_rel_382, 5);
+YAP_UserCPredicate("gecode_constraint_rel_379", gecode_constraint_rel_379, 5);
+YAP_UserCPredicate("gecode_constraint_rel_378", gecode_constraint_rel_378, 5);
+YAP_UserCPredicate("gecode_constraint_rel_375", gecode_constraint_rel_375, 5);
+YAP_UserCPredicate("gecode_constraint_rel_373", gecode_constraint_rel_373, 5);
+YAP_UserCPredicate("gecode_constraint_rel_402", gecode_constraint_rel_402, 5);
+YAP_UserCPredicate("gecode_constraint_rel_404", gecode_constraint_rel_404, 5);
+YAP_UserCPredicate("gecode_constraint_rel_398", gecode_constraint_rel_398, 5);
+YAP_UserCPredicate("gecode_constraint_rel_411", gecode_constraint_rel_411, 5);
+YAP_UserCPredicate("gecode_constraint_rel_410", gecode_constraint_rel_410, 5);
+YAP_UserCPredicate("gecode_constraint_rel_415", gecode_constraint_rel_415, 5);
+YAP_UserCPredicate("gecode_constraint_rel_414", gecode_constraint_rel_414, 5);
+YAP_UserCPredicate("gecode_constraint_rel_419", gecode_constraint_rel_419, 5);
+YAP_UserCPredicate("gecode_constraint_rel_430", gecode_constraint_rel_430, 5);
+YAP_UserCPredicate("gecode_constraint_rel_432", gecode_constraint_rel_432, 5);
+YAP_UserCPredicate("gecode_constraint_rel_372", gecode_constraint_rel_372, 5);
+YAP_UserCPredicate("gecode_constraint_rel_370", gecode_constraint_rel_370, 5);
+YAP_UserCPredicate("gecode_constraint_min_318", gecode_constraint_min_318, 4);
+YAP_UserCPredicate("gecode_constraint_min_316", gecode_constraint_min_316, 4);
+YAP_UserCPredicate("gecode_constraint_min_317", gecode_constraint_min_317, 4);
+YAP_UserCPredicate("gecode_constraint_min_321", gecode_constraint_min_321, 4);
YAP_UserCPredicate("gecode_constraint_cardinality_56", gecode_constraint_cardinality_56, 4);
YAP_UserCPredicate("gecode_constraint_cardinality_58", gecode_constraint_cardinality_58, 4);
YAP_UserCPredicate("gecode_constraint_count_109", gecode_constraint_count_109, 4);
@@ -299,8 +301,8 @@ YAP_UserCPredicate("gecode_constraint_count_106", gecode_constraint_count_106, 4
YAP_UserCPredicate("gecode_constraint_count_100", gecode_constraint_count_100, 4);
YAP_UserCPredicate("gecode_constraint_count_99", gecode_constraint_count_99, 4);
YAP_UserCPredicate("gecode_constraint_count_96", gecode_constraint_count_96, 4);
-YAP_UserCPredicate("gecode_constraint_sqrt_437", gecode_constraint_sqrt_437, 3);
-YAP_UserCPredicate("gecode_constraint_sqrt_436", gecode_constraint_sqrt_436, 3);
+YAP_UserCPredicate("gecode_constraint_sqrt_447", gecode_constraint_sqrt_447, 3);
+YAP_UserCPredicate("gecode_constraint_sqrt_446", gecode_constraint_sqrt_446, 3);
YAP_UserCPredicate("gecode_constraint_cumulatives_157", gecode_constraint_cumulatives_157, 9);
YAP_UserCPredicate("gecode_constraint_cumulatives_155", gecode_constraint_cumulatives_155, 9);
YAP_UserCPredicate("gecode_constraint_cumulatives_153", gecode_constraint_cumulatives_153, 9);
@@ -309,41 +311,41 @@ YAP_UserCPredicate("gecode_constraint_cumulatives_149", gecode_constraint_cumula
YAP_UserCPredicate("gecode_constraint_cumulatives_147", gecode_constraint_cumulatives_147, 9);
YAP_UserCPredicate("gecode_constraint_cumulatives_145", gecode_constraint_cumulatives_145, 9);
YAP_UserCPredicate("gecode_constraint_cumulatives_143", gecode_constraint_cumulatives_143, 9);
-YAP_UserCPredicate("gecode_constraint_nvalues_334", gecode_constraint_nvalues_334, 4);
-YAP_UserCPredicate("gecode_constraint_nvalues_336", gecode_constraint_nvalues_336, 4);
-YAP_UserCPredicate("gecode_constraint_nvalues_330", gecode_constraint_nvalues_330, 4);
-YAP_UserCPredicate("gecode_constraint_nvalues_332", gecode_constraint_nvalues_332, 4);
+YAP_UserCPredicate("gecode_constraint_nvalues_344", gecode_constraint_nvalues_344, 4);
+YAP_UserCPredicate("gecode_constraint_nvalues_346", gecode_constraint_nvalues_346, 4);
+YAP_UserCPredicate("gecode_constraint_nvalues_340", gecode_constraint_nvalues_340, 4);
+YAP_UserCPredicate("gecode_constraint_nvalues_342", gecode_constraint_nvalues_342, 4);
YAP_UserCPredicate("gecode_constraint_binpacking_54", gecode_constraint_binpacking_54, 4);
-YAP_UserCPredicate("gecode_constraint_linear_275", gecode_constraint_linear_275, 7);
-YAP_UserCPredicate("gecode_constraint_linear_279", gecode_constraint_linear_279, 7);
-YAP_UserCPredicate("gecode_constraint_linear_267", gecode_constraint_linear_267, 7);
-YAP_UserCPredicate("gecode_constraint_linear_271", gecode_constraint_linear_271, 7);
+YAP_UserCPredicate("gecode_constraint_linear_285", gecode_constraint_linear_285, 7);
+YAP_UserCPredicate("gecode_constraint_linear_289", gecode_constraint_linear_289, 7);
+YAP_UserCPredicate("gecode_constraint_linear_277", gecode_constraint_linear_277, 7);
+YAP_UserCPredicate("gecode_constraint_linear_281", gecode_constraint_linear_281, 7);
YAP_UserCPredicate("gecode_constraint_abs_52", gecode_constraint_abs_52, 4);
YAP_UserCPredicate("gecode_constraint_convex_90", gecode_constraint_convex_90, 2);
YAP_UserCPredicate("gecode_constraint_div_163", gecode_constraint_div_163, 4);
YAP_UserCPredicate("gecode_constraint_div_162", gecode_constraint_div_162, 4);
-YAP_UserCPredicate("gecode_constraint_rel_402", gecode_constraint_rel_402, 6);
-YAP_UserCPredicate("gecode_constraint_rel_406", gecode_constraint_rel_406, 6);
-YAP_UserCPredicate("gecode_constraint_rel_385", gecode_constraint_rel_385, 6);
-YAP_UserCPredicate("gecode_constraint_rel_386", gecode_constraint_rel_386, 6);
-YAP_UserCPredicate("gecode_constraint_rel_374", gecode_constraint_rel_374, 6);
-YAP_UserCPredicate("gecode_constraint_rel_370", gecode_constraint_rel_370, 6);
-YAP_UserCPredicate("gecode_constraint_rel_366", gecode_constraint_rel_366, 6);
-YAP_UserCPredicate("gecode_constraint_rel_364", gecode_constraint_rel_364, 6);
-YAP_UserCPredicate("gecode_constraint_rel_415", gecode_constraint_rel_415, 6);
+YAP_UserCPredicate("gecode_constraint_rel_412", gecode_constraint_rel_412, 6);
YAP_UserCPredicate("gecode_constraint_rel_416", gecode_constraint_rel_416, 6);
-YAP_UserCPredicate("gecode_constraint_rel_417", gecode_constraint_rel_417, 6);
-YAP_UserCPredicate("gecode_constraint_rel_418", gecode_constraint_rel_418, 6);
-YAP_UserCPredicate("gecode_constraint_weights_455", gecode_constraint_weights_455, 5);
-YAP_UserCPredicate("gecode_constraint_max_293", gecode_constraint_max_293, 5);
-YAP_UserCPredicate("gecode_constraint_path_343", gecode_constraint_path_343, 9);
+YAP_UserCPredicate("gecode_constraint_rel_395", gecode_constraint_rel_395, 6);
+YAP_UserCPredicate("gecode_constraint_rel_396", gecode_constraint_rel_396, 6);
+YAP_UserCPredicate("gecode_constraint_rel_384", gecode_constraint_rel_384, 6);
+YAP_UserCPredicate("gecode_constraint_rel_380", gecode_constraint_rel_380, 6);
+YAP_UserCPredicate("gecode_constraint_rel_376", gecode_constraint_rel_376, 6);
+YAP_UserCPredicate("gecode_constraint_rel_374", gecode_constraint_rel_374, 6);
+YAP_UserCPredicate("gecode_constraint_rel_425", gecode_constraint_rel_425, 6);
+YAP_UserCPredicate("gecode_constraint_rel_426", gecode_constraint_rel_426, 6);
+YAP_UserCPredicate("gecode_constraint_rel_427", gecode_constraint_rel_427, 6);
+YAP_UserCPredicate("gecode_constraint_rel_428", gecode_constraint_rel_428, 6);
+YAP_UserCPredicate("gecode_constraint_weights_465", gecode_constraint_weights_465, 5);
+YAP_UserCPredicate("gecode_constraint_max_303", gecode_constraint_max_303, 5);
+YAP_UserCPredicate("gecode_constraint_path_353", gecode_constraint_path_353, 9);
+YAP_UserCPredicate("gecode_constraint_unary_459", gecode_constraint_unary_459, 4);
+YAP_UserCPredicate("gecode_constraint_unary_455", gecode_constraint_unary_455, 4);
YAP_UserCPredicate("gecode_constraint_unary_449", gecode_constraint_unary_449, 4);
-YAP_UserCPredicate("gecode_constraint_unary_445", gecode_constraint_unary_445, 4);
-YAP_UserCPredicate("gecode_constraint_unary_439", gecode_constraint_unary_439, 4);
-YAP_UserCPredicate("gecode_constraint_unary_442", gecode_constraint_unary_442, 4);
-YAP_UserCPredicate("gecode_constraint_nroot_328", gecode_constraint_nroot_328, 4);
-YAP_UserCPredicate("gecode_constraint_nroot_327", gecode_constraint_nroot_327, 4);
-YAP_UserCPredicate("gecode_constraint_sorted_430", gecode_constraint_sorted_430, 5);
+YAP_UserCPredicate("gecode_constraint_unary_452", gecode_constraint_unary_452, 4);
+YAP_UserCPredicate("gecode_constraint_nroot_338", gecode_constraint_nroot_338, 4);
+YAP_UserCPredicate("gecode_constraint_nroot_337", gecode_constraint_nroot_337, 4);
+YAP_UserCPredicate("gecode_constraint_sorted_440", gecode_constraint_sorted_440, 5);
YAP_UserCPredicate("gecode_constraint_circuit_80", gecode_constraint_circuit_80, 5);
YAP_UserCPredicate("gecode_constraint_circuit_77", gecode_constraint_circuit_77, 5);
YAP_UserCPredicate("gecode_constraint_circuit_74", gecode_constraint_circuit_74, 5);
@@ -374,9 +376,9 @@ YAP_UserCPredicate("gecode_constraint_assign_8", gecode_constraint_assign_8, 5);
YAP_UserCPredicate("gecode_constraint_assign_5", gecode_constraint_assign_5, 5);
YAP_UserCPredicate("gecode_constraint_assign_11", gecode_constraint_assign_11, 5);
YAP_UserCPredicate("gecode_constraint_assign_14", gecode_constraint_assign_14, 5);
+YAP_UserCPredicate("gecode_constraint_rel_399", gecode_constraint_rel_399, 3);
YAP_UserCPredicate("gecode_constraint_rel_389", gecode_constraint_rel_389, 3);
-YAP_UserCPredicate("gecode_constraint_rel_379", gecode_constraint_rel_379, 3);
-YAP_UserCPredicate("gecode_constraint_path_346", gecode_constraint_path_346, 4);
+YAP_UserCPredicate("gecode_constraint_path_356", gecode_constraint_path_356, 4);
YAP_UserCPredicate("gecode_constraint_branch_45", gecode_constraint_branch_45, 4);
YAP_UserCPredicate("gecode_constraint_branch_29", gecode_constraint_branch_29, 4);
YAP_UserCPredicate("gecode_constraint_branch_23", gecode_constraint_branch_23, 4);
@@ -385,15 +387,15 @@ YAP_UserCPredicate("gecode_constraint_branch_35", gecode_constraint_branch_35, 4
YAP_UserCPredicate("gecode_constraint_branch_47", gecode_constraint_branch_47, 4);
YAP_UserCPredicate("gecode_constraint_branch_41", gecode_constraint_branch_41, 4);
YAP_UserCPredicate("gecode_constraint_branch_49", gecode_constraint_branch_49, 4);
-YAP_UserCPredicate("gecode_constraint_mult_316", gecode_constraint_mult_316, 5);
+YAP_UserCPredicate("gecode_constraint_mult_326", gecode_constraint_mult_326, 5);
YAP_UserCPredicate("gecode_constraint_circuit_81", gecode_constraint_circuit_81, 6);
YAP_UserCPredicate("gecode_constraint_circuit_78", gecode_constraint_circuit_78, 6);
YAP_UserCPredicate("gecode_constraint_circuit_75", gecode_constraint_circuit_75, 6);
YAP_UserCPredicate("gecode_constraint_clause_88", gecode_constraint_clause_88, 5);
YAP_UserCPredicate("gecode_constraint_clause_86", gecode_constraint_clause_86, 5);
-YAP_UserCPredicate("gecode_constraint_precede_358", gecode_constraint_precede_358, 4);
-YAP_UserCPredicate("gecode_constraint_precede_355", gecode_constraint_precede_355, 4);
-YAP_UserCPredicate("gecode_constraint_precede_354", gecode_constraint_precede_354, 4);
+YAP_UserCPredicate("gecode_constraint_precede_368", gecode_constraint_precede_368, 4);
+YAP_UserCPredicate("gecode_constraint_precede_365", gecode_constraint_precede_365, 4);
+YAP_UserCPredicate("gecode_constraint_precede_364", gecode_constraint_precede_364, 4);
YAP_UserCPredicate("gecode_constraint_channel_69", gecode_constraint_channel_69, 6);
YAP_UserCPredicate("gecode_constraint_cumulative_126", gecode_constraint_cumulative_126, 7);
YAP_UserCPredicate("gecode_constraint_cumulative_129", gecode_constraint_cumulative_129, 7);
@@ -407,18 +409,22 @@ YAP_UserCPredicate("gecode_constraint_cumulative_137", gecode_constraint_cumulat
YAP_UserCPredicate("gecode_constraint_cumulative_131", gecode_constraint_cumulative_131, 7);
YAP_UserCPredicate("gecode_constraint_distinct_161", gecode_constraint_distinct_161, 3);
YAP_UserCPredicate("gecode_constraint_distinct_158", gecode_constraint_distinct_158, 3);
-YAP_UserCPredicate("gecode_constraint_member_303", gecode_constraint_member_303, 5);
-YAP_UserCPredicate("gecode_constraint_member_299", gecode_constraint_member_299, 5);
-YAP_UserCPredicate("gecode_constraint_mod_312", gecode_constraint_mod_312, 4);
-YAP_UserCPredicate("gecode_constraint_sqr_434", gecode_constraint_sqr_434, 3);
-YAP_UserCPredicate("gecode_constraint_sqr_433", gecode_constraint_sqr_433, 3);
-YAP_UserCPredicate("gecode_constraint_sequence_426", gecode_constraint_sequence_426, 7);
-YAP_UserCPredicate("gecode_constraint_sequence_424", gecode_constraint_sequence_424, 7);
-YAP_UserCPredicate("gecode_constraint_path_344", gecode_constraint_path_344, 7);
-YAP_UserCPredicate("gecode_constraint_path_341", gecode_constraint_path_341, 7);
-YAP_UserCPredicate("gecode_constraint_path_338", gecode_constraint_path_338, 7);
+YAP_UserCPredicate("gecode_constraint_member_313", gecode_constraint_member_313, 5);
+YAP_UserCPredicate("gecode_constraint_member_309", gecode_constraint_member_309, 5);
+YAP_UserCPredicate("gecode_constraint_mod_322", gecode_constraint_mod_322, 4);
+YAP_UserCPredicate("gecode_constraint_sqr_444", gecode_constraint_sqr_444, 3);
+YAP_UserCPredicate("gecode_constraint_sqr_443", gecode_constraint_sqr_443, 3);
+YAP_UserCPredicate("gecode_constraint_sequence_436", gecode_constraint_sequence_436, 7);
+YAP_UserCPredicate("gecode_constraint_sequence_434", gecode_constraint_sequence_434, 7);
+YAP_UserCPredicate("gecode_constraint_path_354", gecode_constraint_path_354, 7);
+YAP_UserCPredicate("gecode_constraint_path_351", gecode_constraint_path_351, 7);
+YAP_UserCPredicate("gecode_constraint_path_348", gecode_constraint_path_348, 7);
YAP_UserCPredicate("gecode_constraint_divmod_166", gecode_constraint_divmod_166, 6);
-YAP_UserCPredicate("gecode_constraint_sorted_431", gecode_constraint_sorted_431, 3);
+YAP_UserCPredicate("gecode_constraint_sorted_441", gecode_constraint_sorted_441, 3);
+YAP_UserCPredicate("gecode_constraint_extensional_252", gecode_constraint_extensional_252, 4);
+YAP_UserCPredicate("gecode_constraint_extensional_255", gecode_constraint_extensional_255, 4);
+YAP_UserCPredicate("gecode_constraint_extensional_247", gecode_constraint_extensional_247, 4);
+YAP_UserCPredicate("gecode_constraint_extensional_250", gecode_constraint_extensional_250, 4);
YAP_UserCPredicate("gecode_constraint_circuit_84", gecode_constraint_circuit_84, 3);
YAP_UserCPredicate("gecode_constraint_circuit_83", gecode_constraint_circuit_83, 3);
YAP_UserCPredicate("gecode_constraint_channel_71", gecode_constraint_channel_71, 3);
@@ -449,34 +455,38 @@ YAP_UserCPredicate("gecode_constraint_cumulatives_146", gecode_constraint_cumula
YAP_UserCPredicate("gecode_constraint_cumulatives_144", gecode_constraint_cumulatives_144, 8);
YAP_UserCPredicate("gecode_constraint_cumulatives_142", gecode_constraint_cumulatives_142, 8);
YAP_UserCPredicate("gecode_constraint_binpacking_55", gecode_constraint_binpacking_55, 5);
-YAP_UserCPredicate("gecode_constraint_linear_283", gecode_constraint_linear_283, 6);
-YAP_UserCPredicate("gecode_constraint_linear_287", gecode_constraint_linear_287, 6);
-YAP_UserCPredicate("gecode_constraint_linear_251", gecode_constraint_linear_251, 6);
-YAP_UserCPredicate("gecode_constraint_linear_255", gecode_constraint_linear_255, 6);
-YAP_UserCPredicate("gecode_constraint_linear_259", gecode_constraint_linear_259, 6);
-YAP_UserCPredicate("gecode_constraint_linear_257", gecode_constraint_linear_257, 6);
-YAP_UserCPredicate("gecode_constraint_linear_274", gecode_constraint_linear_274, 6);
-YAP_UserCPredicate("gecode_constraint_linear_273", gecode_constraint_linear_273, 6);
-YAP_UserCPredicate("gecode_constraint_linear_278", gecode_constraint_linear_278, 6);
-YAP_UserCPredicate("gecode_constraint_linear_277", gecode_constraint_linear_277, 6);
-YAP_UserCPredicate("gecode_constraint_linear_266", gecode_constraint_linear_266, 6);
+YAP_UserCPredicate("gecode_constraint_extensional_251", gecode_constraint_extensional_251, 3);
+YAP_UserCPredicate("gecode_constraint_extensional_254", gecode_constraint_extensional_254, 3);
+YAP_UserCPredicate("gecode_constraint_extensional_246", gecode_constraint_extensional_246, 3);
+YAP_UserCPredicate("gecode_constraint_extensional_249", gecode_constraint_extensional_249, 3);
+YAP_UserCPredicate("gecode_constraint_linear_293", gecode_constraint_linear_293, 6);
+YAP_UserCPredicate("gecode_constraint_linear_297", gecode_constraint_linear_297, 6);
+YAP_UserCPredicate("gecode_constraint_linear_261", gecode_constraint_linear_261, 6);
YAP_UserCPredicate("gecode_constraint_linear_265", gecode_constraint_linear_265, 6);
-YAP_UserCPredicate("gecode_constraint_linear_270", gecode_constraint_linear_270, 6);
YAP_UserCPredicate("gecode_constraint_linear_269", gecode_constraint_linear_269, 6);
-YAP_UserCPredicate("gecode_constraint_nooverlap_323", gecode_constraint_nooverlap_323, 7);
-YAP_UserCPredicate("gecode_constraint_nooverlap_318", gecode_constraint_nooverlap_318, 7);
+YAP_UserCPredicate("gecode_constraint_linear_267", gecode_constraint_linear_267, 6);
+YAP_UserCPredicate("gecode_constraint_linear_284", gecode_constraint_linear_284, 6);
+YAP_UserCPredicate("gecode_constraint_linear_283", gecode_constraint_linear_283, 6);
+YAP_UserCPredicate("gecode_constraint_linear_288", gecode_constraint_linear_288, 6);
+YAP_UserCPredicate("gecode_constraint_linear_287", gecode_constraint_linear_287, 6);
+YAP_UserCPredicate("gecode_constraint_linear_276", gecode_constraint_linear_276, 6);
+YAP_UserCPredicate("gecode_constraint_linear_275", gecode_constraint_linear_275, 6);
+YAP_UserCPredicate("gecode_constraint_linear_280", gecode_constraint_linear_280, 6);
+YAP_UserCPredicate("gecode_constraint_linear_279", gecode_constraint_linear_279, 6);
+YAP_UserCPredicate("gecode_constraint_nooverlap_333", gecode_constraint_nooverlap_333, 7);
+YAP_UserCPredicate("gecode_constraint_nooverlap_328", gecode_constraint_nooverlap_328, 7);
YAP_UserCPredicate("gecode_constraint_div_164", gecode_constraint_div_164, 5);
-YAP_UserCPredicate("gecode_constraint_sqr_435", gecode_constraint_sqr_435, 4);
-YAP_UserCPredicate("gecode_constraint_path_345", gecode_constraint_path_345, 8);
-YAP_UserCPredicate("gecode_constraint_path_342", gecode_constraint_path_342, 8);
-YAP_UserCPredicate("gecode_constraint_path_339", gecode_constraint_path_339, 8);
-YAP_UserCPredicate("gecode_constraint_unary_447", gecode_constraint_unary_447, 5);
+YAP_UserCPredicate("gecode_constraint_sqr_445", gecode_constraint_sqr_445, 4);
+YAP_UserCPredicate("gecode_constraint_path_355", gecode_constraint_path_355, 8);
+YAP_UserCPredicate("gecode_constraint_path_352", gecode_constraint_path_352, 8);
+YAP_UserCPredicate("gecode_constraint_path_349", gecode_constraint_path_349, 8);
+YAP_UserCPredicate("gecode_constraint_unary_457", gecode_constraint_unary_457, 5);
+YAP_UserCPredicate("gecode_constraint_unary_460", gecode_constraint_unary_460, 5);
+YAP_UserCPredicate("gecode_constraint_unary_453", gecode_constraint_unary_453, 5);
+YAP_UserCPredicate("gecode_constraint_unary_456", gecode_constraint_unary_456, 5);
YAP_UserCPredicate("gecode_constraint_unary_450", gecode_constraint_unary_450, 5);
-YAP_UserCPredicate("gecode_constraint_unary_443", gecode_constraint_unary_443, 5);
-YAP_UserCPredicate("gecode_constraint_unary_446", gecode_constraint_unary_446, 5);
-YAP_UserCPredicate("gecode_constraint_unary_440", gecode_constraint_unary_440, 5);
-YAP_UserCPredicate("gecode_constraint_sorted_429", gecode_constraint_sorted_429, 4);
-YAP_UserCPredicate("gecode_constraint_sorted_432", gecode_constraint_sorted_432, 4);
+YAP_UserCPredicate("gecode_constraint_sorted_439", gecode_constraint_sorted_439, 4);
+YAP_UserCPredicate("gecode_constraint_sorted_442", gecode_constraint_sorted_442, 4);
YAP_UserCPredicate("gecode_constraint_element_223", gecode_constraint_element_223, 8);
YAP_UserCPredicate("gecode_constraint_element_217", gecode_constraint_element_217, 8);
YAP_UserCPredicate("gecode_constraint_element_235", gecode_constraint_element_235, 8);
@@ -500,7 +510,7 @@ YAP_UserCPredicate("gecode_constraint_element_238", gecode_constraint_element_23
YAP_UserCPredicate("gecode_constraint_element_231", gecode_constraint_element_231, 5);
YAP_UserCPredicate("gecode_constraint_element_237", gecode_constraint_element_237, 5);
YAP_UserCPredicate("gecode_constraint_element_229", gecode_constraint_element_229, 5);
-YAP_UserCPredicate("gecode_constraint_sequence_428", gecode_constraint_sequence_428, 3);
+YAP_UserCPredicate("gecode_constraint_sequence_438", gecode_constraint_sequence_438, 3);
YAP_UserCPredicate("gecode_constraint_branch_30", gecode_constraint_branch_30, 5);
YAP_UserCPredicate("gecode_constraint_branch_26", gecode_constraint_branch_26, 5);
YAP_UserCPredicate("gecode_constraint_branch_24", gecode_constraint_branch_24, 5);
@@ -509,10 +519,10 @@ YAP_UserCPredicate("gecode_constraint_branch_36", gecode_constraint_branch_36, 5
YAP_UserCPredicate("gecode_constraint_branch_42", gecode_constraint_branch_42, 5);
YAP_UserCPredicate("gecode_constraint_branch_38", gecode_constraint_branch_38, 5);
YAP_UserCPredicate("gecode_constraint_circuit_79", gecode_constraint_circuit_79, 7);
-YAP_UserCPredicate("gecode_constraint_pow_351", gecode_constraint_pow_351, 4);
-YAP_UserCPredicate("gecode_constraint_pow_350", gecode_constraint_pow_350, 4);
-YAP_UserCPredicate("gecode_constraint_precede_357", gecode_constraint_precede_357, 3);
-YAP_UserCPredicate("gecode_constraint_precede_353", gecode_constraint_precede_353, 3);
+YAP_UserCPredicate("gecode_constraint_pow_361", gecode_constraint_pow_361, 4);
+YAP_UserCPredicate("gecode_constraint_pow_360", gecode_constraint_pow_360, 4);
+YAP_UserCPredicate("gecode_constraint_precede_367", gecode_constraint_precede_367, 3);
+YAP_UserCPredicate("gecode_constraint_precede_363", gecode_constraint_precede_363, 3);
YAP_UserCPredicate("gecode_constraint_cumulative_128", gecode_constraint_cumulative_128, 6);
YAP_UserCPredicate("gecode_constraint_cumulative_124", gecode_constraint_cumulative_124, 6);
YAP_UserCPredicate("gecode_constraint_cumulative_118", gecode_constraint_cumulative_118, 6);
@@ -522,16 +532,16 @@ YAP_UserCPredicate("gecode_constraint_cumulative_136", gecode_constraint_cumulat
YAP_UserCPredicate("gecode_constraint_cumulative_130", gecode_constraint_cumulative_130, 6);
YAP_UserCPredicate("gecode_constraint_cumulative_133", gecode_constraint_cumulative_133, 6);
YAP_UserCPredicate("gecode_constraint_distinct_159", gecode_constraint_distinct_159, 4);
-YAP_UserCPredicate("gecode_constraint_min_304", gecode_constraint_min_304, 3);
-YAP_UserCPredicate("gecode_constraint_min_305", gecode_constraint_min_305, 3);
-YAP_UserCPredicate("gecode_constraint_min_310", gecode_constraint_min_310, 3);
-YAP_UserCPredicate("gecode_constraint_sqrt_438", gecode_constraint_sqrt_438, 4);
-YAP_UserCPredicate("gecode_constraint_sequence_425", gecode_constraint_sequence_425, 6);
-YAP_UserCPredicate("gecode_constraint_sequence_423", gecode_constraint_sequence_423, 6);
-YAP_UserCPredicate("gecode_constraint_unshare_454", gecode_constraint_unshare_454, 3);
-YAP_UserCPredicate("gecode_constraint_unshare_452", gecode_constraint_unshare_452, 3);
-YAP_UserCPredicate("gecode_constraint_path_349", gecode_constraint_path_349, 6);
-YAP_UserCPredicate("gecode_constraint_path_340", gecode_constraint_path_340, 6);
+YAP_UserCPredicate("gecode_constraint_min_314", gecode_constraint_min_314, 3);
+YAP_UserCPredicate("gecode_constraint_min_315", gecode_constraint_min_315, 3);
+YAP_UserCPredicate("gecode_constraint_min_320", gecode_constraint_min_320, 3);
+YAP_UserCPredicate("gecode_constraint_sqrt_448", gecode_constraint_sqrt_448, 4);
+YAP_UserCPredicate("gecode_constraint_sequence_435", gecode_constraint_sequence_435, 6);
+YAP_UserCPredicate("gecode_constraint_sequence_433", gecode_constraint_sequence_433, 6);
+YAP_UserCPredicate("gecode_constraint_unshare_464", gecode_constraint_unshare_464, 3);
+YAP_UserCPredicate("gecode_constraint_unshare_462", gecode_constraint_unshare_462, 3);
+YAP_UserCPredicate("gecode_constraint_path_359", gecode_constraint_path_359, 6);
+YAP_UserCPredicate("gecode_constraint_path_350", gecode_constraint_path_350, 6);
YAP_UserCPredicate("gecode_constraint_divmod_165", gecode_constraint_divmod_165, 5);
YAP_UserCPredicate("gecode_constraint_branch_31", gecode_constraint_branch_31, 6);
YAP_UserCPredicate("gecode_constraint_branch_27", gecode_constraint_branch_27, 6);
@@ -540,11 +550,11 @@ YAP_UserCPredicate("gecode_constraint_branch_33", gecode_constraint_branch_33, 6
YAP_UserCPredicate("gecode_constraint_branch_37", gecode_constraint_branch_37, 6);
YAP_UserCPredicate("gecode_constraint_branch_43", gecode_constraint_branch_43, 6);
YAP_UserCPredicate("gecode_constraint_branch_39", gecode_constraint_branch_39, 6);
-YAP_UserCPredicate("gecode_constraint_nooverlap_322", gecode_constraint_nooverlap_322, 9);
+YAP_UserCPredicate("gecode_constraint_nooverlap_332", gecode_constraint_nooverlap_332, 9);
YAP_UserCPredicate("gecode_constraint_cumulative_120", gecode_constraint_cumulative_120, 5);
YAP_UserCPredicate("gecode_constraint_cumulative_132", gecode_constraint_cumulative_132, 5);
-YAP_UserCPredicate("gecode_constraint_member_300", gecode_constraint_member_300, 3);
-YAP_UserCPredicate("gecode_constraint_member_296", gecode_constraint_member_296, 3);
+YAP_UserCPredicate("gecode_constraint_member_310", gecode_constraint_member_310, 3);
+YAP_UserCPredicate("gecode_constraint_member_306", gecode_constraint_member_306, 3);
YAP_UserCPredicate("gecode_constraint_count_111", gecode_constraint_count_111, 6);
YAP_UserCPredicate("gecode_constraint_count_113", gecode_constraint_count_113, 6);
YAP_UserCPredicate("gecode_constraint_count_115", gecode_constraint_count_115, 6);
@@ -553,8 +563,8 @@ YAP_UserCPredicate("gecode_constraint_count_103", gecode_constraint_count_103, 6
YAP_UserCPredicate("gecode_constraint_count_105", gecode_constraint_count_105, 6);
YAP_UserCPredicate("gecode_constraint_count_93", gecode_constraint_count_93, 6);
YAP_UserCPredicate("gecode_constraint_count_95", gecode_constraint_count_95, 6);
-YAP_UserCPredicate("gecode_constraint_pow_352", gecode_constraint_pow_352, 5);
-YAP_UserCPredicate("gecode_constraint_notMin_326", gecode_constraint_notMin_326, 3);
+YAP_UserCPredicate("gecode_constraint_pow_362", gecode_constraint_pow_362, 5);
+YAP_UserCPredicate("gecode_constraint_notMin_336", gecode_constraint_notMin_336, 3);
YAP_UserCPredicate("gecode_constraint_cumulative_127", gecode_constraint_cumulative_127, 8);
YAP_UserCPredicate("gecode_constraint_cumulative_123", gecode_constraint_cumulative_123, 8);
YAP_UserCPredicate("gecode_constraint_cumulative_139", gecode_constraint_cumulative_139, 8);
@@ -577,54 +587,54 @@ YAP_UserCPredicate("gecode_constraint_dom_203", gecode_constraint_dom_203, 3);
YAP_UserCPredicate("gecode_constraint_dom_191", gecode_constraint_dom_191, 3);
YAP_UserCPredicate("gecode_constraint_dom_182", gecode_constraint_dom_182, 3);
YAP_UserCPredicate("gecode_constraint_dom_211", gecode_constraint_dom_211, 3);
-YAP_UserCPredicate("gecode_constraint_linear_263", gecode_constraint_linear_263, 5);
-YAP_UserCPredicate("gecode_constraint_linear_261", gecode_constraint_linear_261, 5);
-YAP_UserCPredicate("gecode_constraint_linear_250", gecode_constraint_linear_250, 5);
-YAP_UserCPredicate("gecode_constraint_linear_249", gecode_constraint_linear_249, 5);
-YAP_UserCPredicate("gecode_constraint_linear_254", gecode_constraint_linear_254, 5);
-YAP_UserCPredicate("gecode_constraint_linear_253", gecode_constraint_linear_253, 5);
-YAP_UserCPredicate("gecode_constraint_linear_258", gecode_constraint_linear_258, 5);
-YAP_UserCPredicate("gecode_constraint_linear_256", gecode_constraint_linear_256, 5);
-YAP_UserCPredicate("gecode_constraint_linear_282", gecode_constraint_linear_282, 5);
-YAP_UserCPredicate("gecode_constraint_linear_281", gecode_constraint_linear_281, 5);
-YAP_UserCPredicate("gecode_constraint_linear_286", gecode_constraint_linear_286, 5);
-YAP_UserCPredicate("gecode_constraint_linear_285", gecode_constraint_linear_285, 5);
-YAP_UserCPredicate("gecode_constraint_linear_272", gecode_constraint_linear_272, 5);
-YAP_UserCPredicate("gecode_constraint_linear_276", gecode_constraint_linear_276, 5);
+YAP_UserCPredicate("gecode_constraint_linear_292", gecode_constraint_linear_292, 5);
+YAP_UserCPredicate("gecode_constraint_linear_291", gecode_constraint_linear_291, 5);
+YAP_UserCPredicate("gecode_constraint_linear_296", gecode_constraint_linear_296, 5);
+YAP_UserCPredicate("gecode_constraint_linear_295", gecode_constraint_linear_295, 5);
+YAP_UserCPredicate("gecode_constraint_linear_273", gecode_constraint_linear_273, 5);
+YAP_UserCPredicate("gecode_constraint_linear_271", gecode_constraint_linear_271, 5);
+YAP_UserCPredicate("gecode_constraint_linear_260", gecode_constraint_linear_260, 5);
+YAP_UserCPredicate("gecode_constraint_linear_259", gecode_constraint_linear_259, 5);
YAP_UserCPredicate("gecode_constraint_linear_264", gecode_constraint_linear_264, 5);
+YAP_UserCPredicate("gecode_constraint_linear_263", gecode_constraint_linear_263, 5);
YAP_UserCPredicate("gecode_constraint_linear_268", gecode_constraint_linear_268, 5);
-YAP_UserCPredicate("gecode_constraint_nooverlap_317", gecode_constraint_nooverlap_317, 6);
-YAP_UserCPredicate("gecode_constraint_nooverlap_320", gecode_constraint_nooverlap_320, 6);
+YAP_UserCPredicate("gecode_constraint_linear_266", gecode_constraint_linear_266, 5);
+YAP_UserCPredicate("gecode_constraint_linear_282", gecode_constraint_linear_282, 5);
+YAP_UserCPredicate("gecode_constraint_linear_286", gecode_constraint_linear_286, 5);
+YAP_UserCPredicate("gecode_constraint_linear_274", gecode_constraint_linear_274, 5);
+YAP_UserCPredicate("gecode_constraint_linear_278", gecode_constraint_linear_278, 5);
+YAP_UserCPredicate("gecode_constraint_nooverlap_327", gecode_constraint_nooverlap_327, 6);
+YAP_UserCPredicate("gecode_constraint_nooverlap_330", gecode_constraint_nooverlap_330, 6);
YAP_UserCPredicate("gecode_constraint_element_245", gecode_constraint_element_245, 6);
YAP_UserCPredicate("gecode_constraint_element_243", gecode_constraint_element_243, 6);
YAP_UserCPredicate("gecode_constraint_element_241", gecode_constraint_element_241, 6);
YAP_UserCPredicate("gecode_constraint_element_239", gecode_constraint_element_239, 6);
-YAP_UserCPredicate("gecode_constraint_rel_395", gecode_constraint_rel_395, 4);
-YAP_UserCPredicate("gecode_constraint_rel_397", gecode_constraint_rel_397, 4);
-YAP_UserCPredicate("gecode_constraint_rel_413", gecode_constraint_rel_413, 4);
-YAP_UserCPredicate("gecode_constraint_rel_411", gecode_constraint_rel_411, 4);
-YAP_UserCPredicate("gecode_constraint_rel_383", gecode_constraint_rel_383, 4);
-YAP_UserCPredicate("gecode_constraint_rel_384", gecode_constraint_rel_384, 4);
+YAP_UserCPredicate("gecode_constraint_rel_405", gecode_constraint_rel_405, 4);
+YAP_UserCPredicate("gecode_constraint_rel_407", gecode_constraint_rel_407, 4);
+YAP_UserCPredicate("gecode_constraint_rel_423", gecode_constraint_rel_423, 4);
+YAP_UserCPredicate("gecode_constraint_rel_421", gecode_constraint_rel_421, 4);
+YAP_UserCPredicate("gecode_constraint_rel_393", gecode_constraint_rel_393, 4);
+YAP_UserCPredicate("gecode_constraint_rel_394", gecode_constraint_rel_394, 4);
+YAP_UserCPredicate("gecode_constraint_rel_391", gecode_constraint_rel_391, 4);
+YAP_UserCPredicate("gecode_constraint_rel_387", gecode_constraint_rel_387, 4);
+YAP_UserCPredicate("gecode_constraint_rel_385", gecode_constraint_rel_385, 4);
+YAP_UserCPredicate("gecode_constraint_rel_390", gecode_constraint_rel_390, 4);
YAP_UserCPredicate("gecode_constraint_rel_381", gecode_constraint_rel_381, 4);
YAP_UserCPredicate("gecode_constraint_rel_377", gecode_constraint_rel_377, 4);
-YAP_UserCPredicate("gecode_constraint_rel_375", gecode_constraint_rel_375, 4);
-YAP_UserCPredicate("gecode_constraint_rel_380", gecode_constraint_rel_380, 4);
-YAP_UserCPredicate("gecode_constraint_rel_371", gecode_constraint_rel_371, 4);
-YAP_UserCPredicate("gecode_constraint_rel_367", gecode_constraint_rel_367, 4);
-YAP_UserCPredicate("gecode_constraint_rel_391", gecode_constraint_rel_391, 4);
-YAP_UserCPredicate("gecode_constraint_rel_393", gecode_constraint_rel_393, 4);
-YAP_UserCPredicate("gecode_constraint_rel_387", gecode_constraint_rel_387, 4);
-YAP_UserCPredicate("gecode_constraint_rel_390", gecode_constraint_rel_390, 4);
-YAP_UserCPredicate("gecode_constraint_rel_399", gecode_constraint_rel_399, 4);
+YAP_UserCPredicate("gecode_constraint_rel_401", gecode_constraint_rel_401, 4);
YAP_UserCPredicate("gecode_constraint_rel_403", gecode_constraint_rel_403, 4);
-YAP_UserCPredicate("gecode_constraint_rel_407", gecode_constraint_rel_407, 4);
-YAP_UserCPredicate("gecode_constraint_rel_408", gecode_constraint_rel_408, 4);
-YAP_UserCPredicate("gecode_constraint_rel_414", gecode_constraint_rel_414, 4);
-YAP_UserCPredicate("gecode_constraint_rel_419", gecode_constraint_rel_419, 4);
-YAP_UserCPredicate("gecode_constraint_rel_421", gecode_constraint_rel_421, 4);
-YAP_UserCPredicate("gecode_constraint_rel_361", gecode_constraint_rel_361, 4);
-YAP_UserCPredicate("gecode_constraint_rel_359", gecode_constraint_rel_359, 4);
-YAP_UserCPredicate("gecode_constraint_min_309", gecode_constraint_min_309, 5);
+YAP_UserCPredicate("gecode_constraint_rel_397", gecode_constraint_rel_397, 4);
+YAP_UserCPredicate("gecode_constraint_rel_400", gecode_constraint_rel_400, 4);
+YAP_UserCPredicate("gecode_constraint_rel_409", gecode_constraint_rel_409, 4);
+YAP_UserCPredicate("gecode_constraint_rel_413", gecode_constraint_rel_413, 4);
+YAP_UserCPredicate("gecode_constraint_rel_417", gecode_constraint_rel_417, 4);
+YAP_UserCPredicate("gecode_constraint_rel_418", gecode_constraint_rel_418, 4);
+YAP_UserCPredicate("gecode_constraint_rel_424", gecode_constraint_rel_424, 4);
+YAP_UserCPredicate("gecode_constraint_rel_429", gecode_constraint_rel_429, 4);
+YAP_UserCPredicate("gecode_constraint_rel_431", gecode_constraint_rel_431, 4);
+YAP_UserCPredicate("gecode_constraint_rel_371", gecode_constraint_rel_371, 4);
+YAP_UserCPredicate("gecode_constraint_rel_369", gecode_constraint_rel_369, 4);
+YAP_UserCPredicate("gecode_constraint_min_319", gecode_constraint_min_319, 5);
YAP_UserCPredicate("gecode_constraint_count_108", gecode_constraint_count_108, 3);
YAP_UserCPredicate("gecode_constraint_count_98", gecode_constraint_count_98, 3);
-YAP_UserCPredicate("gecode_constraint_ite_247", gecode_constraint_ite_247, 6);
+YAP_UserCPredicate("gecode_constraint_ite_257", gecode_constraint_ite_257, 6);
diff --git a/library/gecode/Makefile.in b/library/gecode/Makefile.in
index a770a413c..047553535 100644
--- a/library/gecode/Makefile.in
+++ b/library/gecode/Makefile.in
@@ -72,5 +72,7 @@ clean:
install: all
mkdir -p $(DESTDIR)$(YAPLIBDIR)
mkdir -p $(DESTDIR)$(SHAREDIR)/Yap
+ mkdir -p $(DESTDIR)$(SHAREDIR)/Yap/gecode
$(INSTALL_PROGRAM) $(SOBJS) $(DESTDIR)$(YAPLIBDIR)
$(INSTALL) gecode.yap $(DESTDIR)$(SHAREDIR)/Yap
+ $(INSTALL) $(srcdir)/clpfd.yap $(DESTDIR)$(SHAREDIR)/Yap/gecode
diff --git a/library/gecode/clp_examples/photo.yap b/library/gecode/clp_examples/photo.yap
new file mode 100644
index 000000000..f34bbd290
--- /dev/null
+++ b/library/gecode/clp_examples/photo.yap
@@ -0,0 +1,68 @@
+%% -*- prolog -*-
+%%=============================================================================
+%% Copyright (C) 2011 by Denys Duchier
+%%
+%% This program is free software: you can redistribute it and/or modify it
+%% under the terms of the GNU Lesser General Public License as published by the
+%% Free Software Foundation, either version 3 of the License, or (at your
+%% option) any later version.
+%%
+%% This program is distributed in the hope that it will be useful, but WITHOUT
+%% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+%% FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+%% more details.
+%%
+%% You should have received a copy of the GNU Lesser General Public License
+%% along with this program. If not, see .
+%%=============================================================================
+
+:- use_module(library(gecode/clpfd)).
+:- use_module(library(maplist)).
+
+% 5 people want to have a photograph together, but they have preferences.
+photo(Ex, People, Amount) :-
+ ex(Ex, People, Preferences),
+ length(People, Len),
+ Len0 is Len-1,
+ People ins 0..Len0,
+ all_distinct(People),
+ % Bools are the satisfied constraints
+ maplist(preference_satisfied, Preferences, Bools),
+ length(Preferences, PLen),
+ Amount in 0..PLen,
+ sum( Bools ) #= Amount,
+ % add all satisfied constraints
+ maximize(Amount),
+ labeling([], People).
+
+%reification, use with care
+preference_satisfied(X-Y, B) :-
+ abs(X - Y) #= 1 #<==> B.
+
+ex(s,[Alice,Bob,Carl,Deb,Evan], [Alice-Carl,
+ Carl-Deb,
+ Deb-Alice,
+ Evan-Alice,
+ Bob-Evan,
+ Carl-Evan,
+ Deb-Evan,
+ Evan-Bob]).
+
+ex(l,[Betty,Chris,Donald,Fred,Gary,Mary,Paul,Peter,Susan],
+ [Betty-Donald,
+ Betty-Gary,
+ Betty-Peter,
+ Chris-Gary,
+ Chris-Susan,
+ Donald-Fred,
+ Donald-Gary,
+ Fred-Betty,
+ Fred-Gary,
+ Gary-Mary,
+ Gary-Betty,
+ Mary-Betty,
+ Mary-Susan,
+ Paul-Donald,
+ Paul-Peter,
+ Peter-Susan,
+ Peter-Paul]).
diff --git a/library/gecode/clp_examples/queens.yap b/library/gecode/clp_examples/queens.yap
new file mode 100644
index 000000000..4131a68f5
--- /dev/null
+++ b/library/gecode/clp_examples/queens.yap
@@ -0,0 +1,38 @@
+
+:- use_module(library(gecode/clpfd)).
+:- use_module(library(maplist)).
+
+queens(N, Queens) :-
+ length(Queens, N),
+ Queens ins 1..N,
+ all_distinct(Queens),
+ foldl(inc, Queens, Inc, 0, _), % [0, 1, 2, .... ]
+ foldl(dec, Queens, Dec, 0, _), % [0, -1, -2, ... ]
+ all_distinct(Inc,Queens),
+ all_distinct(Dec,Queens),
+ labeling([], Queens).
+
+inc(_, I0, I0, I) :-
+ I is I0+1.
+
+dec(_, I0, I0, I) :-
+ I is I0-1.
+
+lqueens(N, Queens) :-
+ length(Queens, N),
+ Queens ins 1..N,
+ all_distinct(Queens),
+ lconstrain( Queens, 0 ),
+ labeling([], Queens).
+
+lconstrain([], _).
+lconstrain( [Q|Queens], I0) :-
+ I is I0+1,
+ foldl(constrain(Q, I0), Queens, I, _),
+ lconstrain( Queens, I).
+
+constrain(Q, I, R, J, J1) :-
+ J1 is J+1,
+ Q + I #\= R + J,
+ Q - I #\= R - J.
+
diff --git a/library/gecode/clp_examples/send_more_money.yap b/library/gecode/clp_examples/send_more_money.yap
new file mode 100644
index 000000000..fc03a4337
--- /dev/null
+++ b/library/gecode/clp_examples/send_more_money.yap
@@ -0,0 +1,34 @@
+%% -*- prolog -*-
+%%=============================================================================
+%% Copyright (C) 2011, 2013 by Denys Duchier, Vitor Santos Costa
+%%
+%% This program is free software: you can redistribute it and/or modify it
+%% under the terms of the GNU Lesser General Public License as published by the
+%% Free Software Foundation, either version 3 of the License, or (at your
+%% option) any later version.
+%%
+%% This program is distributed in the hope that it will be useful, but WITHOUT
+%% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+%% FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+%% more details.
+%%
+%% You should have received a copy of the GNU Lesser General Public License
+%% along with this program. If not, see .
+%%=============================================================================
+
+:- use_module(library(gecode/clpfd)).
+
+% S E N D
+% + M O R E
+% ---------
+% M O N E Y
+send_more_money(Letters) :-
+ [S,E,N,D,M,O,R,Y] = Letters,
+ Letters ins 0..9,
+ M #\= 0,
+ S #\= 0,
+ all_distinct(Letters),
+ 1000*S + 100*E + 10*N + D +
+ 1000*M + 100*O + 10*R + E #=
+ 10000*M + 1000*O + 100*N + 10*E + Y,
+ labeling([], Letters).
diff --git a/library/gecode/clp_examples/send_most_money.yap b/library/gecode/clp_examples/send_most_money.yap
new file mode 100644
index 000000000..9665b3eeb
--- /dev/null
+++ b/library/gecode/clp_examples/send_most_money.yap
@@ -0,0 +1,36 @@
+%% -*- prolog -*-
+%%=============================================================================
+%% Copyright (C) 2011, 2013 by Denys Duchier, Vitor Santos Costa
+%%
+%% This program is free software: you can redistribute it and/or modify it
+%% under the terms of the GNU Lesser General Public License as published by the
+%% Free Software Foundation, either version 3 of the License, or (at your
+%% option) any later version.
+%%
+%% This program is distributed in the hope that it will be useful, but WITHOUT
+%% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+%% FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+%% more details.
+%%
+%% You should have received a copy of the GNU Lesser General Public License
+%% along with this program. If not, see .
+%%=============================================================================
+
+:- use_module(library(gecode/clpfd)).
+
+% S E N D
+% + M O S T
+% ---------
+% M O N E Y
+send_most_money(Letters, Money) :-
+ [S,E,N,D,M,O,T,Y] = Letters,
+ Letters ins 0..9,
+ Money in 0..99999,
+ M #\= 0,
+ S #\= 0,
+ all_distinct(Letters),
+ 1000*S + 100*E + 10*N + D +
+ 1000*M + 100*O + 10*S + T #= Money,
+ 10000*M + 1000*O + 100*N + 10*E + Y #= Money,
+ maximize(Money),
+ labeling([], Letters).
diff --git a/library/gecode/clp_examples/test.yap b/library/gecode/clp_examples/test.yap
new file mode 100644
index 000000000..313401511
--- /dev/null
+++ b/library/gecode/clp_examples/test.yap
@@ -0,0 +1,71 @@
+
+:- use_module(library(gecode/clpfd)).
+:- use_module(library(maplist)).
+
+test0(X) :-
+ X in 1..10,
+ X #= 2.
+test1(X) :-
+ X in 1..10,
+ Y in 3..7,
+ Z in 1..4,
+ X / Y #= Z,
+ labeling([], [X]).
+test2(X) :-
+ X in 1..10,
+ X / 4 #= 2,
+ labeling([], [X]).
+test3(A) :-
+ A = [X,Y,Z],
+ A ins 1..4,
+ Y #> 2,
+ lex_chain(A),
+ all_different(A),
+ labeling([], [X,Y,Z]).
+test4(A) :-
+ A = [X,Y,Z],
+ A ins 1..4,
+ Y #> 2,
+ Z #> 3,
+ lex_chain(A),
+ min(A, 1),
+ all_different(A),
+ labeling([], [X,Y,Z]).
+test5(A) :-
+ A = [X,Y,Z],
+ A ins 0..1,
+ in_relation( A, [[0,0,0],[0,1,0],[1,0,0]] ),
+ X #> 0,
+ labeling([], A).
+test6(A+B) :-
+ A = [X,Y,Z],
+ B = [X1,Y1,Z1],
+ A ins 0..1,
+ B ins 0..1,
+ extensional_constraint([[0,0,0],[0,1,0],[1,0,0]], C),
+ in_relation( A, C ),
+ in_relation( B, C ),
+ X #> 0,
+ X1 #< X,
+ Y1 #\= Z1,
+ labeling([], A),
+ labeling([], B).
+test7(A) :-
+ A = [X,Y,Z],
+ A ins 0..1,
+ in_dfa( A, 0, [t(0,0,0),t(0,1,1),t(1,0,0),t(-1,0,0)], [0]),
+ X #> 0,
+ labeling([], A).
+test8(A+B) :-
+ A = [X,Y,Z,W],
+ B = [X1,Y1,Z1,W1],
+ A ins 0..1,
+ B ins 0..1,
+ dfa( 0, [t(0,0,0),t(0,1,1),t(1,0,0),t(-1,0,0)], [0], C),
+ in_dfa( A, C ),
+ in_dfa( B, C ),
+ X #> 0,
+ X1 #< X,
+ Y1 #\= Z1,
+ labeling([], A),
+ labeling([], B).
diff --git a/library/gecode/clpfd.yap b/library/gecode/clpfd.yap
new file mode 100644
index 000000000..999ab9273
--- /dev/null
+++ b/library/gecode/clpfd.yap
@@ -0,0 +1,779 @@
+:- module(clpfd, [
+ op(760, yfx, #<==>),
+ op(750, xfy, #==>),
+ op(750, yfx, #<==),
+ op(740, yfx, #\/),
+ op(730, yfx, #\),
+ op(720, yfx, #/\),
+ op(710, fy, #\),
+ op(700, xfx, #>),
+ op(700, xfx, #<),
+ op(700, xfx, #>=),
+ op(700, xfx, #=<),
+ op(700, xfx, #=),
+ op(700, xfx, #\=),
+ op(700, xfx, in),
+ op(700, xfx, ins),
+ op(450, xfx, ..), % should bind more tightly than \/
+ (#>)/2,
+ (#<)/2,
+ (#>=)/2,
+ (#=<)/2,
+ (#=)/2,
+ (#\=)/2,
+ (#<==>)/2,
+ (#==>)/2,
+ (#<==)/2,
+ (#\)/1,
+ (#\/)/2,
+ (#/\)/2,
+ in/2 ,
+ ins/2,
+ all_different/1,
+ all_distinct/1,
+ all_distinct/2,
+ maximize/1,
+ sum/3,
+ lex_chain/1,
+ minimum/2,
+ min/2,
+ maximum/2,
+ max/2,
+ scalar_product/4,
+ extensional_constraint/2,
+ in_relation/2,
+ dfa/4,
+ in_dfa/2,
+ in_dfa/4, /*
+ tuples_in/2, */
+ labeling/2 /*,
+ label/1,
+ indomain/1,
+ serialized/2,
+ global_cardinality/2,
+ global_cardinality/3,
+ circuit/1,
+ element/3,
+ automaton/3,
+ automaton/8,
+ transpose/2,
+ zcompare/3,
+ chain/2,
+ fd_var/1,
+ fd_inf/2,
+ fd_sup/2,
+ fd_size/2,
+ fd_dom/2 */
+ ]).
+
+:- use_module(library(gecode)).
+:- use_module(library(maplist)).
+
+constraint( (_ #> _) ).
+constraint( (_ #< _) ).
+constraint( (_ #>= _) ).
+constraint( (_ #=< _) ).
+constraint( (_ #= _) ).
+constraint( (_ #\= _) ).
+constraint( (_ #\ _) ).
+constraint( (_ #<==> _) ).
+constraint( (_ #==> _) ).
+constraint( (_ #<== _) ).
+constraint( (_ #\/ _) ).
+constraint( (_ #/\ _) ).
+constraint( in(_, _) ). %2,
+constraint( ins(_, _) ). %2,
+constraint( all_different(_) ). %1,
+constraint( all_distinct(_) ). %1,
+constraint( all_distinct(_,_) ). %1,
+constraint( sum(_, _, _) ). %3,
+constraint( scalar_product(_, _, _, _) ). %4,
+constraint( min(_, _) ). %2,
+constraint( minimum(_, _) ). %2,
+constraint( max(_, _) ). %2,
+constraint( maximum(_, _) ). %2,
+constraint( in_relation(_, _) ). %2,
+constraint( in_dfa(_, _) ). %2,
+constraint( in_dfa(_, _, _, _) ). %2,
+constraint( tuples_in(_, _) ). %2,
+constraint( labeling(_, _) ). %2,
+constraint( label(_) ). %1,
+constraint( indomain(_) ). %1,
+constraint( lex_chain(_) ). %1,
+constraint( serialized(_, _) ). %2,
+constraint( global_cardinality(_, _) ). %2,
+constraint( global_cardinality(_, _, _) ). %3,
+constraint( circuit(_) ). %1,
+constraint( element(_, _, _) ). %3,
+constraint( automaton(_, _, _) ). %3,
+constraint( automaton(_, _, _, _, _, _, _, _) ). %8,
+constraint( transpose(_, _) ). %2,
+constraint( zcompare(_, _, _) ). %3,
+constraint( chain(_, _) ). %2,
+constraint( fd_var(_) ). %1,
+constraint( fd_inf(_, _) ). %2,
+constraint( fd_sup(_, _) ). %2,
+constraint( fd_size(_, _) ). %2,
+constraint( fd_dom(_, _) ). %2
+
+
+
+process_constraints((B0,B1), (NB0, NB1), Env) :-
+ process_constraints(B0, NB0, Env),
+ process_constraints(B1, NB1, Env).
+process_constraints(B, B, env(_Space)) :-
+ constraint(B), !.
+process_constraints(B, B, _Env).
+% process_constraint(B, NB, Space).
+
+( A #= B) :-
+ get_home(Env),
+ post( rel(A, (#=), B), Env, _).
+( A #\= B) :-
+ get_home(Env),
+ post( rel(A, (#\=), B), Env, _).
+( A #< B) :-
+ get_home(Env),
+ post( rel(A, (#<), B), Env, _).
+( A #> B) :-
+ get_home(Env),
+ post( rel(A, (#>), B), Env, _).
+( A #=< B) :-
+ get_home(Env),
+ post( rel(A, (#=<), B), Env, _).
+( A #>= B) :-
+ get_home(Env),
+ post( rel(A, (#>=), B), Env, _).
+sum( L, Op, V) :-
+ get_home( Env ),
+ post( rel(sum(L), Op, V), Env, _).
+( A #<==> VBool) :-
+ get_home(Space-Map),
+ Bool := boolvar(Space),
+ m( VBool, Bool, 0, 1, Map),
+ Space += reify(Bool, 'RM_EQV', R),
+ post(A, Space-Map, R).
+( A #==> VBool) :-
+ get_home(Space-Map),
+ Bool := boolvar(Space),
+ m( VBool, Bool, 0, 1, Map),
+ Space += reify(Bool, 'RM_IMP', R),
+ post(A, Space-Map, R).
+( A #<== VBool) :-
+ get_home(Space-Map),
+ Bool := boolvar(Space),
+ m( VBool, Bool, 0, 1, Map),
+ Space += reify(Bool, 'RM_PMI', R),
+ post(A, Space-Map, R).
+'#\\'(A) :-
+ get_home(Space-Map),
+ B := boolvar(Space),
+ Space += reify(B, 'RM_EQV', R),
+ Space += rel(B, 'BOT_EQV', 0),
+ post(A, Space-Map, R).
+( A1 #\/ A2 ) :-
+ get_home(Space-Map),
+ B1 := boolvar(Space),
+ B2 := boolvar(Space),
+ Space += reify(B1, 'RM_EQV', R1),
+ Space += reify(B2, 'RM_EQV', R2),
+ post(A1, Space-Map, R1),
+ post(A2, Space-Map, R2),
+ Space += rel(B1, B2, 'BOT_OR', 1).
+( A1 #/\ A2 ) :-
+ get_home(Space-Map),
+ B1 := boolvar(Space),
+ B2 := boolvar(Space),
+ Space += reify(B1, 'RM_EQV', R1),
+ Space += reify(B2, 'RM_EQV', R2),
+ post(A1, Space-Map, R1),
+ post(A2, Space-Map, R2),
+ Space += rel(B1, B2, 'BOT_AND', 1).
+( X in A..B) :-
+ get_home(Space-Map),
+ m(X, NX, A, B, Map),
+ NX := intvar(Space, A, B).
+( Xs ins A..B) :-
+ get_home(Space-Map),
+ maplist(lm(A, B, Map), Xs, NXs),
+ length(Xs, N),
+ NXs := intvars(Space, N, A, B).
+all_different( Xs ) :-
+ get_home(Env),
+ post( all_different( Xs ), Env, _ ).
+all_distinct( Xs ) :-
+ get_home(Env),
+ post( all_distinct( Xs ), Env, _ ).
+all_distinct( Cs, Xs ) :-
+ get_home(Env),
+ post( all_distinct( Cs, Xs ), Env, _ ).
+scalar_product( Cs, Vs, Rels, X ) :-
+ get_home(Env),
+ post( scalar_product( Cs, Vs, Rels, X ), Env, _ ).
+lex_chain( Cs ) :-
+ get_home(Env),
+ post( rel( Cs, '#=<' ), Env, _ ).
+minimum( V, Xs ) :-
+ get_home(Env),
+ post( rel( min(Xs), (#=), V ), Env, _ ).
+min( Xs, V ) :-
+ get_home(Env),
+ post( rel( min(Xs), (#=), V ), Env, _ ).
+maximum( V, Xs ) :-
+ get_home(Env),
+ post( rel( max(Xs), (#=), V ), Env, _ ).
+max( Xs, V ) :-
+ get_home(Env),
+ post( rel( max(Xs), (#=), V ), Env, _ ).
+in_relation( Xs, Rel ) :-
+ get_home(Env),
+ post(in_tupleset(Xs, Rel), Env, _ ).
+in_dfa( Xs, Rel ) :-
+ get_home(Env),
+ post(in_dfa(Xs, Rel), Env, _ ).
+in_dfa( Xs, S0, Ts, Fs ) :-
+ get_home(Env),
+ post(in_dfa(Xs, S0, Ts, Fs), Env, _ ).
+
+labeling(_Opts, Xs) :-
+ get_home(Space-Map),
+ maplist(ll(Map), Xs, NXs),
+ Space += branch(NXs, 'INT_VAR_SIZE_MIN', 'INT_VAL_MIN').
+
+maximize(V) :-
+ get_home(Space-Map),
+ l(V, I, Map),
+ Space += maximize(I).
+
+extensional_constraint( Tuples, TupleSet) :-
+ TupleSet := tupleset( Tuples ).
+
+dfa( S0, Transitions, Finals, DFA) :-
+ DFA := dfa( S0, Transitions, Finals ).
+
+post( ( A #= B), Env, Reify) :-
+ post( rel( A, (#=), B), Env, Reify).
+post( ( A #\= B), Env, Reify) :-
+ post( rel( A, (#\=), B), Env, Reify).
+post( ( A #> B), Env, Reify) :-
+ post( rel( A, (#>), B), Env, Reify).
+post( ( A #< B), Env, Reify) :-
+ post( rel( A, (#<), B), Env, Reify).
+post( ( A #>= B), Env, Reify) :-
+ post( rel( A, (#>=), B), Env, Reify).
+post( ( A #=< B), Env, Reify) :-
+ post( rel( A, (#=<), B), Env, Reify).
+% X #< Y
+% X #< 2
+post( rel( A, Op, B), Space-Map, Reify):-
+ var(A),
+ ( var(B) -> l(B, IB, Map) ; integer(B) -> IB = B ), !,
+ l(A, IA, Map),
+ gecode_arith_op( Op, GOP ),
+ (var(Reify) -> Space += rel(IA, GOP, IB) ;
+ Space += rel(IA, GOP, IB, Reify) ).
+% 2 #\= B
+post( rel( A, Op, B), Space-Map, Reify):-
+ var(B), integer(A), !,
+ l(B, IB, Map),
+ gecode_arith_op( Op, GOP ),
+ (var(Reify) -> Space += rel(A, GOP, IB) ;
+ Space += rel(A, GOP, IB, Reify) ).
+% sum([A,B,C]) #= X
+post( rel( sum(L), Op, Out), Space-Map, Reify):-
+ checklist( var, L ),
+ ( var(Out) -> l(Out, IOut, Map) ; integer(Out) -> IOut = Out ), !,
+ var(Out), !,
+ maplist(ll(Map), [Out|L], [IOut|IL] ),
+ gecode_arith_op( Op, GOP ),
+ (var(Reify) ->
+ Space += linear(IL, GOP, IOut);
+ Space += linear(IL, GOP, IOut, Reify)
+ ).
+% [A,B,C,D] #< 3
+post( rel( A, Op ), Space-Map, Reify):-
+ checklist( var, A ), !,
+ maplist(ll(Map), A, IL ),
+ gecode_arith_op( Op, GOP ),
+ (var(Reify) -> Space += rel(IL, GOP) ;
+ Space += rel(IL, GOP, IB) ).
+post( rel( A, Op, B), Space-Map, Reify):-
+ var( A ), !,
+ ( var(B) -> l(B, IB, Map) ; integer(B) -> IB = B ), !,
+ l(A, IA, Map),
+ gecode_arith_op( Op, GOP ),
+ (var(Reify) -> Space += rel(IA, GOP, IB) ;
+ Space += rel(IA, GOP, IB, Reify) ).
+post( rel( A, Op, B), Space-Map, Reify):-
+ checklist( var, A ),
+ ( var(B) -> l(B, IB, Map) ; integer(B) -> IB = B ), !,
+ maplist(ll(Map), A, IL ),
+ gecode_arith_op( Op, GOP ),
+ (var(Reify) -> Space += rel(IL, GOP, IB) ;
+ Space += rel(IL, GOP, IB, Reify) ).
+post( rel(A, Op, B), Space-Map, Reify):-
+ ( nonvar(A), ( A = _+_ ; A = _-_ ) ;
+ nonvar(B), ( B = _ + _ ; B = _-_) ), !,
+ linearize(A, 1, As, Bs, CAs, CBs, 0, A0, Space-Map),
+ linearize(B, -1, Bs, [], CBs, [], A0, B0, Space-Map),
+ gecode_arith_op( Op, GOP ),
+ (var(Reify) ->
+ ( checklist(is_one, CAs) ->
+ Space += linear(As, GOP, B0);
+ Space += linear(CAs, As, GOP, B0)
+ )
+ ;
+ ( checklist(is_one, CAs) ->
+ Space += linear(As, GOP, B0, Reify);
+ Space += linear(CAs, As, GOP, B0, Reify)
+ )
+ ).
+post( rel(A, Op, B), Space-Map, Reify):-
+ nonvar(A),
+ arith(A, Name),
+ A =.. [_Op,A1],
+ is_list(A1), !,
+ ( _Op = min -> true ; _Op = max ),
+ maplist(equality_l( Space-Map), A1, NA1),
+ maplist(in_c_l( Space-Map), NA1, VA1),
+ equality(B, B1, Space-Map),
+ out_c(Name, VA1, B1, Op, Space-Map, Reify).
+post( rel(A, Op, B), Space-Map, Reify):-
+ nonvar(A),
+ arith(A, Name),
+ A =.. [_Op,A1], !,
+ equality(A1, NA1, Space-Map),
+ in_c(NA1, VA1, Space-Map), !,
+ equality(B, B1, Space-Map),
+ out_c(Name, VA1, B1, Op, Space-Map, Reify).
+post( rel(A, Op, B), Space-Map, Reify):-
+ nonvar(A),
+ arith(A, Name),
+ A =.. [_Op,A1,A2], !,
+ equality(A1, NA1, Space-Map),
+ in_c(NA1, VA1, Space-Map),
+ equality(A2, NA2, Space-Map),
+ in_c(NA2, VA2, Space-Map),
+ equality(B, B1, Space-Map),
+ out_c(Name, VA1, VA2, B1, Op, Space-Map, Reify).
+post( scalar_product(Cs, L, Op, Out), Space-Map, Reify):-
+ var(Out), !,
+ maplist(ll(Map), [Out|L], [IOut|IL] ),
+ gecode_arith_op( Op, GOP ),
+ (var(Reify) ->
+ Space += linear(Cs, IL, GOP, IOut);
+ Space += linear(Cs, IL, GOP, IOut, Reify)
+ ).
+post( scalar_product(Cs, L, Op, Out), Space-Map, Reify):-
+ integer(Out), !,
+ maplist(ll(Map), L, IL ),
+ gecode_arith_op( Op, GOP ),
+ (var(Reify) ->
+ Space += linear(Cs, IL, GOP, Out);
+ Space += linear(Cs, IL, GOP, Out, Reify)
+ ).
+post( all_different( Xs ), Space-Map, Reify) :-
+ maplist(ll(Map), Xs, NXs),
+ (var(Reify) ->
+ Space += distinct(NXs)
+ ;
+ throw(error(domain(not_reifiable),all_different( Xs )))
+ ).
+post( all_distinct( Xs ), Space-Map, Reify) :-
+ maplist(ll(Map), Xs, NXs),
+ (var(Reify) ->
+ Space += distinct(NXs)
+ ;
+ throw(error(domain(not_reifiable),all_distinct( Xs )))
+ ).
+post( all_distinct( Cs , Xs ), Space-Map, Reify) :-
+ maplist(ll(Map), Xs, NXs),
+ (var(Reify) ->
+ Space += distinct(Cs,NXs)
+ ;
+ throw(error(domain(not_reifiable),all_distinct( Cs , Xs )))
+ ).
+post(in_tupleset(Xs, Tuples), Space-Map, Reify) :-
+ is_list( Tuples ), !,
+ TS := tupleset( Tuples ),
+ maplist(ll(Map), Xs, IXs),
+ (var(Reify) ->
+ Space += extensional(IXs, TS)
+ ;
+ throw(error(domain(not_reifiable),in_relation(Xs, Tuples)))
+ ).
+post(in_tupleset(Xs, TS), Space-Map, Reify) :-
+ maplist(ll(Map), Xs, IXs),
+ (var(Reify) ->
+ Space += extensional(IXs, TS)
+ ;
+ throw(error(domain(not_reifiable),in_relation(Xs, Tuples)))
+ ).
+post(in_dfa(Xs, S0, Trs, Fs), Space-Map, Reify) :-
+ TS := dfa( S0, Trs, Fs ),
+ maplist(ll(Map), Xs, IXs),
+ (var(Reify) ->
+ Space += extensional(IXs, TS)
+ ;
+ throw(error(domain(not_reifiable),in_dfa(Xs, Tuples)))
+ ).
+post(in_dfa(Xs, TS), Space-Map, Reify) :-
+ maplist(ll(Map), Xs, IXs),
+ (var(Reify) ->
+ Space += extensional(IXs, TS)
+ ;
+ throw(error(domain(not_reifiable),in_dfa(Xs, Tuples)))
+ ).
+
+gecode_arith_op( (#=) , 'IRT_EQ' ).
+gecode_arith_op( (#\=) , 'IRT_NQ' ).
+gecode_arith_op( (#>) , 'IRT_GR' ).
+gecode_arith_op( (#>=) , 'IRT_GQ' ).
+gecode_arith_op( (#<) , 'IRT_LE' ).
+gecode_arith_op( (#=<) , 'IRT_LQ' ).
+
+linearize(V, C, [A|As], As, [C|CAs], CAs, I, I, _-Map) :-
+ var(V), !,
+ l(V, A, Map).
+linearize(A+B, C, As, Bs, CAs, CBs, I, IF, Env) :-
+ linearize(A, C, As, A1s, CAs, CA1s, I, I1, Env),
+ linearize(B, C, A1s, Bs, CA1s, CBs, I1, IF, Env).
+linearize(A-B, C, As, Bs, CAs, CBs, I, IF, Env) :-
+ NC is -C,
+ linearize(A, C, As, A1s, CAs, CA1s, I, I1, Env),
+ linearize(B, NC, A1s, Bs, CA1s, CBs, I1, IF, Env).
+linearize(A, C, As, As, CAs, CAs, I, IF, _) :-
+ integer(A), !,
+ IF is I-C*A.
+linearize(A, C, As, As, CAs, CAs, I, IF, _) :-
+ ground(A),
+ catch( (B is eval(A)), _, fail ), !,
+ IF is I-C*B.
+linearize(C1*B, C, As, Bs, CAs, CBs, I, IF, Env) :-
+ integer(C1), !,
+ NC is C*C1,
+ linearize(B, NC, As, Bs, CAs, CBs, I, IF, Env).
+linearize(B*C1, C, As, Bs, CAs, CBs, I, IF, Env) :-
+ integer(C1), !,
+ NC is C*C1,
+ linearize(B, NC, As, Bs, CAs, CBs, I, IF, Env).
+linearize(AC, C, [A|Bs], Bs, [C|CBs], CBs, I, I, Env) :-
+ arith(AC, _),
+ equality(AC, V, Env),
+ Env = _-Map,
+ l(V, A, Map).
+
+arith(abs(_), abs).
+arith(min(_), min).
+arith(max(_), max).
+arith(min(_,_), min).
+arith(max(_,_), max).
+arith((_ * _), times).
+arith((_ / _), div).
+arith((_ mod _), mod).
+
+% replace abs(min(A,B)-max(A,B)) by
+% min(A,B,A1), max(A,B,A2), linear([1,-1],[A1,B1],=,A3), abs(A3,AN)
+equality(V, V, _Env) :-
+ var( V ), !.
+equality(V, V, _Env) :-
+ integer( V ), !.
+equality(abs(V), NV, Env) :-
+ equality(V, VA, Env),
+ new_arith(abs, VA, NV, Env).
+equality(min(V), NV, Env) :-
+ maplist( equality_l(Env), V, VA ),
+ new_arith(min, VA, NV, Env).
+equality(max(V), NV, Env) :-
+ maplist( equality_l(Env), V, VA ),
+ new_arith(max, VA, NV, Env).
+equality(V1+V2, NV, Env) :-
+ equality(V1, V1A, Env),
+ equality(V2, V2A, Env),
+ new_arith( plus, V1A, V2A, NV, Env).
+equality(V1-V2, NV, Env) :-
+ equality(V1, V1A, Env),
+ equality(V2, V2A, Env),
+ new_arith( minus, V1A, V2A, NV, Env).
+equality(V1*V2, NV, Env) :-
+ equality(V1, V1A, Env),
+ equality(V2, V2A, Env),
+ new_arith( times, V1A, V2A, NV, Env).
+equality(V1/V2, NV, Env) :-
+ equality(V1, V1A, Env),
+ equality(V2, V2A, Env),
+ new_arith( div, V1A, V2A, NV, Env).
+equality(V1 mod V2, NV, Env) :-
+ equality(V1, V1A, Env),
+ equality(V2, V2A, Env),
+ new_arith( (mod), V1A, V2A, NV, Env).
+equality(max( V1 , V2), NV, Env) :-
+ equality(V1, V1A, Env),
+ equality(V2, V2A, Env),
+ new_arith( (max), V1A, V2A, NV, Env).
+equality(min( V1 , V2), NV, Env) :-
+ equality(V1, V1A, Env),
+ equality(V2, V2A, Env),
+ new_arith( (min), V1A, V2A, NV, Env).
+
+equality_l(Env, V0, V) :-
+ equality(V0, V, Env).
+
+% abs(X) #= 3
+out_c(Name, A1, B, Op, Space-Map, Reify) :-
+ integer(B), !,
+ new_arith( Name, A1, NB, Space-Map),
+ gecode_arith_op( Op, BOP ),
+ l(NB, IB, Map),
+ ( var(Reify) ->
+ Space += rel(IB, BOP, B)
+ ;
+ Space += rel(IB, BOP, B, Reify)
+ ).
+% abs(X) #= Cin[..]
+out_c(Name, A1, B, (#=), Space-Map, Reify) :-
+ var(Reify),
+ l(B, IB, Map), !,
+ l(A1, IA1, Map),
+ G =.. [Name, IA1, IB],
+ Space += G.
+% abs(X) #= NEW
+out_c(Name, A1, B, (#=), Space-Map, Reify) :-
+ var(Reify), !,
+ new_arith( Name, A1, B, Space-Map).
+% abs(X) #> NEW
+out_c(Name, A1, B, Op, Space-Map, Reify) :-
+ l(B, IB0, Map), !,
+ new_arith( Name, A1, NB, Space-Map),
+ l(NB, IB, Map),
+ gecode_arith_op( Op, BOP ),
+ (
+ nonvar(Reify) ->
+ Space += rel(IB, BOP, IB0)
+ ;
+ Space += rel(IB, BOP, IB0, Reify)
+ ).
+
+% X*Y #= 3
+out_c(Name, A1, A2, B, Op, Space-Map, Reify) :-
+ integer(B), !,
+ new_arith( Name, A1, A2, NB, Space-Map),
+ l(NB, IB, Map),
+ gecode_arith_op( Op, BOP ),
+ ( var(Reify) ->
+ Space += rel(IB, BOP, B)
+ ;
+ Space += rel(IB, BOP, B, Reify)
+ ).
+% X*Y #= Cin[..]
+out_c(Name, A1, A2, B, (#=), Space-Map, Reify) :-
+ var(Reify),
+ l(B, IB, Map), !,
+ l(A1, IA1, Map),
+ l(A2, IA2, Map),
+ G =.. [Name, IA1, IA2, IB],
+ Space += G.
+% abs(X) #= NEW, cannot be reified
+out_c(Name, A1, A2, B, (#=), Space-Map, Reify) :-
+ var(Reify), !,
+ new_arith( Name, A1, A2, B, Space-Map).
+% min(X,Y) #= Cin[..] <=>
+out_c(Name, A1, A2, B, Space-Map, Reify) :-
+ l(B, IB0, Map), !,
+ new_arith( Name, A1, A2, NB, Space-Map),
+ l(NB, IB, Map),
+ gecode_arith_op( Op, BOP ),
+ ( var(Reify) ->
+ Space += rel(IB, BOP, IB0)
+ ;
+ Space += rel(IB, BOP, IB0, Reify)
+ ).
+
+new_arith( abs, V, NV, Space-Map) :-
+ l(V, X, Min0, Max0, Map),
+ ( Min0 < 0 ->
+ ( Max0 < 0 -> Min is -Max0, Max is -Min0 ;
+ Min = 0 , Max is max( -Min0, Max0 ) )
+ ;
+ Min = Min0, Max = Max0
+ ),
+ NX := intvar(Space, Min, Max),
+ m(NV, NX, Min, Max, Map),
+ Space += abs(X, NX).
+
+new_arith( min, V, NV, Space-Map) :-
+ V = [V1|RV],
+ l(V1, X1, Min0, Max0, Map),
+ foldl2( min_l(Map), RV, Max0, Max, Min0, Min),
+ NX := intvar(Space, Min, Max),
+ m(NV, NX, Min, Max, Map),
+ maplist(ll(Map), V, X),
+ Space += min(X, NX).
+
+new_arith( max, V, NV, Space-Map) :-
+ V = [V1|RV],
+ l(V1, X, Min0, Max0, Map),
+ foldl2( max_l(Map), RV, Max0, Max, Min0, Min),
+ NX := intvar(Space, Min, Max),
+ m(NV, NX, Min, Max, Map),
+ maplist(ll(Map), V, X),
+ Space += min(X, NX).
+
+new_arith( minus, V1, V2, NV, Space-Map) :-
+ l(V1, X1, Min1, Max1, Map),
+ l(V2, X2, Min2, Max2, Map),
+ Min is Min1-Max2,
+ Max is Max1-Min2,
+ NX := intvar(Space, Min, Max),
+ m(NV, NX, Min, Max, Map),
+ Space += linear([1,-1], [X1,X2], 'IRT_EQ', NX).
+
+new_arith( plua, V1, V2, NV, Space-Map) :-
+ l(V1, X1, Min1, Max1, Map),
+ l(V2, X2, Min2, Max2, Map),
+ Min is Min1+Min2,
+ Max is Max1+Max2,
+ NX := intvar(Space, Min, Max),
+ m(NV, NX, Min, Max, Map),
+ Space += linear([1,1], [X1,X2], 'IRT_EQ', NX).
+
+new_arith( min, V1, V2, NV, Space-Map) :-
+ l(V1, X1, Min1, Max1, Map),
+ l(V2, X2, Min2, Max2, Map),
+ Min is min(Min1,Min2),
+ Max is min(Max1,Max2),
+ NX := intvar(Space, Min, Max),
+ m(NV, NX, Min, Max, Map),
+ Space += min(X1, X2, NX).
+
+new_arith( max, V1, V2, NV, Space-Map) :-
+ l(V1, X1, Min1, Max1, Map),
+ l(V2, X2, Min2, Max2, Map),
+ Min is max(Min1,Min2),
+ Max is max(Max1,Max2),
+ NX := intvar(Space, Min, Max),
+ m(NV, NX, Min, Max, Map),
+ Space += max(X1, X2, NX).
+
+new_arith( times, V1, V2, NV, Space-Map) :-
+ l(V1, X1, Min1, Max1, Map),
+ l(V2, X2, Min2, Max2, Map),
+ min_times(Min1,Min2,Max1,Max2,Min),
+ max_times(Min1,Min2,Max1,Max2,Max),
+ NX := intvar(Space, Min, Max),
+ m(NV, NX, Min, Max, Map),
+ Space += times(X1, X2, NX).
+
+new_arith( (div), V1, V2, NV, Space-Map) :-
+ l(V1, X1, Min1, Max1, Map),
+ l(V2, X2, Min2, Max2, Map),
+ min_div(Min1,Min2,Max1,Max2,Min),
+ max_div(Min1,Min2,Max1,Max2,Max),
+ NX := intvar(Space, Min, Max),
+ m(NV, NX, Min, Max, Map),
+ Space += div(X1, X2, NX).
+
+new_arith( (mod), V1, V2, NV, Space-Map) :-
+ l(V1, X1, _Min1, Max1, Map),
+ l(V2, X2, Min2, Max2, Map),
+ Min is 0,
+ Max is min(abs(Max1), Max2-1),
+ NX := intvar(Space, Min, Max),
+ m(NV, NX, Min, Max, Map),
+ Space += mod(X1, X2, NX).
+
+
+min_times(Min1,Min2,Max1,Max2,Min) :-
+ Min is min(Min1*Min2, min(Min1*Max2, min(Max1*Min2, Max1*Max2))).
+
+max_times(Min1,Min2,Max1,Max2,Max) :-
+ Max is max(Min1*Min2, max(Min1*Max2, max(Max1*Min2, Max1*Max2))).
+
+min_div(Min1,Min20,Max1,Max20,Min) :-
+ ( Min20 == 0 -> Min2 = 1 ; Min2 = Min20),
+ ( Max20 == 0 -> Max2 = -1; Max2 = Max20),
+ Min is min(Min1 div Min2, min(Min1 div Max2, min(Max1 div Min2, Max1 div Max2))).
+
+max_div(Min1,Min20,Max1,Max20,Max) :-
+ ( Min20 == 0 -> Min2 = 1 ; Min2 = Min20),
+ ( Max20 == 0 -> Max2 = -1; Max2 = Max20),
+ Max is max(Min1 div Min2, max(Min1 div Max2, max(Max1 div Min2, Max1 div Max2))).
+
+min_l(Map, V, Min0, Min, Max0, Max) :-
+ l(V, _, Min1, Max1, Map),
+ Min is min(Min0, Min1),
+ Max is min(Max0, Max1).
+
+max_l(Map, V, Min0, Min, Max0, Max) :-
+ l(V, _, Min1, Max1, Map),
+ Min is max(Min0, Min1),
+ Max is max(Max0, Max1).
+
+in_c(A, A, _y) :-
+ var(A), !.
+in_c(C, A, Space-Map) :-
+ integer(C),
+ Min is C-1,
+ NX := intvar(Space, Min, C),
+ m(A, NX, Min, C, Map),
+ Space += rel(NX, 'IRT_EQ', C).
+
+in_c_l(Env, V, IV) :-
+ in_c(V, IV, Env).
+
+user:term_expansion( ( H :- B), (H :- (clpfd:init_gecode(Space, Me), NB, clpfd:close_gecode(Space, Vs, Me)) ) ) :-
+ process_constraints(B, NB, Env),
+ term_variables(H, Vs),
+ nonvar( Env ), !,
+ Env = env( Space ).
+
+init_gecode(Space, old) :-
+ nb_current(gecode_space, Space), nonvar(Space), !.
+init_gecode(Space-Map, new) :-
+ Space := space,
+ b_setval(gecode_space, Space-Map).
+
+close_gecode(_Space, _Vs, old) :- !.
+close_gecode(Space-Map, Vs0, new) :-
+ term_variables(Vs0, Vs),
+ selectlist(intvar(Map), Vs, CVs),
+ maplist(ll(Map), CVs, IVs),
+ SolSpace := search(Space),
+ CVs := val(SolSpace,IVs).
+
+intvar(Map, V) :-
+ l(V, _IV, Map).
+
+get_home(Home) :-
+ b_getval(gecode_space, Home).
+
+m(NV, OV, NA, NB, Vs) :-
+ var(Vs), !,
+ Vs = [v(NV,OV,NA,NB)|_].
+m(NV, OV, NA, NB, [_|Vs]) :-
+ m(NV, OV, NA, NB, Vs).
+
+lm(A, B, Map, X, Y) :-
+ m(X, Y, A, B, Map).
+
+l(NV, OV, Vs) :-
+ var(Vs), !,
+ fail.
+l(NV, OV, [v(V, OV, _A, _B)|_Vs]) :-
+ V == NV, !.
+l(NV, OV, [_|Vs]) :-
+ l(NV, OV, Vs).
+
+ll(Map, X, Y) :-
+ l(X, Y, Map).
+
+l(NV, OV, _, _, Vs) :-
+ var(Vs), !,
+ fail.
+l(NV, OV, A, B, [v(V, OV, A, B)|_Vs]) :-
+ V == NV, !.
+l(NV, OV, A, B, [_|Vs]) :-
+ l(NV, OV, A, B, Vs).
+
+is_one(1).
+
diff --git a/library/gecode/dev/code-generator.py b/library/gecode/dev/code-generator.py
index e2d2d7193..fa71c8df9 100644
--- a/library/gecode/dev/code-generator.py
+++ b/library/gecode/dev/code-generator.py
@@ -190,9 +190,7 @@ class DeclsLoader(object):
class PredGenerator(DeclsLoader):
- OMIT = ("DFA", # NOT YET SUPPORTED!!!
- "TupleSet", # NOT YET SUPPORTED!!!
- "VarBranchOptions",
+ OMIT = ("VarBranchOptions",
"ValBranchOptions",
"TieBreakVarBranch",
"TieBreak",
diff --git a/library/gecode/dev/gecode-enums-4.2.0.py b/library/gecode/dev/gecode-enums-4.2.0.py
new file mode 100644
index 000000000..c1c631ee2
--- /dev/null
+++ b/library/gecode/dev/gecode-enums-4.2.0.py
@@ -0,0 +1,95 @@
+# This file was automatically extracted from Gecode source files.
+# It is subject to the same Copyright as the source files from which
+# it is derived, and is distributed under the same Licensing conditions.
+ENUM_CLASSES = []
+
+class ScriptMode(object):
+ TYPE = 'ScriptMode'
+ ENUM = ['SM_SOLUTION','SM_TIME','SM_STAT','SM_GIST']
+
+ENUM_CLASSES.append(ScriptMode)
+
+class RestartMode(object):
+ TYPE = 'RestartMode'
+ ENUM = ['RM_NONE','RM_CONSTANT','RM_LINEAR','RM_LUBY','RM_GEOMETRIC']
+
+ENUM_CLASSES.append(RestartMode)
+
+class FloatRelType(object):
+ TYPE = 'FloatRelType'
+ ENUM = ['FRT_EQ','FRT_NQ','FRT_LQ','FRT_LE','FRT_GQ','FRT_GR']
+
+ENUM_CLASSES.append(FloatRelType)
+
+class ReifyMode(object):
+ TYPE = 'ReifyMode'
+ ENUM = ['RM_EQV','RM_IMP','RM_PMI']
+
+ENUM_CLASSES.append(ReifyMode)
+
+class IntRelType(object):
+ TYPE = 'IntRelType'
+ ENUM = ['IRT_EQ','IRT_NQ','IRT_LQ','IRT_LE','IRT_GQ','IRT_GR']
+
+ENUM_CLASSES.append(IntRelType)
+
+class BoolOpType(object):
+ TYPE = 'BoolOpType'
+ ENUM = ['BOT_AND','BOT_OR','BOT_IMP','BOT_EQV','BOT_XOR']
+
+ENUM_CLASSES.append(BoolOpType)
+
+class IntConLevel(object):
+ TYPE = 'IntConLevel'
+ ENUM = ['ICL_VAL','ICL_BND','ICL_DOM','ICL_DEF']
+
+ENUM_CLASSES.append(IntConLevel)
+
+class TaskType(object):
+ TYPE = 'TaskType'
+ ENUM = ['TT_FIXP','TT_FIXS','TT_FIXE']
+
+ENUM_CLASSES.append(TaskType)
+
+class ExtensionalPropKind(object):
+ TYPE = 'ExtensionalPropKind'
+ ENUM = ['EPK_DEF','EPK_SPEED','EPK_MEMORY']
+
+ENUM_CLASSES.append(ExtensionalPropKind)
+
+class ViewSelStatus(object):
+ TYPE = 'ViewSelStatus'
+ ENUM = ['VSS_BEST','VSS_BETTER','VSS_TIE','VSS_WORSE']
+
+ENUM_CLASSES.append(ViewSelStatus)
+
+class ExecStatus(object):
+ TYPE = 'ExecStatus'
+ ENUM = ['__ES_SUBSUMED','ES_FAILED','ES_NOFIX','ES_OK','ES_FIX','ES_NOFIX_FORCE','__ES_PARTIAL']
+
+ENUM_CLASSES.append(ExecStatus)
+
+class ActorProperty(object):
+ TYPE = 'ActorProperty'
+ ENUM = ['AP_DISPOSE','AP_WEAKLY']
+
+ENUM_CLASSES.append(ActorProperty)
+
+class SpaceStatus(object):
+ TYPE = 'SpaceStatus'
+ ENUM = ['SS_FAILED','SS_SOLVED','SS_BRANCH']
+
+ENUM_CLASSES.append(SpaceStatus)
+
+class SetRelType(object):
+ TYPE = 'SetRelType'
+ ENUM = ['SRT_EQ','SRT_NQ','SRT_SUB','SRT_SUP','SRT_DISJ','SRT_CMPL','SRT_LQ','SRT_LE','SRT_GQ','SRT_GR']
+
+ENUM_CLASSES.append(SetRelType)
+
+class SetOpType(object):
+ TYPE = 'SetOpType'
+ ENUM = ['SOT_UNION','SOT_DUNION','SOT_INTER','SOT_MINUS']
+
+ENUM_CLASSES.append(SetOpType)
+
diff --git a/library/gecode/dev/gecode-prototypes-4.2.0.hh b/library/gecode/dev/gecode-prototypes-4.2.0.hh
new file mode 100644
index 000000000..8fe67ddf5
--- /dev/null
+++ b/library/gecode/dev/gecode-prototypes-4.2.0.hh
@@ -0,0 +1,280 @@
+// This file was automatically extracted from Gecode source files.
+// It is subject to the same Copyright as the source files from which
+// it is derived, and is distributed under the same Licensing conditions.
+BrancherHandle assign(Home,BoolVar,IntAssign,BoolVarValPrint=NULL);
+BrancherHandle assign(Home,const BoolVarArgs&,IntAssign,BoolBranchFilter=NULL,BoolVarValPrint=NULL);
+BrancherHandle assign(Home,const FloatVarArgs&,FloatAssign,FloatBranchFilter=NULL,FloatVarValPrint=NULL);
+BrancherHandle assign(Home,const IntVarArgs&,IntAssign,IntBranchFilter=NULL,IntVarValPrint=NULL);
+BrancherHandle assign(Home,const SetVarArgs&,SetAssign,SetBranchFilter=NULL,SetVarValPrint=NULL);
+BrancherHandle assign(Home,FloatVar,FloatAssign,FloatVarValPrint=NULL);
+BrancherHandle assign(Home,IntVar,IntAssign,IntVarValPrint=NULL);
+BrancherHandle assign(Home,SetVar,SetAssign,SetVarValPrint=NULL);
+BrancherHandle branch(Home,BoolVar,IntValBranch,BoolVarValPrint=NULL);
+BrancherHandle branch(Home,const BoolVarArgs&,IntVarBranch,IntValBranch,BoolBranchFilter=NULL,BoolVarValPrint=NULL);
+BrancherHandle branch(Home,const BoolVarArgs&,IntVarBranch,IntValBranch,const Symmetries&,BoolBranchFilter=NULL,BoolVarValPrint=NULL);
+BrancherHandle branch(Home,const BoolVarArgs&,TieBreak,IntValBranch,BoolBranchFilter=NULL,BoolVarValPrint=NULL);
+BrancherHandle branch(Home,const BoolVarArgs&,TieBreak,IntValBranch,const Symmetries&,BoolBranchFilter=NULL,BoolVarValPrint=NULL);
+BrancherHandle branch(Home,const FloatVarArgs&,FloatVarBranch,FloatValBranch,FloatBranchFilter=NULL,FloatVarValPrint=NULL);
+BrancherHandle branch(Home,const FloatVarArgs&,TieBreak,FloatValBranch,FloatBranchFilter=NULL,FloatVarValPrint=NULL);
+BrancherHandle branch(Home,const IntVarArgs&,IntVarBranch,IntValBranch,const Symmetries&,IntBranchFilter=NULL,IntVarValPrint=NULL);
+BrancherHandle branch(Home,const IntVarArgs&,IntVarBranch,IntValBranch,IntBranchFilter=NULL,IntVarValPrint=NULL);
+BrancherHandle branch(Home,const IntVarArgs&,TieBreak,IntValBranch,const Symmetries&,IntBranchFilter=NULL,IntVarValPrint=NULL);
+BrancherHandle branch(Home,const IntVarArgs&,TieBreak,IntValBranch,IntBranchFilter=NULL,IntVarValPrint=NULL);
+BrancherHandle branch(Home,const SetVarArgs&,SetVarBranch,SetValBranch,const Symmetries&,SetBranchFilter=NULL,SetVarValPrint=NULL);
+BrancherHandle branch(Home,const SetVarArgs&,SetVarBranch,SetValBranch,SetBranchFilter=NULL,SetVarValPrint=NULL);
+BrancherHandle branch(Home,const SetVarArgs&,TieBreak,SetValBranch,const Symmetries&,SetBranchFilter=NULL,SetVarValPrint=NULL);
+BrancherHandle branch(Home,const SetVarArgs&,TieBreak,SetValBranch,SetBranchFilter=NULL,SetVarValPrint=NULL);
+BrancherHandle branch(Home,FloatVar,FloatValBranch,FloatVarValPrint=NULL);
+BrancherHandle branch(Home,IntVar,IntValBranch,IntVarValPrint=NULL);
+BrancherHandle branch(Home,SetVar,SetValBranch,SetVarValPrint=NULL);
+void abs(Home,FloatVar,FloatVar);
+void abs(Home,IntVar,IntVar,IntConLevel=ICL_DEF);
+void atmostOne(Home,const SetVarArgs&,unsigned int);
+void binpacking(Home,const IntVarArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cardinality(Home,const SetVarArgs&,unsigned int,unsigned int);
+void cardinality(Home,SetVar,IntVar);
+void cardinality(Home,SetVar,unsigned int,unsigned int);
+void channel(Home,BoolVar,IntVar,IntConLevel=ICL_DEF);
+void channel(Home,const BoolVarArgs&,IntVar,int=0,IntConLevel=ICL_DEF);
+void channel(Home,const BoolVarArgs&,SetVar);
+void channel(Home,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void channel(Home,const IntVarArgs&,const SetVarArgs&);
+void channel(Home,const IntVarArgs&,int,const IntVarArgs&,int,IntConLevel=ICL_DEF);
+void channel(Home,const SetVarArgs&,const SetVarArgs&);
+void channel(Home,FloatVar,IntVar);
+void channel(Home,IntVar,FloatVar);
+void channelSorted(Home,const IntVarArgs&,SetVar);
+void circuit(Home,const IntArgs&,const IntVarArgs&,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void circuit(Home,const IntArgs&,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void circuit(Home,const IntArgs&,int,const IntVarArgs&,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void circuit(Home,const IntArgs&,int,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void circuit(Home,const IntVarArgs&,IntConLevel=ICL_DEF);
+void circuit(Home,int,const IntVarArgs&,IntConLevel=ICL_DEF);
+void clause(Home,BoolOpType,const BoolVarArgs&,const BoolVarArgs&,BoolVar,IntConLevel=ICL_DEF);
+void clause(Home,BoolOpType,const BoolVarArgs&,const BoolVarArgs&,int,IntConLevel=ICL_DEF);
+void convex(Home,SetVar);
+void convex(Home,SetVar,SetVar);
+void count(Home,const IntVarArgs&,const IntArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSetArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSetArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSet&,const IntArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSet&,IntRelType,int,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSet&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,int,IntRelType,int,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,int,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,IntVar,IntRelType,int,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,IntVar,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const IntVarArgs&,const IntArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const IntVarArgs&,const IntArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const IntVarArgs&,const IntArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const IntVarArgs&,const IntArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntArgs&,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntArgs&,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void distinct(Home,const IntArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void distinct(Home,const IntVarArgs&,IntConLevel=ICL_DEF);
+void div(Home,FloatVar,FloatVar,FloatVar);
+void div(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void divmod(Home,IntVar,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void dom(Home,BoolVar,BoolVar,IntConLevel=ICL_DEF);
+void dom(Home,const BoolVarArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void dom(Home,const FloatVarArgs&,const FloatVarArgs&);
+void dom(Home,const FloatVarArgs&,FloatNum,FloatNum);
+void dom(Home,const FloatVarArgs&,FloatVal);
+void dom(Home,const IntVarArgs&,const IntSet&,IntConLevel=ICL_DEF);
+void dom(Home,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void dom(Home,const IntVarArgs&,int,IntConLevel=ICL_DEF);
+void dom(Home,const IntVarArgs&,int,int,IntConLevel=ICL_DEF);
+void dom(Home,const SetVarArgs&,const SetVarArgs&);
+void dom(Home,const SetVarArgs&,SetRelType,const IntSet&);
+void dom(Home,const SetVarArgs&,SetRelType,int);
+void dom(Home,const SetVarArgs&,SetRelType,int,int);
+void dom(Home,FloatVar,FloatNum,FloatNum);
+void dom(Home,FloatVar,FloatNum,FloatNum,Reify);
+void dom(Home,FloatVar,FloatVal);
+void dom(Home,FloatVar,FloatVal,Reify);
+void dom(Home,FloatVar,FloatVar);
+void dom(Home,IntVar,const IntSet&,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,const IntSet&,Reify,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,int,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,int,int,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,int,int,Reify,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,int,Reify,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,IntVar,IntConLevel=ICL_DEF);
+void dom(Home,SetVar,SetRelType,const IntSet&);
+void dom(Home,SetVar,SetRelType,const IntSet&,Reify);
+void dom(Home,SetVar,SetRelType,int);
+void dom(Home,SetVar,SetRelType,int,int);
+void dom(Home,SetVar,SetRelType,int,int,Reify);
+void dom(Home,SetVar,SetRelType,int,Reify);
+void dom(Home,SetVar,SetVar);
+void element(Home,const BoolVarArgs&,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void element(Home,const BoolVarArgs&,IntVar,int,IntConLevel=ICL_DEF);
+void element(Home,const BoolVarArgs&,IntVar,int,IntVar,int,BoolVar,IntConLevel=ICL_DEF);
+void element(Home,const IntSetArgs&,IntVar,int,IntVar,int,SetVar);
+void element(Home,const IntSetArgs&,IntVar,SetVar);
+void element(Home,const IntVarArgs&,IntVar,int,IntConLevel=ICL_DEF);
+void element(Home,const IntVarArgs&,IntVar,int,IntVar,int,IntVar,IntConLevel=ICL_DEF);
+void element(Home,const IntVarArgs&,IntVar,IntVar,IntConLevel=ICL_DEF);
+void element(Home,const SetVarArgs&,IntVar,int,IntVar,int,SetVar);
+void element(Home,const SetVarArgs&,IntVar,SetVar);
+void element(Home,IntSharedArray,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void element(Home,IntSharedArray,IntVar,int,IntConLevel=ICL_DEF);
+void element(Home,IntSharedArray,IntVar,int,IntVar,int,BoolVar,IntConLevel=ICL_DEF);
+void element(Home,IntSharedArray,IntVar,int,IntVar,int,IntVar,IntConLevel=ICL_DEF);
+void element(Home,IntSharedArray,IntVar,IntVar,IntConLevel=ICL_DEF);
+void element(Home,SetOpType,const IntArgs&,SetVar,SetVar,const IntSet&=IntSet(Set::Limits::min,Set::Limits::max));
+void element(Home,SetOpType,const IntSetArgs&,SetVar,SetVar,const IntSet&=IntSet(Set::Limits::min,Set::Limits::max));
+void element(Home,SetOpType,const IntVarArgs&,SetVar,SetVar,const IntSet&=IntSet(Set::Limits::min,Set::Limits::max));
+void element(Home,SetOpType,const SetVarArgs&,SetVar,SetVar,const IntSet&=IntSet(Set::Limits::min,Set::Limits::max));
+void extensional(Home,const BoolVarArgs&,const TupleSet&,ExtensionalPropKind=EPK_DEF,IntConLevel=ICL_DEF);
+void extensional(Home,const BoolVarArgs&,DFA,IntConLevel=ICL_DEF);
+void extensional(Home,const IntVarArgs&,const TupleSet&,ExtensionalPropKind=EPK_DEF,IntConLevel=ICL_DEF);
+void extensional(Home,const IntVarArgs&,DFA,IntConLevel=ICL_DEF);
+void ite(Home,BoolVar,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void linear(Home,const BoolVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void linear(Home,const BoolVarArgs&,IntRelType,int,Reify,IntConLevel=ICL_DEF);
+void linear(Home,const BoolVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void linear(Home,const BoolVarArgs&,IntRelType,IntVar,Reify,IntConLevel=ICL_DEF);
+void linear(Home,const FloatValArgs&,const FloatVarArgs&,FloatRelType,FloatNum);
+void linear(Home,const FloatValArgs&,const FloatVarArgs&,FloatRelType,FloatNum,Reify);
+void linear(Home,const FloatValArgs&,const FloatVarArgs&,FloatRelType,FloatVar);
+void linear(Home,const FloatValArgs&,const FloatVarArgs&,FloatRelType,FloatVar,Reify);
+void linear(Home,const FloatVarArgs&,FloatRelType,FloatNum);
+void linear(Home,const FloatVarArgs&,FloatRelType,FloatNum,Reify);
+void linear(Home,const FloatVarArgs&,FloatRelType,FloatVar);
+void linear(Home,const FloatVarArgs&,FloatRelType,FloatVar,Reify);
+void linear(Home,const IntArgs&,const BoolVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const BoolVarArgs&,IntRelType,int,Reify,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const BoolVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const BoolVarArgs&,IntRelType,IntVar,Reify,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const IntVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const IntVarArgs&,IntRelType,int,Reify,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const IntVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const IntVarArgs&,IntRelType,IntVar,Reify,IntConLevel=ICL_DEF);
+void linear(Home,const IntVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void linear(Home,const IntVarArgs&,IntRelType,int,Reify,IntConLevel=ICL_DEF);
+void linear(Home,const IntVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntVarArgs&,IntRelType,IntVar,Reify,IntConLevel=ICL_DEF);
+void max(Home,const FloatVarArgs&,FloatVar);
+void max(Home,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void max(Home,FloatVar,FloatVar,FloatVar);
+void max(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void max(Home,SetVar,IntVar);
+void max(Home,SetVar,IntVar,Reify);
+void member(Home,const BoolVarArgs&,BoolVar,IntConLevel=ICL_DEF);
+void member(Home,const BoolVarArgs&,BoolVar,Reify,IntConLevel=ICL_DEF);
+void member(Home,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void member(Home,const IntVarArgs&,IntVar,Reify,IntConLevel=ICL_DEF);
+void min(Home,const FloatVarArgs&,FloatVar);
+void min(Home,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void min(Home,FloatVar,FloatVar,FloatVar);
+void min(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void min(Home,SetVar,IntVar);
+void min(Home,SetVar,IntVar,Reify);
+void mod(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void mult(Home,FloatVar,FloatVar,FloatVar);
+void mult(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void nooverlap(Home,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void nooverlap(Home,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void nooverlap(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void nooverlap(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void notMax(Home,SetVar,IntVar);
+void notMin(Home,SetVar,IntVar);
+void nroot(Home,FloatVar,int,FloatVar);
+void nroot(Home,IntVar,int,IntVar,IntConLevel=ICL_DEF);
+void nvalues(Home,const BoolVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void nvalues(Home,const BoolVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void nvalues(Home,const IntVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void nvalues(Home,const IntVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntArgs&,const IntVarArgs&,IntVar,IntVar,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntArgs&,const IntVarArgs&,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntArgs&,int,const IntVarArgs&,IntVar,IntVar,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntArgs&,int,const IntVarArgs&,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntVarArgs&,IntVar,IntVar,IntConLevel=ICL_DEF);
+void path(Home,int,const IntVarArgs&,IntVar,IntVar,IntConLevel=ICL_DEF);
+void pow(Home,FloatVar,int,FloatVar);
+void pow(Home,IntVar,int,IntVar,IntConLevel=ICL_DEF);
+void precede(Home,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void precede(Home,const IntVarArgs&,int,int,IntConLevel=ICL_DEF);
+void precede(Home,const SetVarArgs&,const IntArgs&);
+void precede(Home,const SetVarArgs&,int,int);
+void rel(Home,BoolOpType,const BoolVarArgs&,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,BoolOpType,const BoolVarArgs&,int,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,BoolOpType,BoolVar,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,BoolOpType,BoolVar,int,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,IntRelType,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,IntRelType,BoolVar,Reify,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,IntRelType,int,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,IntRelType,int,Reify,IntConLevel=ICL_DEF);
+void rel(Home,const BoolVarArgs&,IntRelType,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,const BoolVarArgs&,IntRelType,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void rel(Home,const BoolVarArgs&,IntRelType,IntConLevel=ICL_DEF);
+void rel(Home,const BoolVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void rel(Home,const FloatVarArgs&,FloatRelType,FloatVal);
+void rel(Home,const FloatVarArgs&,FloatRelType,FloatVar);
+void rel(Home,const IntSet&,SetOpType,SetVar,SetRelType,const IntSet&);
+void rel(Home,const IntSet&,SetOpType,SetVar,SetRelType,SetVar);
+void rel(Home,const IntVarArgs&,IntRelType,const IntVarArgs&,IntConLevel=ICL_DEF);
+void rel(Home,const IntVarArgs&,IntRelType,IntConLevel=ICL_DEF);
+void rel(Home,const IntVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void rel(Home,const IntVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void rel(Home,FloatVar,FloatRelType,FloatVal);
+void rel(Home,FloatVar,FloatRelType,FloatVal,Reify);
+void rel(Home,FloatVar,FloatRelType,FloatVar);
+void rel(Home,FloatVar,FloatRelType,FloatVar,Reify);
+void rel(Home,IntVar,IntRelType,int,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,int,Reify,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,IntVar,Reify,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,SetVar);
+void rel(Home,IntVar,SetRelType,SetVar);
+void rel(Home,IntVar,SetRelType,SetVar,Reify);
+void rel(Home,SetOpType,const IntVarArgs&,const IntSet&,SetVar);
+void rel(Home,SetOpType,const IntVarArgs&,SetVar);
+void rel(Home,SetOpType,const SetVarArgs&,const IntSet&,SetVar);
+void rel(Home,SetOpType,const SetVarArgs&,SetVar);
+void rel(Home,SetVar,IntRelType,IntVar);
+void rel(Home,SetVar,SetOpType,const IntSet&,SetRelType,const IntSet&);
+void rel(Home,SetVar,SetOpType,const IntSet&,SetRelType,SetVar);
+void rel(Home,SetVar,SetOpType,SetVar,SetRelType,const IntSet&);
+void rel(Home,SetVar,SetOpType,SetVar,SetRelType,SetVar);
+void rel(Home,SetVar,SetRelType,IntVar);
+void rel(Home,SetVar,SetRelType,IntVar,Reify);
+void rel(Home,SetVar,SetRelType,SetVar);
+void rel(Home,SetVar,SetRelType,SetVar,Reify);
+void sequence(Home,const BoolVarArgs&,const IntSet&,int,int,int,IntConLevel=ICL_DEF);
+void sequence(Home,const IntVarArgs&,const IntSet&,int,int,int,IntConLevel=ICL_DEF);
+void sequence(Home,const SetVarArgs&);
+void sequence(Home,const SetVarArgs&,SetVar);
+void sorted(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void sorted(Home,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void sqr(Home,FloatVar,FloatVar);
+void sqr(Home,IntVar,IntVar,IntConLevel=ICL_DEF);
+void sqrt(Home,FloatVar,FloatVar);
+void sqrt(Home,IntVar,IntVar,IntConLevel=ICL_DEF);
+void unary(Home,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void unshare(Home,BoolVarArgs&,IntConLevel=ICL_DEF);
+void unshare(Home,IntVarArgs&,IntConLevel=ICL_DEF);
+void weights(Home,IntSharedArray,IntSharedArray,SetVar,IntVar);
diff --git a/library/gecode/photo.yap b/library/gecode/examples/photo.yap
similarity index 100%
rename from library/gecode/photo.yap
rename to library/gecode/examples/photo.yap
diff --git a/library/gecode/queens.yap b/library/gecode/examples/queens.yap
similarity index 100%
rename from library/gecode/queens.yap
rename to library/gecode/examples/queens.yap
diff --git a/library/gecode/send_more_money.yap b/library/gecode/examples/send_more_money.yap
similarity index 100%
rename from library/gecode/send_more_money.yap
rename to library/gecode/examples/send_more_money.yap
diff --git a/library/gecode/send_most_money.yap b/library/gecode/examples/send_most_money.yap
similarity index 100%
rename from library/gecode/send_most_money.yap
rename to library/gecode/examples/send_most_money.yap
diff --git a/library/gecode/gecode3_yap.cc b/library/gecode/gecode3_yap.cc
index 02283d31a..9cd3c67a8 100644
--- a/library/gecode/gecode3_yap.cc
+++ b/library/gecode/gecode3_yap.cc
@@ -16,7 +16,7 @@
// along with this program. If not, see .
//=============================================================================
-#include "gecode-common.icc"
+#include "gecode3-common.icc"
#include
using namespace std;
using namespace generic_gecode;
diff --git a/library/gecode/gecode4_yap.cc b/library/gecode/gecode4_yap.cc
index f7aaffc19..077145c3e 100644
--- a/library/gecode/gecode4_yap.cc
+++ b/library/gecode/gecode4_yap.cc
@@ -168,6 +168,18 @@ extern "C"
return * (SetAssign*) YAP_OpaqueObjectFromTerm(t);
}
+ static inline TupleSet&
+ gecode_TupleSet_from_term(YAP_Term t)
+ {
+ return *(TupleSet *) YAP_OpaqueObjectFromTerm(t);
+ }
+
+ static inline DFA&
+ gecode_DFA_from_term(YAP_Term t)
+ {
+ return *(DFA *) YAP_OpaqueObjectFromTerm(t);
+ }
+
static inline FloatNum
gecode_FloatNum_from_term(YAP_Term t)
{
@@ -1569,6 +1581,111 @@ extern "C"
return YAP_Unify(YAP_ARG4, term);
}
+ static YAP_opaque_tag_t gecode_tupleset_tag;
+ static YAP_opaque_handler_t gecode_tupleset_handler;
+
+ static int gecode_tupleset_fail_handler(void* p)
+ {
+ return TRUE;
+ }
+
+ static int
+ gecode_tupleset_write_handler
+ (void *stream_, YAP_opaque_tag_t type, void *p, int flags)
+ {
+ IOSTREAM* stream = (IOSTREAM*) stream_;
+ Sfprintf(stream,"", p);
+ return TRUE;
+ }
+
+ static int gecode_new_tupleset(void)
+ {
+ YAP_Term term =
+ YAP_NewOpaqueObject(gecode_tupleset_tag, sizeof(TupleSet));
+ TupleSet *ts = new (YAP_OpaqueObjectFromTerm(term)) TupleSet;
+ YAP_Term t = YAP_ARG1;
+ while (YAP_IsPairTerm( t ) ) {
+ YAP_Term l = YAP_HeadOfTerm(t);
+ int n = gecode_list_length(l);
+ int i = 0;
+ IntArgs is(n);
+ while (YAP_IsPairTerm( l ) ) {
+ YAP_Term ll = YAP_HeadOfTerm(l);
+ if (!YAP_IsIntTerm(ll)) {
+ cerr << "non-integer on tuple set" << endl; exit(1);
+ }
+ is[i++] = YAP_IntOfTerm(ll);
+ l = YAP_TailOfTerm(l);
+ }
+ ts->add(is);
+ if (l != YAP_TermNil()) {
+ cerr << "non-list on tuple set" << endl; exit(1);
+ }
+ t = YAP_TailOfTerm(t);
+ }
+ if (t != YAP_TermNil()) {
+ cerr << "non-list on tuple set" << endl; exit(1);
+ }
+ ts->finalize();
+ return YAP_Unify(YAP_ARG2, term);
+ }
+
+ static YAP_opaque_tag_t gecode_dfa_tag;
+ static YAP_opaque_handler_t gecode_dfa_handler;
+
+ static int gecode_dfa_fail_handler(void* p)
+ {
+ return TRUE;
+ }
+
+ static int
+ gecode_dfa_write_handler
+ (void *stream_, YAP_opaque_tag_t type, void *p, int flags)
+ {
+ IOSTREAM* stream = (IOSTREAM*) stream_;
+ Sfprintf(stream,"", p);
+ return TRUE;
+ }
+
+ static int gecode_new_dfa(void)
+ {
+ YAP_Term term =
+ YAP_NewOpaqueObject(gecode_dfa_tag, sizeof(DFA));
+ // DFA ts = new (YAP_OpaqueObjectFromTerm(term)) DFA;
+ YAP_Term t2 = YAP_ARG2;
+ int s0 = YAP_IntOfTerm(t2);
+ YAP_Term t3 = YAP_ARG3;
+ int n = gecode_list_length(t3), i=0;
+ DFA::Transition t[n];
+ while (YAP_IsPairTerm( t3 ) ) {
+ YAP_Term tt = YAP_HeadOfTerm(t3);
+ int is, sy, os;
+ is = YAP_IntOfTerm(YAP_ArgOfTerm(1,tt));
+ sy = YAP_IntOfTerm(YAP_ArgOfTerm(2,tt));
+ os = YAP_IntOfTerm(YAP_ArgOfTerm(3,tt));
+ t[i++] = DFA::Transition(is, sy, os);
+ t3 = YAP_TailOfTerm(t3);
+ }
+ if (t3 != YAP_TermNil()) {
+ cerr << "non-list on DFA" << endl; exit(1);
+ }
+ YAP_Term t4 = YAP_ARG4;
+ n = gecode_list_length(t4)+1;
+ i=0;
+ int s[n];
+ s[n-1] = -1;
+ while (YAP_IsPairTerm( t4 ) ) {
+ YAP_Term tt = YAP_HeadOfTerm(t4);
+ s[i++] = YAP_IntOfTerm(tt);
+ t4 = YAP_TailOfTerm(t4);
+ }
+ if (t4 != YAP_TermNil()) {
+ cerr << "non-list on DFA" << endl; exit(1);
+ }
+ new (YAP_OpaqueObjectFromTerm(term)) DFA(s0, t, s);
+ return YAP_Unify(YAP_ARG1, term);
+ }
+
void gecode_init(void)
{
{ YAP_Atom X= YAP_LookupAtom("true");
@@ -1758,6 +1875,16 @@ extern "C"
gecode_reify_handler.write_handler = gecode_reify_write_handler;
gecode_reify_tag = YAP_NewOpaqueType(&gecode_reify_handler);
YAP_UserCPredicate("gecode_new_reify", gecode_new_reify, 4);
+ // Opaque TupleSet
+ gecode_tupleset_handler.fail_handler = gecode_tupleset_fail_handler;
+ gecode_tupleset_handler.write_handler = gecode_tupleset_write_handler;
+ gecode_tupleset_tag = YAP_NewOpaqueType(&gecode_tupleset_handler);
+ YAP_UserCPredicate("gecode_new_tupleset", gecode_new_tupleset, 2);
+ // Opaque DFA
+ gecode_dfa_handler.fail_handler = gecode_dfa_fail_handler;
+ gecode_dfa_handler.write_handler = gecode_dfa_write_handler;
+ gecode_dfa_tag = YAP_NewOpaqueType(&gecode_dfa_handler);
+ YAP_UserCPredicate("gecode_new_dfa", gecode_new_dfa, 4);
#ifdef DISJUNCTOR
// opaque disjunctors and clauses
gecode_disjunctor_handler.write_handler = gecode_disjunctor_write_handler;
diff --git a/library/gecode/gecode4_yap_hand_written.yap b/library/gecode/gecode4_yap_hand_written.yap
index 4fd8d7d5d..c4f194976 100644
--- a/library/gecode/gecode4_yap_hand_written.yap
+++ b/library/gecode/gecode4_yap_hand_written.yap
@@ -118,6 +118,14 @@ is_IntSetArgs_([H|T],[H2|T2]) :- is_IntSet(H,H2), is_IntSetArgs(T,T2).
is_IntSetArgs(X,Y) :- nonvar(X), is_IntSetArgs_(X,Y).
is_IntSetArgs(X) :- \+ \+ is_IntSetArgs(X,_).
+is_TupleSet_('TupleSet'(TS),TS).
+is_TupleSet(X,Y) :- nonvar(X), is_TupleSet_(X,Y).
+is_TupleSet(X) :- is_TupleSet(X,_).
+
+is_DFA_('DFA'(TS),TS).
+is_DFA(X,Y) :- nonvar(X), is_DFA_(X,Y).
+is_DFA(X) :- is_DFA(X,_).
+
new_intset(X,I,J) :- intset(X,I,J).
new_intset(X,L) :- intset(X,L).
@@ -150,6 +158,10 @@ assert_is_Space(X,Y) :-
is_Space(X,Y) -> true ; throw(gecode_error(expected(space))).
assert_is_IntSet(X,Y) :-
is_IntSet(X,Y) -> true ; throw(gecode_error(expected(intset))).
+assert_is_TupleSet(X,Y) :-
+ is_TupleSet(X,Y) -> true ; throw(gecode_error(expected(tupleset))).
+assert_is_DFA(X,Y) :-
+ is_DFA(X,Y) -> true ; throw(gecode_error(expected(dfa))).
assert_is_IntVar(X,Y) :-
is_IntVar(X,Y) -> true ; throw(gecode_error(expected(intvar))).
assert_is_BoolVar(X,Y) :-
@@ -540,6 +552,15 @@ new_setvar(SVar,Space,X1,X2) :-
gecode_new_setvar_12(Idx,Space_,X1_,X2_),
SVar='SetVar'(Idx,-1).
+new_tupleset( TupleSet, List ) :-
+ gecode_new_tupleset(List, TupleSet_),
+ TupleSet = 'TupleSet'(TupleSet_).
+
+new_dfa( DFA, S0, List, Finals ) :-
+ gecode_new_dfa(DFA_, S0, List, Finals),
+ DFA = 'DFA'(DFA_).
+
+
minimize(Space,IVar) :-
assert_is_Space(Space,Space_),
assert_is_IntVar(IVar,IVar_),
@@ -926,6 +947,8 @@ keep_list_(_, X) :-
(X := setvars(Space,N,X1,X2,X3,X4)) :- !, new_setvars_(X,Space,N,X1,X2,X3,X4).
(X := setvars(Space,N,X1,X2,X3)) :- !, new_setvars_(X,Space,N,X1,X2,X3).
(X := setvars(Space,N,X1,X2)) :- !, new_setvars_(X,Space,N,X1,X2).
+(X := tupleset(Set)) :- !, new_tupleset(X, Set).
+(X := dfa(S0, Transitions, Finals)) :- !, new_dfa(X, S0, Transitions, Finals).
(X := min(Space,Var)) :- !, get_min(X,Space,Var).
(X := max(Space,Var)) :- !, get_max(X,Space,Var).
@@ -1013,7 +1036,8 @@ keep_list_(_, X) :-
(Space += element(X1,X2,X3,X4,X5)) :- !, element(Space,X1,X2,X3,X4,X5).
(Space += element(X1,X2,X3,X4,X5,X6)) :- !, element(Space,X1,X2,X3,X4,X5,X6).
(Space += element(X1,X2,X3,X4,X5,X6,X7)) :- !, element(Space,X1,X2,X3,X4,X5,X6,X7).
-(Space += linear(X1,X2,X3)) :- !, linear(Space,X1,X2,X3).
+(Space += extensional(X1,X2)) :- !, extensional(Space,X1,X2).
+(Space += extensional(X1,X2,X3)) :- !, extensional(Space,X1,X2,X3).
(Space += linear(X1,X2,X3,X4)) :- !, linear(Space,X1,X2,X3,X4).
(Space += linear(X1,X2,X3,X4,X5)) :- !, linear(Space,X1,X2,X3,X4,X5).
(Space += linear(X1,X2,X3,X4,X5,X6)) :- !, linear(Space,X1,X2,X3,X4,X5,X6).
diff --git a/misc/ATOMS b/misc/ATOMS
index 0e198499d..eb5bed1b3 100644
--- a/misc/ATOMS
+++ b/misc/ATOMS
@@ -387,6 +387,8 @@ F Dot6 Dot 6
F Dot7 Dot 7
F Dot8 Dot 8
F Dot9 Dot 9
+F EmptySquareBrackets EmptySquareBrackets 2
+F EmptyCurlyBrackets EmptyCurlyBrackets 2
F Eq Eq 2
F Error Error 2
F EvaluationError EvaluationError 1
diff --git a/pl/consult.yap b/pl/consult.yap
index 71e3bb919..4731c3d8c 100755
--- a/pl/consult.yap
+++ b/pl/consult.yap
@@ -37,6 +37,8 @@ load_files(Files,Opts) :-
'$process_lf_opts'(Opts,Silent,InfLevel,Expand,Changed,CompilationMode,Imports,Stream,Encoding,SkipUnixComments,CompMode,Reconsult,Files,Call),
'$check_use_module'(Call,UseModule),
'$current_module'(M0),
+ % make sure we can run consult
+ '$init_system',
'$lf'(Files,M0,Call,InfLevel,Expand,Changed,CompilationMode,Imports,Stream,Encoding,SkipUnixComments,CompMode,Reconsult,UseModule),
'$close_lf'(Silent).