diff --git a/C/blobs.c b/C/blobs.c index 449a9e819..0a9f541ac 100644 --- a/C/blobs.c +++ b/C/blobs.c @@ -46,7 +46,14 @@ char * Yap_blob_to_string(AtomEntry *ref, const char *s0, size_t sz) fclose(f); // return the final result. return s; } else { +#if __APPLE__ size_t sz0 = strlcpy( s, (char *)RepAtom( AtomSWIStream )->StrOfAE, sz); +#else + size_t sz0; + char *f = (char *)memcpy(s, (char *)RepAtom( AtomSWIStream )->StrOfAE, sz); + f[0]='\0'; + sz0 = f-s; +#endif s = s+sz0; sz -= sz0; #if defined(__linux__) || defined(__APPLE__) diff --git a/C/load_dl.c b/C/load_dl.c index f533bef4c..7f5c1d711 100755 --- a/C/load_dl.c +++ b/C/load_dl.c @@ -26,6 +26,7 @@ char * findExecutable(const char *av0, char *buffer); #include +#include #include #include #include diff --git a/C/save.c b/C/save.c index 6ac07c972..94008aaed 100755 --- a/C/save.c +++ b/C/save.c @@ -32,6 +32,7 @@ static char SccsId[] = "@(#)save.c 1.3 3/15/90"; #include "dlmalloc.h" #endif #include "yapio.h" +#include "YapText.h" #include "sshift.h" #include "Foreign.h" #if HAVE_STRING_H diff --git a/C/scanner.c b/C/scanner.c index 4feef50a7..4812cea57 100755 --- a/C/scanner.c +++ b/C/scanner.c @@ -454,7 +454,7 @@ static void Yap_setCurrentSourceLocation(struct stream_desc *s) { } /* token table with some help from Richard O'Keefe's PD scanner */ -static char chtype0[NUMBER_OF_CHARS + 1] = { +char_kind_t Yap_chtype0[NUMBER_OF_CHARS + 1] = { EF, /* nul soh stx etx eot enq ack bel bs ht nl vt np cr so si */ @@ -547,23 +547,6 @@ typedef struct scanner_internals { size_t CommentsBuffLim; } scanner_internals; -char *Yap_chtype = chtype0 + 1; - -int Yap_wide_chtype(Int ch) { -#if HAVE_WCTYPE_H - if (iswalnum(ch)) { - if (iswlower(ch)) - return LC; - if (iswdigit(ch)) - return NU; - return UC; - } - if (iswpunct(ch)) - return SY; -#endif - return BS; -} - // standard get char, uses conversion table // and converts to wide #define getchr(inp) inp->stream_wgetc_for_read(inp - GLOBAL_Stream) diff --git a/C/udi.c b/C/udi.c index 0b726ac9a..46d9cbd5d 100644 --- a/C/udi.c +++ b/C/udi.c @@ -236,115 +236,9 @@ Yap_udi_search(PredEntry *p) Yap_ClauseListDestroy(c.cl); return Yap_FAILCODE(); } - } else {//intersection needed using Judy1 -#ifdef USE_JUDY - /*TODO: do more tests to this algorithm*/ - int i; - Pvoid_t tmp = (Pvoid_t) NULL; - Pvoid_t result = (Pvoid_t) NULL; - Word_t count = 0L; - Word_t idx_r = 0L; - Word_t idx_tmp = 0L; - int rc = 0; - yamop **x; - - /* - * I will start with the simplest approach - * for each index create a set and intersect it with the - * next - * - * In the future it could pay to sort according to index type - * to improve intersection part - */ - for (i = 0; i < utarray_len(info->args) ; i++) { - parg = (UdiPArg) utarray_eltptr(info->args,i); - r = parg->control->search(parg->idxstr, parg->arg, j1_callback, &tmp); - if (r == -1) /*this arg does not prune search*/ - continue; - rc ++; - J1C(count, result, 0, -1); - if (r == 0) /* this arg gave 0 results -> FAIL*/ - { - if (count > 0) // clear previous result if they exists - J1FA(count, result); - return Yap_FAILCODE(); - } - - if (count == 0) // first result_set - { - result = tmp; - tmp = (Pvoid_t) NULL; - } - else /*intersection*/ - { - idx_tmp = 0L; - idx_r = 0L; - J1F(count, result, idx_r); //succeeds one time at least - assert(count > 0); - J1F(count, tmp, idx_tmp); //succeeds one time at least - assert(count > 0); - while (count) - { - while (idx_r < idx_tmp) - { - J1U(count, result, idx_r); //does not belong - J1N(count, result, idx_r); //next - if (! count) break; //end result set - } - if(idx_r == idx_tmp) - { - J1N(count, result, idx_r); //next - if (! count) break; //end result set - J1N(count, tmp, idx_tmp); //next tmp - //if (! count) break; //end tmp set will break while - } - else // (idx_r > idx_tmp) - { - idx_tmp = idx_r; // fast forward - J1F(count, tmp, idx_tmp); // first starting in idx_r - //if (! count) break; //end tmp set will break while - } - } - J1F(count, result, idx_r); // first starting in idx_r - //clear up the rest - while (idx_r > idx_tmp && count) //result has more setted values - { - J1U(count, result, idx_r); //does not belong - J1N(count, result, idx_r); //next - } - J1FA(count, tmp); //free tmp - } - } - if (rc == 0) /*no search performed*/ - return NULL; - - J1C(count, result, 0, -1); - if (count == 0) { /*result set empty -> FAIL */ - J1FA(count, result); - return Yap_FAILCODE(); - } - - /*convert Juddy1 to clauselist*/ - Yap_ClauseListInit(&clauselist); - idx_r = 0L; - J1F(count, result, idx_r); - while (count) - { - x = (yamop **) utarray_eltptr(info->clauselist, idx_r - 1); - Yap_ClauseListExtend( - &clauselist, - *x, - info->p); - J1N(count, result, idx_r); - } - J1FA(count,result); - fprintf(stderr,"J1 used space %ld bytes for %d clausules\n", - count, Yap_ClauseListCount(&clauselist)); - Yap_ClauseListClose(&clauselist); -#else - fprintf(stderr,"Without libJudy only one argument indexed is allowed." - "Falling back to Yap Indexing\n"); - return NULL; //NO Judy Available +#if 0 + } else {//intersection needed using Judy + Yap_udi_join( &clauselist, parg, info ); #endif } diff --git a/CMakeLists.txt b/CMakeLists.txt index 19bce7465..e3c4b3a9d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -6,7 +6,7 @@ project(YAP) -cmake_minimum_required(VERSION 3.0) +cmake_minimum_required(VERSION 2.8XSXCG) # where we have most scripts # set path to additional CMake modules set(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake ${CMAKE_MODULE_PATH}) @@ -178,7 +178,6 @@ ENDIF("${isSystemDir}" STREQUAL "-1") # -set ( YAP_MALLOC_T void *) set ( MIN_STACKSPACE 1024*SIZEOF_INT_P ) set ( MIN_HEAPSPACE 2*1024*SIZEOF_INT_P ) set ( MIN_TRAILSPACE 512*SIZEOF_INT_P ) @@ -314,6 +313,8 @@ endif (YAP_CALL_TRACER) #set( CMAKE_REQUIRED_LIBRARIES ${READLINE_LIBS} ${CMAKE_REQUIRED_LIBRARIES} ) #target_link_libraries(libYap ${READLINE_LIBS}) +option (YAPOR "or-p" OFF) + option (YAP_THREADS "support system threads" OFF) macro_optional_find_package (Threads OFF) @@ -458,15 +459,23 @@ option (WITH_YAP_STATIC #TODO: option (WITH_YAP_MALLOC - "use malloc to allocate memory" ON) -if (YAP_MALLOC) + "use malloc to allocate memory" OFF) +# modern systems do this. +set ( MALLOC_T "void *" ) +if (YAPOR) + set ( USE_DL_MALLOC 1 ) + set ( USE_SYSTEM_MALLOC 0 ) +else() # use default allocator set ( USE_SYSTEM_MALLOC 1 ) + set ( USE_DL_MALLOC 0 ) + set ( USE_SYSTEM_MMAP 0 ) + set ( USE_SYSTEM_SHM 0 ) endif() -option(YAP_CONDOR +option(WITH_YAP_CONDOR "allow YAP to be used from condor" OFF) - if (YAP_MALLOC) + if (WITH_YAP_MALLOC) # use default allocator set ( YAP_STATIC ON ) set ( YAP_DLL OFF ) @@ -496,6 +505,7 @@ target_link_libraries(libYap ${GMP_LIBRARIES} ${READLINE_LIBS} ${CMAKE_DL_LIBS} + m ) add_executable (yap-bin ${CONSOLE_SOURCES}) diff --git a/H/Yap.h b/H/Yap.h index 2cc391574..996722ee2 100755 --- a/H/Yap.h +++ b/H/Yap.h @@ -849,27 +849,6 @@ LOG0(const char *f, int l, const char *fmt, ...) // YAP lexicon -/* Character types for tokenizer and write.c */ - -typedef enum char_kind_t { - BG = 0, /* initial state */ - UC = 1, /* Upper case */ - UL = 2, /* Underline */ - LC = 3, /* Lower case */ - NU = 4, /* digit */ - QT = 5, /* single quote */ - DC = 6, /* double quote */ - SY = 7, /* Symbol character */ - SL = 8, /* Solo character */ - BK = 9, /* Brackets & friends */ - BS = 10, /* Blank */ - EF = 11, /* End of File marker */ - CC = 12 /* comment,char % */ -} charkind_t; - -#ifndef __ANDROID__ -#define __android_log_print( ... ) -#endif #include "GitSHA1.h" diff --git a/H/YapText.h b/H/YapText.h index 2bf898114..1d9337b2b 100644 --- a/H/YapText.h +++ b/H/YapText.h @@ -31,95 +31,230 @@ #include "Yap.h" #include "utf8proc.h" -inline static utf8proc_ssize_t get_utf8(utf8proc_uint8_t * ptr, utf8proc_int32_t *valp) { return utf8proc_iterate( ptr, -1, valp ); } +/* Character types for tokenizer and write.c */ -inline static utf8proc_ssize_t put_utf8(utf8proc_uint8_t * ptr, utf8proc_int32_t val) { return utf8proc_encode_char( val, ptr ); } +/****************** character definition table **************************/ -inline static utf8proc_uint8_t *skip_utf8( utf8proc_uint8_t * pt, utf8proc_ssize_t n) { +#define NUMBER_OF_CHARS 256 +extern char *Yap_chtype; + +typedef enum { + BG = 0, /* initial state */ + UC = 1, /* Upper case */ + UL = 2, /* Underline */ + LC = 3, /* Lower case */ + NU = 4, /* digit */ + QT = 5, /* single quote */ + DC = 6, /* double quote */ + SY = 7, /* Symbol character */ + SL = 8, /* Solo character */ + BK = 9, /* Brackets & friends */ + BS = 10, /* Blank */ + EF = 11, /* End of File marker */ + CC = 12 /* comment,char % */ +} char_kind_t; + +extern char_kind_t Yap_chtype0[]; + +#define Yap_chtype (Yap_chtype0+1) + +char_kind_t Yap_wide_chtype(int ch); + +INLINE_ONLY EXTERN inline char_kind_t Yap_wide_chtype(int ch) { + if (ch < 256) + return Yap_chtype[ch]; + switch (utf8proc_category(ch)) { + case UTF8PROC_CATEGORY_CN: /**< Other, not assigned */ + return BG; + case UTF8PROC_CATEGORY_LU: /**< Letter, uppercase */ + return UC; + case UTF8PROC_CATEGORY_LL: /**< Letter, lowercase */ + return LC; + case UTF8PROC_CATEGORY_LT: /**< Letter, titlecase */ + return UC; + case UTF8PROC_CATEGORY_LM: /**< Letter, modifier */ + return LC; + case UTF8PROC_CATEGORY_LO: /**< Letter, other */ + return LC; + case UTF8PROC_CATEGORY_MN: /**< Mark, nonspacing */ + return BG; + case UTF8PROC_CATEGORY_MC: /**< Mark, spacing combining */ + return BK; + case UTF8PROC_CATEGORY_ME: /**< Mark, enclosing */ + return BK; + case UTF8PROC_CATEGORY_ND: /**< Number, decimal digit */ + return NU; + case UTF8PROC_CATEGORY_NL: /**< Number, letter */ + return NU; + case UTF8PROC_CATEGORY_NO: /**< Number, other */ + return NU; + case UTF8PROC_CATEGORY_PC: /**< Punctuation, connector */ + return SL; + case UTF8PROC_CATEGORY_PD: /**< Punctuation, dash */ + return SY; + case UTF8PROC_CATEGORY_PS: /**< Punctuation, open */ + return BK; + case UTF8PROC_CATEGORY_PE: /**< Punctuation, close */ + return BK; + case UTF8PROC_CATEGORY_PI: /**< Punctuation, initial quote */ + return QT; + case UTF8PROC_CATEGORY_PF: /**< Punctuation, final quote */ + return QT; + case UTF8PROC_CATEGORY_PO: /**< Punctuation, other */ + return SL; + case UTF8PROC_CATEGORY_SM: /**< Symbol, math */ + return SY; + case UTF8PROC_CATEGORY_SC: /**< Symbol, currency */ + return SY; + case UTF8PROC_CATEGORY_SK: /**< Symbol, modifier + + unsure in YAP, let's assume a,c us treated as aç + */ + return LC; + case UTF8PROC_CATEGORY_SO: /**< Symbol, other */ + return SL; + case UTF8PROC_CATEGORY_ZS: /**< Separator, space */ + return BS; + case UTF8PROC_CATEGORY_ZL: /**< Separator, line */ + return BS; + case UTF8PROC_CATEGORY_ZP: /**< Separator, paragraph */ + return BS; + case UTF8PROC_CATEGORY_CC: /**< Other, control */ + return BG; + case UTF8PROC_CATEGORY_CF: /**< Other, format */ + return BG; + case UTF8PROC_CATEGORY_CS: /**< Other, surrogate */ + return BG; + case UTF8PROC_CATEGORY_CO: /**< Other, private use */ + return BG; + } + return BS; +} + +INLINE_ONLY EXTERN inline char_kind_t chtype(Int ch) { + if (ch < NUMBER_OF_CHARS) + return Yap_chtype[ch]; + return Yap_wide_chtype(ch); +} + +#ifndef __ANDROID__ +#define __android_log_print(...) +#endif + +inline static utf8proc_ssize_t get_utf8(utf8proc_uint8_t *ptr, + utf8proc_int32_t *valp) { + return utf8proc_iterate(ptr, -1, valp); +} + +inline static utf8proc_ssize_t put_utf8(utf8proc_uint8_t *ptr, + utf8proc_int32_t val) { + return utf8proc_encode_char(val, ptr); +} + +inline static utf8proc_uint8_t *skip_utf8(utf8proc_uint8_t *pt, + utf8proc_ssize_t n) { utf8proc_ssize_t i; utf8proc_int32_t b; - for (i=0;i< n; i++) { - utf8proc_ssize_t l = utf8proc_iterate( pt, -1, &b ); - if (b==0) return pt; + for (i = 0; i < n; i++) { + utf8proc_ssize_t l = utf8proc_iterate(pt, -1, &b); + if (b == 0) + return pt; pt += l; } return pt; } -inline static utf8proc_ssize_t strlen_utf8(const utf8proc_uint8_t * pt) { - utf8proc_ssize_t rc =0; +inline static utf8proc_ssize_t strlen_utf8(const utf8proc_uint8_t *pt) { + utf8proc_ssize_t rc = 0; utf8proc_int32_t b; while (true) { - utf8proc_ssize_t l = utf8proc_iterate( pt, -1, &b ); - if (b==0) return rc; + utf8proc_ssize_t l = utf8proc_iterate(pt, -1, &b); + if (b == 0) + return rc; pt += l; rc += l; } return rc; } -inline static utf8proc_ssize_t strlen_latin_utf8(const unsigned char * pt) { - utf8proc_ssize_t rc =0; +inline static utf8proc_ssize_t strlen_latin_utf8(const unsigned char *pt) { + utf8proc_ssize_t rc = 0; utf8proc_uint8_t b; while (true) { - utf8proc_ssize_t l = utf8proc_encode_char( *pt, &b ); - if (b==0) return rc; + utf8proc_ssize_t l = utf8proc_encode_char(*pt, &b); + if (b == 0) + return rc; pt++; rc += l; } return rc; } -inline static utf8proc_ssize_t strnlen_latin_utf8(const unsigned char * pt, size_t max) { - utf8proc_ssize_t rc =0; +inline static utf8proc_ssize_t strnlen_latin_utf8(const unsigned char *pt, + size_t max) { + utf8proc_ssize_t rc = 0; utf8proc_uint8_t b; while (true) { - utf8proc_ssize_t l = utf8proc_encode_char( *pt, &b ); - if (b==0) return rc; + utf8proc_ssize_t l = utf8proc_encode_char(*pt, &b); + if (b == 0) + return rc; pt++; rc += l; - if (--max == 0) return rc; + if (--max == 0) + return rc; } return rc; } -inline static utf8proc_ssize_t strlen_ucs2_utf8(const wchar_t * pt) { - utf8proc_ssize_t rc =0; +inline static utf8proc_ssize_t strlen_ucs2_utf8(const wchar_t *pt) { + utf8proc_ssize_t rc = 0; utf8proc_uint8_t b; while (true) { - utf8proc_ssize_t l = utf8proc_encode_char( *pt, &b ); - if (b==0) return rc; - pt ++; + utf8proc_ssize_t l = utf8proc_encode_char(*pt, &b); + if (b == 0) + return rc; + pt++; rc += l; } return rc; } -inline static utf8proc_ssize_t strnlen_ucs2_utf8(const wchar_t * pt, size_t max) { - utf8proc_ssize_t rc =0; +inline static utf8proc_ssize_t strnlen_ucs2_utf8(const wchar_t *pt, + size_t max) { + utf8proc_ssize_t rc = 0; utf8proc_uint8_t b; while (true) { - utf8proc_ssize_t l = utf8proc_encode_char( *pt, &b ); - if (b==0) return rc; - pt ++; + utf8proc_ssize_t l = utf8proc_encode_char(*pt, &b); + if (b == 0) + return rc; + pt++; rc += l; - if (--max == 0) return rc; + if (--max == 0) + return rc; } return rc; } -inline static int cmpn_utf8(const utf8proc_uint8_t * pt1, const utf8proc_uint8_t * pt2, utf8proc_ssize_t n) { +inline static int cmpn_utf8(const utf8proc_uint8_t *pt1, + const utf8proc_uint8_t *pt2, utf8proc_ssize_t n) { utf8proc_ssize_t i; utf8proc_int32_t b; - for (i=0;i< n; i++) { - if (pt1[0] != pt2[0]) return pt1[0]- pt2[0]; - utf8proc_ssize_t l = utf8proc_iterate( pt1, -1, &b ); - if (l == 2) { if (pt1[1] != pt2[1]) return pt1[1]- pt2[1]; } - else if (l == 3) { if (pt1[2] != pt2[2]) return pt1[2]- pt2[2]; } - else if (l == 4) { if (pt1[3] != pt2[3]) return pt1[3]- pt2[3]; } + for (i = 0; i < n; i++) { + if (pt1[0] != pt2[0]) + return pt1[0] - pt2[0]; + utf8proc_ssize_t l = utf8proc_iterate(pt1, -1, &b); + if (l == 2) { + if (pt1[1] != pt2[1]) + return pt1[1] - pt2[1]; + } else if (l == 3) { + if (pt1[2] != pt2[2]) + return pt1[2] - pt2[2]; + } else if (l == 4) { + if (pt1[3] != pt2[3]) + return pt1[3] - pt2[3]; + } pt1 += l; pt2 += l; - } return 0; } @@ -129,115 +264,107 @@ const char *Yap_tokRep(TokEntry *tokptr); // standard strings typedef enum { - YAP_STRING_STRING = 0x1, /// target is a string term - YAP_STRING_CODES = 0x2, /// target is a list of integer codes - YAP_STRING_ATOMS = 0x4, /// target is a list of kength-1 atom + YAP_STRING_STRING = 0x1, /// target is a string term + YAP_STRING_CODES = 0x2, /// target is a list of integer codes + YAP_STRING_ATOMS = 0x4, /// target is a list of kength-1 atom YAP_STRING_ATOMS_CODES = 0x6, /// targt is list of atoms or codes - YAP_STRING_CHARS = 0x8, /// target is a buffer, with byte-sized units - YAP_STRING_WCHARS = 0x10, /// target is a buffer of wide chars - YAP_STRING_ATOM = 0x20, /// tarfet is an ayom - YAP_STRING_INT = 0x40, /// target is an integer term - YAP_STRING_FLOAT = 0x80, /// target is a floar term - YAP_STRING_BIG = 0x100, /// target is an big num term - YAP_STRING_DATUM = 0x200, /// associated with previous 3, use actual object if type, not tern - YAP_STRING_LENGTH = 0x400, /// input: length is fixed; output: return integer with length - YAP_STRING_NTH = 0x800, /// input: ignored; output: nth char - YAP_STRING_TERM = 0x1000, // Generic term, if nothing else given - YAP_STRING_DIFF = 0x2000, // difference list - YAP_STRING_NCHARS = 0x4000, // size of input/result - YAP_STRING_TRUNC = 0x8000, // truncate on maximum size of input/result - YAP_STRING_WQ = 0x10000, // output with write_quote - YAP_STRING_WC = 0x20000, // output with write_canonical - YAP_STRING_WITH_BUFFER = 0x40000, // output on existing buffer - YAP_STRING_MALLOC = 0x80000 // output on malloced buffer + YAP_STRING_CHARS = 0x8, /// target is a buffer, with byte-sized units + YAP_STRING_WCHARS = 0x10, /// target is a buffer of wide chars + YAP_STRING_ATOM = 0x20, /// tarfet is an ayom + YAP_STRING_INT = 0x40, /// target is an integer term + YAP_STRING_FLOAT = 0x80, /// target is a floar term + YAP_STRING_BIG = 0x100, /// target is an big num term + YAP_STRING_DATUM = + 0x200, /// associated with previous 3, use actual object if type, not tern + YAP_STRING_LENGTH = + 0x400, /// input: length is fixed; output: return integer with length + YAP_STRING_NTH = 0x800, /// input: ignored; output: nth char + YAP_STRING_TERM = 0x1000, // Generic term, if nothing else given + YAP_STRING_DIFF = 0x2000, // difference list + YAP_STRING_NCHARS = 0x4000, // size of input/result + YAP_STRING_TRUNC = 0x8000, // truncate on maximum size of input/result + YAP_STRING_WQ = 0x10000, // output with write_quote + YAP_STRING_WC = 0x20000, // output with write_canonical + YAP_STRING_WITH_BUFFER = 0x40000, // output on existing buffer + YAP_STRING_MALLOC = 0x80000 // output on malloced buffer } enum_seq_type_t; - - typedef UInt seq_type_t; #define YAP_TYPE_MASK 0x0FFF typedef union { - Float f; - Int i; + Float f; + Int i; MP_INT *b; const char *c0; const wchar_t *w0; char *c; unsigned char *uc; wchar_t *w; - Atom a; + Atom a; size_t l; int d; - Term t;// depends on other flags -} -seq_val_t; + Term t; // depends on other flags +} seq_val_t; typedef struct text_cvt { seq_type_t type; seq_val_t val; - Term mod; // optional - size_t sz; // fixed sz, or -1 - Term dif; // diff-list, usually TermNil - size_t max; // max_size + Term mod; // optional + size_t sz; // fixed sz, or -1 + Term dif; // diff-list, usually TermNil + size_t max; // max_size encoding_t enc; } seq_tv_t; // string construction #ifdef HR -static inline Term -init_tstring( USES_REGS1 ) { +static inline Term init_tstring(USES_REGS1) { Term t = AbsAppl(HR); HR[0] = (CELL)FunctorString; return t; } -static inline unsigned char * -buf_from_tstring( CELL *p ) { +static inline unsigned char *buf_from_tstring(CELL *p) { unsigned char *out = (unsigned char *)(p + 2); return out; } -static inline void -close_tstring( unsigned char *p USES_REGS ) { - CELL *szp = HR+1; - HR = (CELL *)ALIGN_BY_TYPE( p ,CELL); - *szp = (HR - szp)-1; +static inline void close_tstring(unsigned char *p USES_REGS) { + CELL *szp = HR + 1; + HR = (CELL *)ALIGN_BY_TYPE(p, CELL); + *szp = (HR - szp) - 1; *HR++ = EndSpecials; } #endif // string type depends on current module -static inline seq_type_t -mod_to_type( Term mod USES_REGS ) -{ - +static inline seq_type_t mod_to_type(Term mod USES_REGS) { + // see pl-incl.h unsigned int flags = Yap_GetModuleEntry(mod)->flags; if (flags & DBLQ_ATOM) { return YAP_STRING_ATOM; } else if (flags & DBLQ_STRING) { return YAP_STRING_STRING; - } else if (flags & DBLQ_CHARS) { + } else if (flags & DBLQ_CHARS) { return YAP_STRING_ATOMS; } return YAP_STRING_CODES; } // string type depends on current module -static inline seq_type_t -mod_to_bqtype( Term mod USES_REGS ) -{ - +static inline seq_type_t mod_to_bqtype(Term mod USES_REGS) { + // see pl-incl.h unsigned int flags = Yap_GetModuleEntry(mod)->flags; if (flags & BCKQ_ATOM) { return YAP_STRING_ATOM; } else if (flags & BCKQ_STRING) { return YAP_STRING_STRING; - } else if (flags & BCKQ_CHARS) { + } else if (flags & BCKQ_CHARS) { return YAP_STRING_ATOMS; } return YAP_STRING_CODES; @@ -245,44 +372,45 @@ mod_to_bqtype( Term mod USES_REGS ) // the routines -extern void *Yap_readText( void *buf, seq_tv_t *inp, encoding_t *enc, int *minimal, size_t *lengp USES_REGS); -extern int write_Text( void *inp, seq_tv_t *out, encoding_t enc, int minimal, size_t leng USES_REGS); -extern int Yap_CVT_Text( seq_tv_t *inp, seq_tv_t *out USES_REGS); -extern void *Yap_Concat_Text( int n, seq_tv_t inp[], seq_tv_t *out USES_REGS); -extern void *Yap_Splice_Text( int n, size_t cuts[], seq_tv_t *inp, encoding_t encv[], seq_tv_t outv[] USES_REGS); +extern void *Yap_readText(void *buf, seq_tv_t *inp, encoding_t *enc, + int *minimal, size_t *lengp USES_REGS); +extern int write_Text(void *inp, seq_tv_t *out, encoding_t enc, int minimal, + size_t leng USES_REGS); +extern int Yap_CVT_Text(seq_tv_t *inp, seq_tv_t *out USES_REGS); +extern void *Yap_Concat_Text(int n, seq_tv_t inp[], seq_tv_t *out USES_REGS); +extern void *Yap_Splice_Text(int n, size_t cuts[], seq_tv_t *inp, + encoding_t encv[], seq_tv_t outv[] USES_REGS); // user friendly interface -static inline size_t -Yap_AtomicToLength(Term t0 USES_REGS) -{ +static inline size_t Yap_AtomicToLength(Term t0 USES_REGS) { seq_tv_t inp, out; inp.val.t = t0; - inp.type = YAP_STRING_STRING|YAP_STRING_CODES|YAP_STRING_ATOMS|YAP_STRING_ATOM|YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_BIG|YAP_STRING_TERM; + inp.type = YAP_STRING_STRING | YAP_STRING_CODES | YAP_STRING_ATOMS | + YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT | + YAP_STRING_BIG | YAP_STRING_TERM; out.type = YAP_STRING_LENGTH; if (!Yap_CVT_Text(&inp, &out PASS_REGS)) return 0L; return out.val.t; } -static inline Term -Yap_AtomicToListOfAtoms(Term t0 USES_REGS) -{ +static inline Term Yap_AtomicToListOfAtoms(Term t0 USES_REGS) { seq_tv_t inp, out; inp.val.t = t0; - inp.type = YAP_STRING_STRING|YAP_STRING_ATOM|YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_BIG|YAP_STRING_TERM; + inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | + YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; out.type = YAP_STRING_ATOMS; if (!Yap_CVT_Text(&inp, &out PASS_REGS)) return 0L; return out.val.t; } -static inline Term -Yap_AtomicToListOfCodes(Term t0 USES_REGS) -{ +static inline Term Yap_AtomicToListOfCodes(Term t0 USES_REGS) { seq_tv_t inp, out; inp.val.t = t0; - inp.type = YAP_STRING_STRING|YAP_STRING_ATOM|YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_BIG|YAP_STRING_TERM; + inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | + YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; out.val.uc = NULL; out.type = YAP_STRING_CODES; if (!Yap_CVT_Text(&inp, &out PASS_REGS)) @@ -290,12 +418,11 @@ Yap_AtomicToListOfCodes(Term t0 USES_REGS) return out.val.t; } -static inline Atom -Yap_AtomicToAtom(Term t0 USES_REGS) -{ +static inline Atom Yap_AtomicToAtom(Term t0 USES_REGS) { seq_tv_t inp, out; inp.val.t = t0; - inp.type = YAP_STRING_STRING|YAP_STRING_ATOM|YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_BIG|YAP_STRING_TERM; + inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | + YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; out.val.uc = NULL; out.type = YAP_STRING_ATOM; if (!Yap_CVT_Text(&inp, &out PASS_REGS)) @@ -303,9 +430,7 @@ Yap_AtomicToAtom(Term t0 USES_REGS) return out.val.a; } -static inline size_t -Yap_AtomToLength(Term t0 USES_REGS) -{ +static inline size_t Yap_AtomToLength(Term t0 USES_REGS) { seq_tv_t inp, out; inp.val.t = t0; inp.type = YAP_STRING_ATOM; @@ -316,9 +441,7 @@ Yap_AtomToLength(Term t0 USES_REGS) return out.val.l; } -static inline Term -Yap_AtomToListOfAtoms(Term t0 USES_REGS) -{ +static inline Term Yap_AtomToListOfAtoms(Term t0 USES_REGS) { seq_tv_t inp, out; inp.val.t = t0; inp.type = YAP_STRING_ATOM; @@ -329,13 +452,13 @@ Yap_AtomToListOfAtoms(Term t0 USES_REGS) return out.val.t; } -static inline Term -Yap_AtomSWIToListOfAtoms(Term t0 USES_REGS) -{ +static inline Term Yap_AtomSWIToListOfAtoms(Term t0 USES_REGS) { seq_tv_t inp, out; inp.val.t = t0; - inp.type = YAP_STRING_ATOM|YAP_STRING_STRING|YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_BIG|YAP_STRING_ATOMS_CODES|YAP_STRING_TERM; + inp.type = YAP_STRING_ATOM | YAP_STRING_STRING | YAP_STRING_INT | + YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_ATOMS_CODES | + YAP_STRING_TERM; out.val.uc = NULL; out.type = YAP_STRING_ATOMS; @@ -344,10 +467,7 @@ Yap_AtomSWIToListOfAtoms(Term t0 USES_REGS) return out.val.t; } - -static inline Term -Yap_AtomToListOfCodes(Term t0 USES_REGS) -{ +static inline Term Yap_AtomToListOfCodes(Term t0 USES_REGS) { seq_tv_t inp, out; inp.val.t = t0; inp.type = YAP_STRING_ATOM; @@ -358,22 +478,19 @@ Yap_AtomToListOfCodes(Term t0 USES_REGS) return out.val.t; } -static inline Term -Yap_AtomToNumber(Term t0 USES_REGS) -{ +static inline Term Yap_AtomToNumber(Term t0 USES_REGS) { seq_tv_t inp, out; inp.val.t = t0; inp.type = YAP_STRING_ATOM; out.val.uc = NULL; - out.type = YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_BIG|YAP_STRING_TERM; + out.type = + YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; if (!Yap_CVT_Text(&inp, &out PASS_REGS)) return 0L; return out.val.t; } -static inline Term -Yap_AtomToString(Term t0 USES_REGS) -{ +static inline Term Yap_AtomToString(Term t0 USES_REGS) { seq_tv_t inp, out; inp.val.t = t0; @@ -386,13 +503,12 @@ Yap_AtomToString(Term t0 USES_REGS) return out.val.t; } -static inline Term -Yap_AtomSWIToString(Term t0 USES_REGS) -{ +static inline Term Yap_AtomSWIToString(Term t0 USES_REGS) { seq_tv_t inp, out; inp.val.t = t0; - inp.type = YAP_STRING_ATOM|YAP_STRING_STRING|YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_BIG|YAP_STRING_ATOMS_CODES; + inp.type = YAP_STRING_ATOM | YAP_STRING_STRING | YAP_STRING_INT | + YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_ATOMS_CODES; out.val.uc = NULL; out.type = YAP_STRING_STRING; @@ -401,13 +517,12 @@ Yap_AtomSWIToString(Term t0 USES_REGS) return out.val.t; } -static inline Term -Yap_AtomicToString(Term t0 USES_REGS) -{ +static inline Term Yap_AtomicToString(Term t0 USES_REGS) { seq_tv_t inp, out; inp.val.t = t0; - inp.type = YAP_STRING_STRING|YAP_STRING_ATOM|YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_BIG|YAP_STRING_TERM; + inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | + YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; out.val.uc = NULL; out.type = YAP_STRING_STRING; @@ -416,43 +531,39 @@ Yap_AtomicToString(Term t0 USES_REGS) return out.val.t; } -static inline Term -Yap_AtomicToTDQ(Term t0, Term mod USES_REGS) -{ +static inline Term Yap_AtomicToTDQ(Term t0, Term mod USES_REGS) { seq_tv_t inp, out; - + inp.val.t = t0; - inp.type = YAP_STRING_STRING|YAP_STRING_ATOM|YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_BIG|YAP_STRING_TERM; + inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | + YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; out.val.uc = NULL; out.type = mod_to_type(mod PASS_REGS); - + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) return 0L; if (out.type == YAP_STRING_ATOM) - return MkAtomTerm( out.val.a); + return MkAtomTerm(out.val.a); return out.val.t; } -static inline Term -Yap_AtomicToTBQ(Term t0, Term mod USES_REGS) -{ +static inline Term Yap_AtomicToTBQ(Term t0, Term mod USES_REGS) { seq_tv_t inp, out; - + inp.val.t = t0; - inp.type = YAP_STRING_STRING|YAP_STRING_ATOM|YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_BIG|YAP_STRING_TERM; + inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | + YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; out.val.uc = NULL; out.type = mod_to_bqtype(mod PASS_REGS); - + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) return 0L; if (out.type == YAP_STRING_ATOM) - return MkAtomTerm( out.val.a); + return MkAtomTerm(out.val.a); return out.val.t; } -static inline Atom -Yap_CharsToAtom( const char *s, encoding_t enc USES_REGS ) -{ +static inline Atom Yap_CharsToAtom(const char *s, encoding_t enc USES_REGS) { seq_tv_t inp, out; inp.val.c0 = s; @@ -466,9 +577,8 @@ Yap_CharsToAtom( const char *s, encoding_t enc USES_REGS ) return out.val.a; } -static inline Term -Yap_CharsToListOfAtoms( const char *s, encoding_t enc USES_REGS ) -{ +static inline Term Yap_CharsToListOfAtoms(const char *s, + encoding_t enc USES_REGS) { seq_tv_t inp, out; inp.val.c0 = s; @@ -482,9 +592,8 @@ Yap_CharsToListOfAtoms( const char *s, encoding_t enc USES_REGS ) return out.val.t; } -static inline Term -Yap_CharsToListOfCodes( const char *s, encoding_t enc USES_REGS ) -{ +static inline Term Yap_CharsToListOfCodes(const char *s, + encoding_t enc USES_REGS) { seq_tv_t inp, out; inp.val.c0 = s; @@ -498,9 +607,7 @@ Yap_CharsToListOfCodes( const char *s, encoding_t enc USES_REGS ) return out.val.t; } -static inline Term -Yap_UTF8ToListOfCodes( const char *s USES_REGS ) -{ +static inline Term Yap_UTF8ToListOfCodes(const char *s USES_REGS) { seq_tv_t inp, out; inp.val.c0 = s; @@ -513,9 +620,8 @@ Yap_UTF8ToListOfCodes( const char *s USES_REGS ) return out.val.t; } -static inline Term -Yap_CharsToDiffListOfCodes( const char *s, Term tail, encoding_t enc USES_REGS ) -{ +static inline Term Yap_CharsToDiffListOfCodes(const char *s, Term tail, + encoding_t enc USES_REGS) { seq_tv_t inp, out; inp.val.c0 = s; @@ -523,23 +629,22 @@ Yap_CharsToDiffListOfCodes( const char *s, Term tail, encoding_t enc USES_REGS ) inp.enc = enc; inp.type = YAP_STRING_CHARS; out.val.uc = NULL; - out.type = YAP_STRING_DIFF|YAP_STRING_CODES; + out.type = YAP_STRING_DIFF | YAP_STRING_CODES; out.dif = tail; if (!Yap_CVT_Text(&inp, &out PASS_REGS)) return 0L; return out.val.t; } -static inline Term -Yap_UTF8ToDiffListOfCodes( const char *s, Term tail USES_REGS ) -{ +static inline Term Yap_UTF8ToDiffListOfCodes(const char *s, + Term tail USES_REGS) { seq_tv_t inp, out; - + inp.val.c0 = s; inp.sz = 0; inp.type = YAP_STRING_CHARS; inp.enc = ENC_ISO_UTF8; - out.type = YAP_STRING_DIFF|YAP_STRING_CODES; + out.type = YAP_STRING_DIFF | YAP_STRING_CODES; out.val.uc = NULL; out.dif = tail; if (!Yap_CVT_Text(&inp, &out PASS_REGS)) @@ -547,15 +652,14 @@ Yap_UTF8ToDiffListOfCodes( const char *s, Term tail USES_REGS ) return out.val.t; } -static inline Term -Yap_WCharsToDiffListOfCodes( const wchar_t *s, Term tail USES_REGS ) -{ +static inline Term Yap_WCharsToDiffListOfCodes(const wchar_t *s, + Term tail USES_REGS) { seq_tv_t inp, out; - + inp.val.w0 = s; inp.sz = 0; inp.type = YAP_STRING_WCHARS; - out.type = YAP_STRING_DIFF|YAP_STRING_CODES; + out.type = YAP_STRING_DIFF | YAP_STRING_CODES; out.val.uc = NULL; out.dif = tail; if (!Yap_CVT_Text(&inp, &out PASS_REGS)) @@ -563,9 +667,7 @@ Yap_WCharsToDiffListOfCodes( const wchar_t *s, Term tail USES_REGS ) return out.val.t; } -static inline Term -Yap_CharsToString( const char *s, encoding_t enc USES_REGS ) -{ +static inline Term Yap_CharsToString(const char *s, encoding_t enc USES_REGS) { seq_tv_t inp, out; inp.val.c0 = s; @@ -579,9 +681,7 @@ Yap_CharsToString( const char *s, encoding_t enc USES_REGS ) return out.val.t; } -static inline char * -Yap_AtomToUTF8Text( Atom at, const char *s USES_REGS ) -{ +static inline char *Yap_AtomToUTF8Text(Atom at, const char *s USES_REGS) { seq_tv_t inp, out; inp.val.a = at; @@ -601,11 +701,10 @@ Yap_AtomToUTF8Text( Atom at, const char *s USES_REGS ) return out.val.c; } -static inline Term -Yap_CharsToTDQ( const char *s, Term mod, encoding_t enc USES_REGS ) -{ +static inline Term Yap_CharsToTDQ(const char *s, Term mod, + encoding_t enc USES_REGS) { seq_tv_t inp, out; - + inp.val.c0 = s; inp.sz = 0; inp.type = YAP_STRING_CHARS; @@ -616,15 +715,14 @@ Yap_CharsToTDQ( const char *s, Term mod, encoding_t enc USES_REGS ) if (!Yap_CVT_Text(&inp, &out PASS_REGS)) return 0L; if (out.type == YAP_STRING_ATOM) - return MkAtomTerm( out.val.a ); + return MkAtomTerm(out.val.a); return out.val.t; } -static inline Term -Yap_CharsToTBQ( const char *s, Term mod, encoding_t enc USES_REGS ) -{ +static inline Term Yap_CharsToTBQ(const char *s, Term mod, + encoding_t enc USES_REGS) { seq_tv_t inp, out; - + inp.val.c0 = s; inp.sz = 0; inp.type = YAP_STRING_CHARS; @@ -635,13 +733,11 @@ Yap_CharsToTBQ( const char *s, Term mod, encoding_t enc USES_REGS ) if (!Yap_CVT_Text(&inp, &out PASS_REGS)) return 0L; if (out.type == YAP_STRING_ATOM) - return MkAtomTerm( out.val.a ); + return MkAtomTerm(out.val.a); return out.val.t; } -static inline Atom -Yap_ListOfAtomsToAtom(Term t0 USES_REGS) -{ +static inline Atom Yap_ListOfAtomsToAtom(Term t0 USES_REGS) { seq_tv_t inp, out; inp.val.t = t0; inp.type = YAP_STRING_ATOMS; @@ -652,22 +748,19 @@ Yap_ListOfAtomsToAtom(Term t0 USES_REGS) return out.val.a; } -static inline Term -Yap_ListOfAtomsToNumber(Term t0 USES_REGS) -{ +static inline Term Yap_ListOfAtomsToNumber(Term t0 USES_REGS) { seq_tv_t inp, out; inp.val.t = t0; inp.type = YAP_STRING_ATOMS; - out.type = YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_BIG|YAP_STRING_TERM; + out.type = + YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; out.val.uc = NULL; if (!Yap_CVT_Text(&inp, &out PASS_REGS)) return 0L; return out.val.t; } -static inline Term -Yap_ListOfAtomsToString(Term t0 USES_REGS) -{ +static inline Term Yap_ListOfAtomsToString(Term t0 USES_REGS) { seq_tv_t inp, out; inp.val.t = t0; inp.type = YAP_STRING_ATOMS; @@ -678,9 +771,7 @@ Yap_ListOfAtomsToString(Term t0 USES_REGS) return out.val.t; } -static inline Atom -Yap_ListOfCodesToAtom(Term t0 USES_REGS) -{ +static inline Atom Yap_ListOfCodesToAtom(Term t0 USES_REGS) { seq_tv_t inp, out; inp.val.t = t0; inp.type = YAP_STRING_CODES; @@ -691,22 +782,18 @@ Yap_ListOfCodesToAtom(Term t0 USES_REGS) return out.val.a; } -static inline Term -Yap_ListOfCodesToNumber(Term t0 USES_REGS) -{ +static inline Term Yap_ListOfCodesToNumber(Term t0 USES_REGS) { seq_tv_t inp, out; inp.val.t = t0; inp.type = YAP_STRING_CODES; - out.type = YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_BIG; + out.type = YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG; out.val.uc = NULL; if (!Yap_CVT_Text(&inp, &out PASS_REGS)) return 0L; return out.val.t; } -static inline Term -Yap_ListOfCodesToString(Term t0 USES_REGS) -{ +static inline Term Yap_ListOfCodesToString(Term t0 USES_REGS) { seq_tv_t inp, out; inp.val.t = t0; inp.type = YAP_STRING_CODES; @@ -717,12 +804,11 @@ Yap_ListOfCodesToString(Term t0 USES_REGS) return out.val.t; } -static inline Atom -Yap_ListToAtom(Term t0 USES_REGS) -{ +static inline Atom Yap_ListToAtom(Term t0 USES_REGS) { seq_tv_t inp, out; inp.val.t = t0; - inp.type = YAP_STRING_STRING|YAP_STRING_ATOMS_CODES|YAP_STRING_TERM|YAP_STRING_ATOM; + inp.type = YAP_STRING_STRING | YAP_STRING_ATOMS_CODES | YAP_STRING_TERM | + YAP_STRING_ATOM; out.val.uc = NULL; out.type = YAP_STRING_ATOM; if (!Yap_CVT_Text(&inp, &out PASS_REGS)) @@ -730,42 +816,36 @@ Yap_ListToAtom(Term t0 USES_REGS) return out.val.a; } -static inline Term -Yap_ListToAtomic(Term t0 USES_REGS) -{ +static inline Term Yap_ListToAtomic(Term t0 USES_REGS) { seq_tv_t inp, out; inp.val.t = t0; - inp.type = YAP_STRING_STRING|YAP_STRING_ATOMS_CODES|YAP_STRING_TERM; + inp.type = YAP_STRING_STRING | YAP_STRING_ATOMS_CODES | YAP_STRING_TERM; out.val.uc = NULL; - out.type = YAP_STRING_ATOM|YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_BIG|YAP_STRING_TERM; + out.type = YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT | + YAP_STRING_BIG | YAP_STRING_TERM; if (!Yap_CVT_Text(&inp, &out PASS_REGS)) return 0L; return out.val.t; } -static inline Term -Yap_ListToNumber(Term t0 USES_REGS) -{ +static inline Term Yap_ListToNumber(Term t0 USES_REGS) { seq_tv_t inp, out; inp.val.t = t0; - inp.type = YAP_STRING_STRING|YAP_STRING_ATOMS_CODES; + inp.type = YAP_STRING_STRING | YAP_STRING_ATOMS_CODES; out.val.uc = NULL; - out.type = YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_BIG; + out.type = YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG; if (!Yap_CVT_Text(&inp, &out PASS_REGS)) return 0L; return out.val.t; } - -static inline Term -Yap_ListToString(Term t0 USES_REGS) -{ +static inline Term Yap_ListToString(Term t0 USES_REGS) { seq_tv_t inp, out; inp.val.t = t0; - inp.type = YAP_STRING_STRING|YAP_STRING_ATOMS_CODES|YAP_STRING_TERM; + inp.type = YAP_STRING_STRING | YAP_STRING_ATOMS_CODES | YAP_STRING_TERM; out.val.uc = NULL; out.type = YAP_STRING_STRING; @@ -774,14 +854,13 @@ Yap_ListToString(Term t0 USES_REGS) return out.val.t; } - -static inline Term -Yap_ListSWIToString(Term t0 USES_REGS) -{ +static inline Term Yap_ListSWIToString(Term t0 USES_REGS) { seq_tv_t inp, out; inp.val.t = t0; - inp.type = YAP_STRING_STRING|YAP_STRING_ATOM|YAP_STRING_ATOMS_CODES|YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_BIG|YAP_STRING_TERM; + inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_ATOMS_CODES | + YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | + YAP_STRING_TERM; out.val.uc = NULL; out.type = YAP_STRING_STRING; @@ -790,51 +869,45 @@ Yap_ListSWIToString(Term t0 USES_REGS) return out.val.t; } - -static inline Term -YapListToTDQ(Term t0, Term mod USES_REGS) -{ +static inline Term YapListToTDQ(Term t0, Term mod USES_REGS) { seq_tv_t inp, out; - + inp.val.t = t0; - inp.type = YAP_STRING_STRING|YAP_STRING_ATOMS_CODES|YAP_STRING_TERM; + inp.type = YAP_STRING_STRING | YAP_STRING_ATOMS_CODES | YAP_STRING_TERM; out.val.uc = NULL; out.type = mod_to_type(mod PASS_REGS); - + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) return 0L; if (out.type == YAP_STRING_ATOM) { - return MkAtomTerm( out.val.a); + return MkAtomTerm(out.val.a); } return out.val.t; } -static inline Term -YapListToTBQ(Term t0, Term mod USES_REGS) -{ +static inline Term YapListToTBQ(Term t0, Term mod USES_REGS) { seq_tv_t inp, out; - + inp.val.t = t0; - inp.type = YAP_STRING_STRING|YAP_STRING_ATOMS_CODES|YAP_STRING_TERM; + inp.type = YAP_STRING_STRING | YAP_STRING_ATOMS_CODES | YAP_STRING_TERM; out.val.uc = NULL; out.type = mod_to_bqtype(mod PASS_REGS); - + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) return 0L; if (out.type == YAP_STRING_ATOM) { - return MkAtomTerm( out.val.a); + return MkAtomTerm(out.val.a); } return out.val.t; } -static inline Atom -Yap_NCharsToAtom( const char *s, size_t len, encoding_t enc USES_REGS ) -{ +static inline Atom Yap_NCharsToAtom(const char *s, size_t len, + encoding_t enc USES_REGS) { seq_tv_t inp, out; inp.val.c0 = s; inp.sz = len; - inp.type = YAP_STRING_CHARS|YAP_STRING_NCHARS; + inp.type = YAP_STRING_CHARS | YAP_STRING_NCHARS; inp.enc = enc; out.type = YAP_STRING_ATOM; out.val.uc = NULL; @@ -844,30 +917,27 @@ Yap_NCharsToAtom( const char *s, size_t len, encoding_t enc USES_REGS ) return out.val.a; } -static inline Term -Yap_CharsToDiffListOfAtoms( const char *s, encoding_t enc, Term tail USES_REGS ) -{ +static inline Term Yap_CharsToDiffListOfAtoms(const char *s, encoding_t enc, + Term tail USES_REGS) { seq_tv_t inp, out; inp.val.c0 = s; inp.type = YAP_STRING_CHARS; inp.enc = enc; - out.type = YAP_STRING_ATOMS|YAP_STRING_DIFF; + out.type = YAP_STRING_ATOMS | YAP_STRING_DIFF; out.dif = tail; if (!Yap_CVT_Text(&inp, &out PASS_REGS)) return 0L; return out.val.t; } - -static inline Term -Yap_NCharsToListOfCodes( const char *s, size_t len, encoding_t enc USES_REGS ) -{ +static inline Term Yap_NCharsToListOfCodes(const char *s, size_t len, + encoding_t enc USES_REGS) { seq_tv_t inp, out; inp.val.c0 = s; inp.sz = len; - inp.type = YAP_STRING_CHARS|YAP_STRING_NCHARS; + inp.type = YAP_STRING_CHARS | YAP_STRING_NCHARS; inp.enc = enc; out.type = YAP_STRING_CODES; out.max = len; @@ -876,15 +946,14 @@ Yap_NCharsToListOfCodes( const char *s, size_t len, encoding_t enc USES_REGS ) return out.val.t; } -static inline Term -Yap_NCharsToString( const char *s, size_t len, encoding_t enc USES_REGS ) -{ +static inline Term Yap_NCharsToString(const char *s, size_t len, + encoding_t enc USES_REGS) { seq_tv_t inp, out; inp.val.c0 = s; inp.sz = len; inp.enc = enc; - inp.type = YAP_STRING_CHARS|YAP_STRING_NCHARS; + inp.type = YAP_STRING_CHARS | YAP_STRING_NCHARS; out.type = YAP_STRING_STRING; out.max = len; if (!Yap_CVT_Text(&inp, &out PASS_REGS)) @@ -892,13 +961,12 @@ Yap_NCharsToString( const char *s, size_t len, encoding_t enc USES_REGS ) return out.val.t; } -static inline Term -Yap_NCharsToTDQ( const char *s, size_t len, encoding_t enc, Term mod USES_REGS ) -{ +static inline Term Yap_NCharsToTDQ(const char *s, size_t len, encoding_t enc, + Term mod USES_REGS) { seq_tv_t inp, out; - + inp.val.c0 = s; - inp.type = YAP_STRING_CHARS|YAP_STRING_NCHARS; + inp.type = YAP_STRING_CHARS | YAP_STRING_NCHARS; inp.sz = len; inp.enc = enc; inp.mod = mod; @@ -907,17 +975,16 @@ Yap_NCharsToTDQ( const char *s, size_t len, encoding_t enc, Term mod USES_REGS ) if (!Yap_CVT_Text(&inp, &out PASS_REGS)) return 0L; if (out.type == YAP_STRING_ATOM) - return MkAtomTerm( out.val.a ); + return MkAtomTerm(out.val.a); return out.val.t; } -static inline Term -Yap_NCharsToTBQ( const char *s, size_t len, encoding_t enc, Term mod USES_REGS ) -{ +static inline Term Yap_NCharsToTBQ(const char *s, size_t len, encoding_t enc, + Term mod USES_REGS) { seq_tv_t inp, out; - + inp.val.c0 = s; - inp.type = YAP_STRING_CHARS|YAP_STRING_NCHARS; + inp.type = YAP_STRING_CHARS | YAP_STRING_NCHARS; inp.sz = len; inp.enc = enc; inp.mod = mod; @@ -926,81 +993,74 @@ Yap_NCharsToTBQ( const char *s, size_t len, encoding_t enc, Term mod USES_REGS if (!Yap_CVT_Text(&inp, &out PASS_REGS)) return 0L; if (out.type == YAP_STRING_ATOM) - return MkAtomTerm( out.val.a ); + return MkAtomTerm(out.val.a); return out.val.t; } -static inline Atom -Yap_NumberToAtom(Term t0 USES_REGS) -{ +static inline Atom Yap_NumberToAtom(Term t0 USES_REGS) { seq_tv_t inp, out; inp.val.t = t0; - inp.type = YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_BIG|YAP_STRING_TERM; + inp.type = + YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; out.type = YAP_STRING_ATOM; if (!Yap_CVT_Text(&inp, &out PASS_REGS)) return 0L; return out.val.a; } -static inline Term -Yap_NumberToListOfAtoms(Term t0 USES_REGS) -{ +static inline Term Yap_NumberToListOfAtoms(Term t0 USES_REGS) { seq_tv_t inp, out; inp.val.t = t0; - inp.type = YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_BIG|YAP_STRING_TERM; + inp.type = + YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; out.type = YAP_STRING_ATOMS; if (!Yap_CVT_Text(&inp, &out PASS_REGS)) return 0L; return out.val.t; } -static inline Term -Yap_NumberToListOfCodes(Term t0 USES_REGS) -{ +static inline Term Yap_NumberToListOfCodes(Term t0 USES_REGS) { seq_tv_t inp, out; inp.val.t = t0; - inp.type = YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_BIG|YAP_STRING_TERM; + inp.type = + YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; out.type = YAP_STRING_CODES; if (!Yap_CVT_Text(&inp, &out PASS_REGS)) return 0L; return out.val.t; } -static inline Term -Yap_NumberToString(Term t0 USES_REGS) -{ +static inline Term Yap_NumberToString(Term t0 USES_REGS) { seq_tv_t inp, out; inp.val.t = t0; - inp.type = YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_BIG|YAP_STRING_TERM; + inp.type = + YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; out.type = YAP_STRING_STRING; if (!Yap_CVT_Text(&inp, &out PASS_REGS)) return 0L; return out.val.t; } -static inline Atom -Yap_NWCharsToAtom( const wchar_t *s, size_t len USES_REGS ) -{ - seq_tv_t inp, out; - - inp.val.w0 = s; - inp.sz = len; - inp.type = YAP_STRING_WCHARS|YAP_STRING_NCHARS; - out.type = YAP_STRING_ATOM; - out.max = len; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.a; -} - -static inline Term -Yap_NWCharsToListOfAtoms( const wchar_t *s, size_t len USES_REGS ) -{ +static inline Atom Yap_NWCharsToAtom(const wchar_t *s, size_t len USES_REGS) { seq_tv_t inp, out; inp.val.w0 = s; inp.sz = len; - inp.type = YAP_STRING_WCHARS|YAP_STRING_NCHARS; + inp.type = YAP_STRING_WCHARS | YAP_STRING_NCHARS; + out.type = YAP_STRING_ATOM; + out.max = len; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.a; +} + +static inline Term Yap_NWCharsToListOfAtoms(const wchar_t *s, + size_t len USES_REGS) { + seq_tv_t inp, out; + + inp.val.w0 = s; + inp.sz = len; + inp.type = YAP_STRING_WCHARS | YAP_STRING_NCHARS; out.type = YAP_STRING_ATOMS; out.max = len; if (!Yap_CVT_Text(&inp, &out PASS_REGS)) @@ -1008,14 +1068,13 @@ Yap_NWCharsToListOfAtoms( const wchar_t *s, size_t len USES_REGS ) return out.val.t; } -static inline Term -Yap_NWCharsToListOfCodes( const wchar_t *s, size_t len USES_REGS ) -{ +static inline Term Yap_NWCharsToListOfCodes(const wchar_t *s, + size_t len USES_REGS) { seq_tv_t inp, out; inp.val.w0 = s; inp.sz = len; - inp.type = YAP_STRING_WCHARS|YAP_STRING_NCHARS; + inp.type = YAP_STRING_WCHARS | YAP_STRING_NCHARS; out.type = YAP_STRING_CODES; out.val.uc = NULL; out.max = len; @@ -1024,14 +1083,12 @@ Yap_NWCharsToListOfCodes( const wchar_t *s, size_t len USES_REGS ) return out.val.t; } -static inline Term -Yap_NWCharsToString( const wchar_t *s, size_t len USES_REGS ) -{ +static inline Term Yap_NWCharsToString(const wchar_t *s, size_t len USES_REGS) { seq_tv_t inp, out; inp.val.w0 = s; inp.sz = len; - inp.type = YAP_STRING_WCHARS|YAP_STRING_NCHARS; + inp.type = YAP_STRING_WCHARS | YAP_STRING_NCHARS; out.val.uc = NULL; out.type = YAP_STRING_STRING; out.max = len; @@ -1040,9 +1097,7 @@ Yap_NWCharsToString( const wchar_t *s, size_t len USES_REGS ) return out.val.t; } -static inline Atom -Yap_StringToAtom(Term t0 USES_REGS) -{ +static inline Atom Yap_StringToAtom(Term t0 USES_REGS) { seq_tv_t inp, out; inp.sz = 0; inp.val.t = t0; @@ -1054,13 +1109,13 @@ Yap_StringToAtom(Term t0 USES_REGS) return out.val.a; } -static inline Atom -Yap_StringSWIToAtom(Term t0 USES_REGS) -{ +static inline Atom Yap_StringSWIToAtom(Term t0 USES_REGS) { seq_tv_t inp, out; inp.sz = 0; inp.val.t = t0; - inp.type = YAP_STRING_STRING|YAP_STRING_ATOM|YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_BIG|YAP_STRING_ATOMS_CODES|YAP_STRING_TERM; + inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | + YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_ATOMS_CODES | + YAP_STRING_TERM; out.type = YAP_STRING_ATOM; out.val.uc = NULL; if (!Yap_CVT_Text(&inp, &out PASS_REGS)) @@ -1068,23 +1123,20 @@ Yap_StringSWIToAtom(Term t0 USES_REGS) return out.val.a; } -static inline size_t -Yap_StringToAtomic(Term t0 USES_REGS) -{ +static inline size_t Yap_StringToAtomic(Term t0 USES_REGS) { seq_tv_t inp, out; inp.sz = 0; inp.val.t = t0; inp.type = YAP_STRING_STRING; - out.type = YAP_STRING_ATOM|YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_BIG|YAP_STRING_TERM; + out.type = YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT | + YAP_STRING_BIG | YAP_STRING_TERM; out.val.uc = NULL; if (!Yap_CVT_Text(&inp, &out PASS_REGS)) return 0L; return out.val.t; } -static inline size_t -Yap_StringToLength(Term t0 USES_REGS) -{ +static inline size_t Yap_StringToLength(Term t0 USES_REGS) { seq_tv_t inp, out; inp.sz = 0; inp.val.t = t0; @@ -1096,9 +1148,7 @@ Yap_StringToLength(Term t0 USES_REGS) return out.val.l; } -static inline size_t -Yap_StringToListOfAtoms(Term t0 USES_REGS) -{ +static inline size_t Yap_StringToListOfAtoms(Term t0 USES_REGS) { seq_tv_t inp, out; inp.sz = 0; inp.val.t = t0; @@ -1110,13 +1160,13 @@ Yap_StringToListOfAtoms(Term t0 USES_REGS) return out.val.t; } -static inline size_t -Yap_StringSWIToListOfAtoms(Term t0 USES_REGS) -{ +static inline size_t Yap_StringSWIToListOfAtoms(Term t0 USES_REGS) { seq_tv_t inp, out; inp.sz = 0; inp.val.t = t0; - inp.type = YAP_STRING_STRING|YAP_STRING_ATOM|YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_BIG|YAP_STRING_ATOMS_CODES|YAP_STRING_TERM; + inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | + YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_ATOMS_CODES | + YAP_STRING_TERM; out.type = YAP_STRING_ATOMS; out.val.uc = NULL; if (!Yap_CVT_Text(&inp, &out PASS_REGS)) @@ -1124,9 +1174,7 @@ Yap_StringSWIToListOfAtoms(Term t0 USES_REGS) return out.val.t; } -static inline size_t -Yap_StringToListOfCodes(Term t0 USES_REGS) -{ +static inline size_t Yap_StringToListOfCodes(Term t0 USES_REGS) { seq_tv_t inp, out; inp.val.t = t0; inp.sz = 0; @@ -1138,12 +1186,12 @@ Yap_StringToListOfCodes(Term t0 USES_REGS) return out.val.t; } -static inline size_t -Yap_StringSWIToListOfCodes(Term t0 USES_REGS) -{ +static inline size_t Yap_StringSWIToListOfCodes(Term t0 USES_REGS) { seq_tv_t inp, out; inp.val.t = t0; - inp.type = YAP_STRING_STRING|YAP_STRING_ATOM|YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_BIG|YAP_STRING_ATOMS_CODES|YAP_STRING_TERM; + inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | + YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_ATOMS_CODES | + YAP_STRING_TERM; out.type = YAP_STRING_CODES; out.val.uc = NULL; if (!Yap_CVT_Text(&inp, &out PASS_REGS)) @@ -1151,23 +1199,20 @@ Yap_StringSWIToListOfCodes(Term t0 USES_REGS) return out.val.t; } -static inline Term -Yap_StringToNumber(Term t0 USES_REGS) -{ +static inline Term Yap_StringToNumber(Term t0 USES_REGS) { seq_tv_t inp, out; inp.val.t = t0; inp.sz = 0; inp.type = YAP_STRING_STRING; - out.type = YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_BIG|YAP_STRING_TERM; + out.type = + YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; out.val.uc = NULL; if (!Yap_CVT_Text(&inp, &out PASS_REGS)) return 0L; return out.val.t; } -static inline Term -Yap_WCharsToListOfCodes(const wchar_t *s USES_REGS) -{ +static inline Term Yap_WCharsToListOfCodes(const wchar_t *s USES_REGS) { seq_tv_t inp, out; inp.val.w0 = s; inp.sz = 0; @@ -1179,11 +1224,9 @@ Yap_WCharsToListOfCodes(const wchar_t *s USES_REGS) return out.val.t; } -static inline Term -Yap_WCharsToTDQ( wchar_t *s, Term mod USES_REGS ) -{ +static inline Term Yap_WCharsToTDQ(wchar_t *s, Term mod USES_REGS) { seq_tv_t inp, out; - + inp.val.w0 = s; inp.type = YAP_STRING_WCHARS; inp.sz = 0; @@ -1193,15 +1236,13 @@ Yap_WCharsToTDQ( wchar_t *s, Term mod USES_REGS ) if (!Yap_CVT_Text(&inp, &out PASS_REGS)) return 0L; if (out.type == YAP_STRING_ATOM) - return MkAtomTerm( out.val.a); + return MkAtomTerm(out.val.a); return out.val.t; } -static inline Term -Yap_WCharsToTBQ( wchar_t *s, Term mod USES_REGS ) -{ +static inline Term Yap_WCharsToTBQ(wchar_t *s, Term mod USES_REGS) { seq_tv_t inp, out; - + inp.val.w = s; inp.type = YAP_STRING_WCHARS; inp.sz = 0; @@ -1211,13 +1252,11 @@ Yap_WCharsToTBQ( wchar_t *s, Term mod USES_REGS ) if (!Yap_CVT_Text(&inp, &out PASS_REGS)) return 0L; if (out.type == YAP_STRING_ATOM) - return MkAtomTerm( out.val.a); + return MkAtomTerm(out.val.a); return out.val.t; } -static inline Term -Yap_WCharsToString(const wchar_t *s USES_REGS) -{ +static inline Term Yap_WCharsToString(const wchar_t *s USES_REGS) { seq_tv_t inp, out; inp.val.w0 = s; inp.sz = 0; @@ -1229,9 +1268,7 @@ Yap_WCharsToString(const wchar_t *s USES_REGS) return out.val.t; } -static inline Atom -Yap_ConcatAtoms(Term t1, Term t2 USES_REGS) -{ +static inline Atom Yap_ConcatAtoms(Term t1, Term t2 USES_REGS) { seq_tv_t inpv[2], out; inpv[0].val.t = t1; inpv[0].type = YAP_STRING_ATOM; @@ -1246,15 +1283,15 @@ Yap_ConcatAtoms(Term t1, Term t2 USES_REGS) return out.val.a; } -static inline Atom -Yap_ConcatAtomics(Term t1, Term t2 USES_REGS) -{ +static inline Atom Yap_ConcatAtomics(Term t1, Term t2 USES_REGS) { seq_tv_t inpv[2], out; inpv[0].val.t = t1; - inpv[0].type = YAP_STRING_STRING|YAP_STRING_ATOM|YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_BIG|YAP_STRING_TERM; + inpv[0].type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | + YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; inpv[0].sz = 0; inpv[1].val.t = t2; - inpv[1].type = YAP_STRING_STRING|YAP_STRING_ATOM|YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_BIG|YAP_STRING_TERM; + inpv[1].type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | + YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; inpv[1].sz = 0; out.type = YAP_STRING_ATOM; out.val.uc = NULL; @@ -1263,9 +1300,7 @@ Yap_ConcatAtomics(Term t1, Term t2 USES_REGS) return out.val.a; } -static inline Term -Yap_ConcatStrings(Term t1, Term t2 USES_REGS) -{ +static inline Term Yap_ConcatStrings(Term t1, Term t2 USES_REGS) { seq_tv_t inpv[2], out; inpv[0].val.t = t1; inpv[0].type = YAP_STRING_STRING; @@ -1280,10 +1315,8 @@ Yap_ConcatStrings(Term t1, Term t2 USES_REGS) return out.val.t; } - -static inline Atom -Yap_SpliceAtom(Term t1, Atom ats[], size_t cut, size_t max USES_REGS) -{ +static inline Atom Yap_SpliceAtom(Term t1, Atom ats[], size_t cut, + size_t max USES_REGS) { seq_tv_t outv[2], inp; size_t cuts[2]; cuts[0] = cut; @@ -1302,9 +1335,7 @@ Yap_SpliceAtom(Term t1, Atom ats[], size_t cut, size_t max USES_REGS) return ats[0]; } -static inline Atom -Yap_SubtractHeadAtom(Term t1, Term th USES_REGS) -{ +static inline Atom Yap_SubtractHeadAtom(Term t1, Term th USES_REGS) { seq_tv_t outv[2], inp; inp.type = YAP_STRING_ATOM; inp.val.t = t1; @@ -1315,15 +1346,13 @@ Yap_SubtractHeadAtom(Term t1, Term th USES_REGS) outv[1].type = YAP_STRING_ATOM; outv[1].val.t = 0; outv[1].sz = 0; - if (!Yap_Splice_Text(2, (size_t *)NULL, &inp, (encoding_t *)NULL, outv PASS_REGS)) + if (!Yap_Splice_Text(2, (size_t *)NULL, &inp, (encoding_t *)NULL, + outv PASS_REGS)) return (Atom)NULL; return outv[1].val.a; } - -static inline Atom -Yap_SubtractTailAtom(Term t1, Term th USES_REGS) -{ +static inline Atom Yap_SubtractTailAtom(Term t1, Term th USES_REGS) { seq_tv_t outv[2], inp; inp.type = YAP_STRING_ATOM; inp.val.t = t1; @@ -1333,14 +1362,14 @@ Yap_SubtractTailAtom(Term t1, Term th USES_REGS) outv[0].sz = 0; outv[1].type = YAP_STRING_ATOM; outv[1].val.t = th; - if (!Yap_Splice_Text(2, (size_t *)NULL, &inp, (encoding_t *)NULL, outv PASS_REGS)) + if (!Yap_Splice_Text(2, (size_t *)NULL, &inp, (encoding_t *)NULL, + outv PASS_REGS)) return (Atom)NULL; return outv[0].val.a; } -static inline Term -Yap_SpliceString(Term t1, Term ts[], size_t cut, size_t max USES_REGS) -{ +static inline Term Yap_SpliceString(Term t1, Term ts[], size_t cut, + size_t max USES_REGS) { seq_tv_t outv[2], inp; size_t cuts[2]; inp.type = YAP_STRING_STRING; @@ -1351,16 +1380,14 @@ Yap_SpliceString(Term t1, Term ts[], size_t cut, size_t max USES_REGS) outv[1].sz = 0; cuts[0] = cut; cuts[1] = max; - if (!Yap_Splice_Text(2, cuts, &inp, (encoding_t *)NULL, outv PASS_REGS)) + if (!Yap_Splice_Text(2, cuts, &inp, (encoding_t *)NULL, outv PASS_REGS)) return 0L; ts[0] = outv[0].val.t; ts[1] = outv[1].val.t; return ts[0]; } -static inline Term -Yap_SubtractHeadString(Term t1, Term th USES_REGS) -{ +static inline Term Yap_SubtractHeadString(Term t1, Term th USES_REGS) { seq_tv_t outv[2], inp; inp.type = YAP_STRING_STRING; inp.val.t = t1; @@ -1371,14 +1398,13 @@ Yap_SubtractHeadString(Term t1, Term th USES_REGS) outv[1].type = YAP_STRING_STRING; outv[1].val.t = 0; outv[1].sz = 0; - if (!Yap_Splice_Text(2, (size_t *)NULL, &inp, (encoding_t *)NULL, outv PASS_REGS)) + if (!Yap_Splice_Text(2, (size_t *)NULL, &inp, (encoding_t *)NULL, + outv PASS_REGS)) return 0L; return outv[1].val.t; } -static inline Term -Yap_SubtractTailString(Term t1, Term th USES_REGS) -{ +static inline Term Yap_SubtractTailString(Term t1, Term th USES_REGS) { seq_tv_t outv[2], inp; inp.type = YAP_STRING_STRING; inp.val.t = t1; @@ -1388,7 +1414,8 @@ Yap_SubtractTailString(Term t1, Term th USES_REGS) outv[0].sz = 0; outv[1].type = YAP_STRING_STRING; outv[1].val.t = th; - if (!Yap_Splice_Text(2, (size_t *)NULL, &inp, (encoding_t *)NULL, outv PASS_REGS)) + if (!Yap_Splice_Text(2, (size_t *)NULL, &inp, (encoding_t *)NULL, + outv PASS_REGS)) return 0L; return outv[0].val.t; } diff --git a/H/dhstruct.h b/H/dhstruct.h index e019b4bca..38affffa4 100644 --- a/H/dhstruct.h +++ b/H/dhstruct.h @@ -1,4 +1,4 @@ - + /* This file, dhstruct.h, was generated automatically by "yap -L misc/buildheap" please do not update, update misc/HEAPFIELDS instead */ @@ -91,6 +91,7 @@ #define IDB_MODULE Yap_heap_regs->idb_module #define ATTRIBUTES_MODULE Yap_heap_regs->attributes_module #define CHARSIO_MODULE Yap_heap_regs->charsio_module +#define CHTYPE_MODULE Yap_heap_regs->chtype_module #define TERMS_MODULE Yap_heap_regs->terms_module #define SYSTEM_MODULE Yap_heap_regs->system_module #define OPERATING_SYSTEM_MODULE Yap_heap_regs->operating_system_module diff --git a/H/hstruct.h b/H/hstruct.h index 437d230e5..8dcac74bc 100755 --- a/H/hstruct.h +++ b/H/hstruct.h @@ -1,4 +1,4 @@ - + /* This file, hstruct.h, was generated automatically by "yap -L misc/buildheap" please do not update, update misc/HEAPFIELDS instead */ @@ -91,6 +91,7 @@ Term idb_module; Term attributes_module; Term charsio_module; + Term chtype_module; Term terms_module; Term system_module; Term operating_system_module; diff --git a/H/iatoms.h b/H/iatoms.h index b21080624..4d0bf0224 100644 --- a/H/iatoms.h +++ b/H/iatoms.h @@ -1,4 +1,4 @@ - + /* This file, iatoms.h, was generated automatically by "yap -L misc/buildatoms" please do not update, update misc/ATOMS instead */ @@ -55,6 +55,7 @@ AtomCharacterCode = Yap_LookupAtom("character_code"); AtomChars = Yap_LookupAtom("chars"); AtomCharset = Yap_LookupAtom("charset"); + AtomChType = Yap_FullLookupAtom("$char_type"); AtomCleanCall = Yap_FullLookupAtom("$clean_call"); AtomColomn = Yap_LookupAtom(":"); AtomCodeSpace = Yap_LookupAtom("code_space"); diff --git a/H/ihstruct.h b/H/ihstruct.h index 95b5eb2c7..874905c1b 100644 --- a/H/ihstruct.h +++ b/H/ihstruct.h @@ -1,4 +1,4 @@ - + /* This file, ihstruct.h, was generated automatically by "yap -L misc/buildheap" please do not update, update misc/HEAPFIELDS instead */ @@ -91,6 +91,7 @@ IDB_MODULE = MkAtomTerm(AtomIDB); ATTRIBUTES_MODULE = MkAtomTerm(AtomAttributes); CHARSIO_MODULE = MkAtomTerm(AtomCharsio); + CHTYPE_MODULE = MkAtomTerm(AtomChType); TERMS_MODULE = MkAtomTerm(AtomTerms); SYSTEM_MODULE = MkAtomTerm(AtomSystem); OPERATING_SYSTEM_MODULE = MkAtomTerm(AtomOperatingSystemSupport); diff --git a/H/ratoms.h b/H/ratoms.h index df5291871..cc3875fcd 100644 --- a/H/ratoms.h +++ b/H/ratoms.h @@ -1,4 +1,4 @@ - + /* This file, ratoms.h, was generated automatically by "yap -L misc/buildatoms" please do not update, update misc/ATOMS instead */ @@ -55,6 +55,7 @@ AtomCharacterCode = AtomAdjust(AtomCharacterCode); AtomChars = AtomAdjust(AtomChars); AtomCharset = AtomAdjust(AtomCharset); + AtomChType = AtomAdjust(AtomChType); AtomCleanCall = AtomAdjust(AtomCleanCall); AtomColomn = AtomAdjust(AtomColomn); AtomCodeSpace = AtomAdjust(AtomCodeSpace); diff --git a/H/rhstruct.h b/H/rhstruct.h index 968722e8f..7b1dffb9c 100644 --- a/H/rhstruct.h +++ b/H/rhstruct.h @@ -1,197 +1,304 @@ - -/* This file, rhstruct.h, was generated automatically by "yap -L misc/buildheap" - please do not update, update misc/HEAPFIELDS instead */ + + /* This file, rhstruct.h, was generated automatically by "yap -L misc/buildheap" + please do not update, update misc/HEAPFIELDS instead */ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + #if USE_DL_MALLOC + #if defined(YAPOR) || defined(THREADS) -REINIT_LOCK(DLMallocLock); + REINIT_LOCK(DLMallocLock); #endif #endif #if USE_DL_MALLOC || (USE_SYSTEM_MALLOC && HAVE_MALLINFO) -#ifndef HeapUsed -#define HeapUsed Yap_givemallinfo() +#ifndef HeapUsed +#define HeapUsed Yap_givemallinfo() #endif #else #endif + + + #if defined(YAPOR) || defined(THREADS) -REINIT_LOCK(FreeBlocksLock); -REINIT_LOCK(HeapUsedLock); -REINIT_LOCK(HeapTopLock); + REINIT_LOCK(FreeBlocksLock); + REINIT_LOCK(HeapUsedLock); + REINIT_LOCK(HeapTopLock); #endif + + + #if USE_THREADED_CODE -OP_RTABLE = OpRTableAdjust(OP_RTABLE); + OP_RTABLE = OpRTableAdjust(OP_RTABLE); #endif -EXECUTE_CPRED_OP_CODE = Yap_opcode(_execute_cpred); -EXPAND_OP_CODE = Yap_opcode(_expand_index); -FAIL_OPCODE = Yap_opcode(_op_fail); -INDEX_OPCODE = Yap_opcode(_index_pred); -LOCKPRED_OPCODE = Yap_opcode(_lock_pred); -ORLAST_OPCODE = Yap_opcode(_or_last); -UNDEF_OPCODE = Yap_opcode(_undef_p); -RETRY_USERC_OPCODE = Yap_opcode(_retry_userc); -EXECUTE_CPRED_OPCODE = Yap_opcode(_execute_cpred); + EXECUTE_CPRED_OP_CODE = Yap_opcode(_execute_cpred); + EXPAND_OP_CODE = Yap_opcode(_expand_index); + FAIL_OPCODE = Yap_opcode(_op_fail); + INDEX_OPCODE = Yap_opcode(_index_pred); + LOCKPRED_OPCODE = Yap_opcode(_lock_pred); + ORLAST_OPCODE = Yap_opcode(_or_last); + UNDEF_OPCODE = Yap_opcode(_undef_p); + RETRY_USERC_OPCODE = Yap_opcode(_retry_userc); + EXECUTE_CPRED_OPCODE = Yap_opcode(_execute_cpred); -RestoreInvisibleAtoms(); -RestoreWideAtoms(); -RestoreAtoms(); + + + + + RestoreInvisibleAtoms(); + RestoreWideAtoms(); + RestoreAtoms(); #include "ratoms.h" #ifdef EUROTRA -TermDollarU = AtomTermAdjust(TermDollarU); + TermDollarU = AtomTermAdjust(TermDollarU); #endif -USER_MODULE = AtomTermAdjust(USER_MODULE); -IDB_MODULE = AtomTermAdjust(IDB_MODULE); -ATTRIBUTES_MODULE = AtomTermAdjust(ATTRIBUTES_MODULE); -CHARSIO_MODULE = AtomTermAdjust(CHARSIO_MODULE); -TERMS_MODULE = AtomTermAdjust(TERMS_MODULE); -SYSTEM_MODULE = AtomTermAdjust(SYSTEM_MODULE); -OPERATING_SYSTEM_MODULE = AtomTermAdjust(OPERATING_SYSTEM_MODULE); -READUTIL_MODULE = AtomTermAdjust(READUTIL_MODULE); -HACKS_MODULE = AtomTermAdjust(HACKS_MODULE); -ARG_MODULE = AtomTermAdjust(ARG_MODULE); -GLOBALS_MODULE = AtomTermAdjust(GLOBALS_MODULE); -SWI_MODULE = AtomTermAdjust(SWI_MODULE); -DBLOAD_MODULE = AtomTermAdjust(DBLOAD_MODULE); -RANGE_MODULE = AtomTermAdjust(RANGE_MODULE); + USER_MODULE = AtomTermAdjust(USER_MODULE); + IDB_MODULE = AtomTermAdjust(IDB_MODULE); + ATTRIBUTES_MODULE = AtomTermAdjust(ATTRIBUTES_MODULE); + CHARSIO_MODULE = AtomTermAdjust(CHARSIO_MODULE); + CHTYPE_MODULE = AtomTermAdjust(CHTYPE_MODULE); + TERMS_MODULE = AtomTermAdjust(TERMS_MODULE); + SYSTEM_MODULE = AtomTermAdjust(SYSTEM_MODULE); + OPERATING_SYSTEM_MODULE = AtomTermAdjust(OPERATING_SYSTEM_MODULE); + READUTIL_MODULE = AtomTermAdjust(READUTIL_MODULE); + HACKS_MODULE = AtomTermAdjust(HACKS_MODULE); + ARG_MODULE = AtomTermAdjust(ARG_MODULE); + GLOBALS_MODULE = AtomTermAdjust(GLOBALS_MODULE); + SWI_MODULE = AtomTermAdjust(SWI_MODULE); + DBLOAD_MODULE = AtomTermAdjust(DBLOAD_MODULE); + RANGE_MODULE = AtomTermAdjust(RANGE_MODULE); -CurrentModules = ModEntryPtrAdjust(CurrentModules); -RestoreHiddenPredicates(); -RestoreFlags(GLOBAL_flagCount); + CurrentModules = ModEntryPtrAdjust(CurrentModules); -RestorePredHash(); + + + + RestoreHiddenPredicates(); + + + + + RestoreFlags(GLOBAL_flagCount); + + + + RestorePredHash(); #if defined(YAPOR) || defined(THREADS) #endif -CreepCode = PtoPredAdjust(CreepCode); -UndefCode = PtoPredAdjust(UndefCode); -SpyCode = PtoPredAdjust(SpyCode); -PredFail = PtoPredAdjust(PredFail); -PredTrue = PtoPredAdjust(PredTrue); + + + CreepCode = PtoPredAdjust(CreepCode); + UndefCode = PtoPredAdjust(UndefCode); + SpyCode = PtoPredAdjust(SpyCode); + PredFail = PtoPredAdjust(PredFail); + PredTrue = PtoPredAdjust(PredTrue); #ifdef COROUTINING -WakeUpCode = PtoPredAdjust(WakeUpCode); + WakeUpCode = PtoPredAdjust(WakeUpCode); #endif -PredGoalExpansion = PtoPredAdjust(PredGoalExpansion); -PredMetaCall = PtoPredAdjust(PredMetaCall); -PredTraceMetaCall = PtoPredAdjust(PredTraceMetaCall); -PredDollarCatch = PtoPredAdjust(PredDollarCatch); -PredRecordedWithKey = PtoPredAdjust(PredRecordedWithKey); -PredLogUpdClause = PtoPredAdjust(PredLogUpdClause); -PredLogUpdClauseErase = PtoPredAdjust(PredLogUpdClauseErase); -PredLogUpdClause0 = PtoPredAdjust(PredLogUpdClause0); -PredStaticClause = PtoPredAdjust(PredStaticClause); -PredThrow = PtoPredAdjust(PredThrow); -PredHandleThrow = PtoPredAdjust(PredHandleThrow); -PredIs = PtoPredAdjust(PredIs); -PredSafeCallCleanup = PtoPredAdjust(PredSafeCallCleanup); -PredRestoreRegs = PtoPredAdjust(PredRestoreRegs); -PredCommentHook = PtoPredAdjust(PredCommentHook); + PredGoalExpansion = PtoPredAdjust(PredGoalExpansion); + PredMetaCall = PtoPredAdjust(PredMetaCall); + PredTraceMetaCall = PtoPredAdjust(PredTraceMetaCall); + PredDollarCatch = PtoPredAdjust(PredDollarCatch); + PredRecordedWithKey = PtoPredAdjust(PredRecordedWithKey); + PredLogUpdClause = PtoPredAdjust(PredLogUpdClause); + PredLogUpdClauseErase = PtoPredAdjust(PredLogUpdClauseErase); + PredLogUpdClause0 = PtoPredAdjust(PredLogUpdClause0); + PredStaticClause = PtoPredAdjust(PredStaticClause); + PredThrow = PtoPredAdjust(PredThrow); + PredHandleThrow = PtoPredAdjust(PredHandleThrow); + PredIs = PtoPredAdjust(PredIs); + PredSafeCallCleanup = PtoPredAdjust(PredSafeCallCleanup); + PredRestoreRegs = PtoPredAdjust(PredRestoreRegs); + PredCommentHook = PtoPredAdjust(PredCommentHook); #ifdef YAPOR -PredGetwork = PtoPredAdjust(PredGetwork); -PredGetworkSeq = PtoPredAdjust(PredGetworkSeq); + PredGetwork = PtoPredAdjust(PredGetwork); + PredGetworkSeq = PtoPredAdjust(PredGetworkSeq); #endif /* YAPOR */ #ifdef LOW_LEVEL_TRACER #if defined(YAPOR) || defined(THREADS) -REINIT_LOCK(Yap_low_level_trace_lock); + REINIT_LOCK(Yap_low_level_trace_lock); #endif #endif -DUMMYCODE->opc = Yap_opcode(_op_fail); -FAILCODE->opc = Yap_opcode(_op_fail); -NOCODE->opc = Yap_opcode(_Nstop); -RestoreEnvInst(ENV_FOR_TRUSTFAIL, &TRUSTFAILCODE, _trust_fail, PredFail); -RestoreEnvInst(ENV_FOR_YESCODE, &YESCODE, _Ystop, PredFail); -RestoreOtaplInst(RTRYCODE, _retry_and_mark, PredFail); + + + + + + + + + + DUMMYCODE->opc = Yap_opcode(_op_fail); + FAILCODE->opc = Yap_opcode(_op_fail); + NOCODE->opc = Yap_opcode(_Nstop); + RestoreEnvInst(ENV_FOR_TRUSTFAIL,&TRUSTFAILCODE,_trust_fail,PredFail); + + RestoreEnvInst(ENV_FOR_YESCODE,&YESCODE,_Ystop,PredFail); + + RestoreOtaplInst(RTRYCODE,_retry_and_mark,PredFail); #ifdef BEAM -BEAM_RETRY_CODE->opc = Yap_opcode(_beam_retry_code); + BEAM_RETRY_CODE->opc = Yap_opcode(_beam_retry_code); #endif /* BEAM */ #ifdef YAPOR -RestoreOtaplInst(GETWORK, _getwork, PredGetwork); -RestoreOtaplInst(GETWORK_SEQ, _getwork_seq, PredGetworkSeq); -GETWORK_FIRST_TIME->opc = Yap_opcode(_getwork_first_time); + RestoreOtaplInst(GETWORK,_getwork,PredGetwork); + RestoreOtaplInst(GETWORK_SEQ,_getwork_seq,PredGetworkSeq); + GETWORK_FIRST_TIME->opc = Yap_opcode(_getwork_first_time); #endif /* YAPOR */ #ifdef TABLING -RestoreOtaplInst(LOAD_ANSWER, _table_load_answer, PredFail); -RestoreOtaplInst(TRY_ANSWER, _table_try_answer, PredFail); -RestoreOtaplInst(ANSWER_RESOLUTION, _table_answer_resolution, PredFail); -RestoreOtaplInst(COMPLETION, _table_completion, PredFail); + RestoreOtaplInst(LOAD_ANSWER,_table_load_answer,PredFail); + RestoreOtaplInst(TRY_ANSWER,_table_try_answer,PredFail); + RestoreOtaplInst(ANSWER_RESOLUTION,_table_answer_resolution,PredFail); + RestoreOtaplInst(COMPLETION,_table_completion,PredFail); #ifdef THREADS_CONSUMER_SHARING -RestoreOtaplInst(ANSWER_RESOLUTION_COMPLETION, - _table_answer_resolution_completion, PredFail); + RestoreOtaplInst(ANSWER_RESOLUTION_COMPLETION,_table_answer_resolution_completion,PredFail); #endif /* THREADS_CONSUMER_SHARING */ #endif /* TABLING */ -P_before_spy = PtoOpAdjust(P_before_spy); -RETRY_C_RECORDEDP_CODE = PtoOpAdjust(RETRY_C_RECORDEDP_CODE); -RETRY_C_RECORDED_K_CODE = PtoOpAdjust(RETRY_C_RECORDED_K_CODE); + + + P_before_spy = PtoOpAdjust(P_before_spy); + + RETRY_C_RECORDEDP_CODE = PtoOpAdjust(RETRY_C_RECORDEDP_CODE); + RETRY_C_RECORDED_K_CODE = PtoOpAdjust(RETRY_C_RECORDED_K_CODE); + + + + + + + + + + + + #if defined(YAPOR) || defined(THREADS) -REINIT_LOCK(DBTermsListLock); + REINIT_LOCK(DBTermsListLock); #endif -RestoreDBTermsList(); + RestoreDBTermsList(); -RestoreExpandList(); + + RestoreExpandList(); #if defined(YAPOR) || defined(THREADS) -REINIT_LOCK(ExpandClausesListLock); -REINIT_LOCK(OpListLock); + REINIT_LOCK(ExpandClausesListLock); + REINIT_LOCK(OpListLock); #endif #ifdef DEBUG + + + #endif -RestoreUdiControlBlocks(); -RestoreIntKeys(); -RestoreIntLUKeys(); -RestoreIntBBKeys(); + RestoreUdiControlBlocks(); -RestoreDBErasedMarker(); -RestoreLogDBErasedMarker(); -RestoreDeadStaticClauses(); -RestoreDeadMegaClauses(); -RestoreDeadStaticIndices(); -RestoreDBErasedList(); -RestoreDBErasedIList(); + + + RestoreIntKeys(); + RestoreIntLUKeys(); + RestoreIntBBKeys(); + + + + + + + + RestoreDBErasedMarker(); + RestoreLogDBErasedMarker(); + + RestoreDeadStaticClauses(); + RestoreDeadMegaClauses(); + RestoreDeadStaticIndices(); + RestoreDBErasedList(); + RestoreDBErasedIList(); #if defined(YAPOR) || defined(THREADS) -REINIT_LOCK(DeadStaticClausesLock); -REINIT_LOCK(DeadMegaClausesLock); -REINIT_LOCK(DeadStaticIndicesLock); + REINIT_LOCK(DeadStaticClausesLock); + REINIT_LOCK(DeadMegaClausesLock); + REINIT_LOCK(DeadStaticIndicesLock); #endif #ifdef COROUTINING + + + #endif -OpList = OpListAdjust(OpList); + OpList = OpListAdjust(OpList); -RestoreForeignCode(); + RestoreForeignCode(); -RestoreYapRecords(); -RestoreSWIAtoms(); -RestoreEmptyWakeups(); -RestoreBlobTypes(); -RestoreBlobs(); + RestoreYapRecords(); + + RestoreSWIAtoms(); + + + + + + + + + RestoreEmptyWakeups(); + + + RestoreBlobTypes(); + RestoreBlobs(); + #if defined(YAPOR) || defined(THREADS) -REINIT_LOCK(Blobs_Lock); + REINIT_LOCK(Blobs_Lock); #endif diff --git a/H/tatoms.h b/H/tatoms.h index df98327bf..3c27ade3f 100644 --- a/H/tatoms.h +++ b/H/tatoms.h @@ -1,4 +1,4 @@ - + /* This file, tatoms.h, was generated automatically by "yap -L misc/buildatoms" please do not update, update misc/ATOMS instead */ @@ -161,6 +161,9 @@ Atom AtomCharset_; #define AtomCharset Yap_heap_regs->AtomCharset_ #define TermCharset MkAtomTerm( Yap_heap_regs->AtomCharset_ ) + Atom AtomChType_; +#define AtomChType Yap_heap_regs->AtomChType_ +#define TermChType MkAtomTerm( Yap_heap_regs->AtomChType_ ) Atom AtomCleanCall_; #define AtomCleanCall Yap_heap_regs->AtomCleanCall_ #define TermCleanCall MkAtomTerm( Yap_heap_regs->AtomCleanCall_ ) diff --git a/H/udi_private.h b/H/udi_private.h index 10d71f5e0..ebefb82ad 100644 --- a/H/udi_private.h +++ b/H/udi_private.h @@ -59,16 +59,3 @@ static inline int si_callback(void *key, void *data, void *arg) return Yap_ClauseListExtend(c->cl, *cl, c->pred); } -#ifdef USE_JUDY -#include -/* Judy1 integer sparse set intersection */ -static inline int j1_callback(void *key, void *data, void *arg) -{ - int r; - Pvoid_t *arrayP = (Pvoid_t *) arg; - J1S(r, *arrayP, (Word_t) data); - if (r == JERR) - return FALSE; - return TRUE; -} -#endif diff --git a/cmake/Config.cmake b/cmake/Config.cmake index bdeb9e104..b14fb245c 100644 --- a/cmake/Config.cmake +++ b/cmake/Config.cmake @@ -252,7 +252,7 @@ check_function_exists( labs HAVE_LABS ) check_function_exists( link HAVE_LINK) check_function_exists( localtime HAVE_LOCALTIME ) check_function_exists( lstat HAVE_LSTAT ) -check_function_exists(mallinfo HAVE_MALLINFO) +check_symbol_exists( mallinfo " malloc.h" HAVE_MALLINFO) check_function_exists(mbscoll HAVE_MBSCOLL) check_function_exists(mbscasecoll HAVE_MBSCASECOLL) check_function_exists(mbsnrtowcs HAVE_MBSNRTOWCS) diff --git a/config.h.cmake b/config.h.cmake index 37a125dd5..ab2c9e07c 100644 --- a/config.h.cmake +++ b/config.h.cmake @@ -1613,17 +1613,17 @@ signal. */ /* malloc_t */ #ifndef MALLOC_T -#cmakedefine MALLOC_T "${MALLOC_T}" +#define MALLOC_T "void *" #endif /* max number of threads, default 1 or 1024 */ -#ifndef MAX_THRADS -#cmakedefine MAX_THREADS ${MAX_THREADS} +#ifndef MAX_THREADS +#define MAX_THREADS ${MAX_THREADS} #endif /* maximum amount of or-parallelism */ #ifndef MAX_WORKERS -#cmakedefine MAX_WORKERS ${MAX_WORKERS} +#define MAX_WORKERS ${MAX_WORKERS} #endif /* o not use realloc() from HP-UX 10.20 together with MPI */ @@ -1818,37 +1818,37 @@ signal. */ /* use Doug Lea's malloc for all allocation */ #ifndef USE_DL_MALLOC -#cmakedefine USE_DL_MALLOC ${USE_DL_MALLOC} +#define USE_DL_MALLOC ${USE_DL_MALLOC} #endif /* use bignums/rationals in YAP code. */ #ifndef USE_GMP -#cmakedefine USE_GMP ${USE_GMP} +#define USE_GMP ${USE_GMP} #endif /* use Judy library for UDI indexing in YAP code. */ #ifndef USE_JUDY -#cmakedefine USE_JUDY ${USE_JUDY} +#define USE_JUDY ${USE_JUDY} #endif /* do not use our own locking routines */ #ifndef USE_PTHREAD_LOCKING -#cmakedefine USE_PTHREAD_LOCKING ${USE_PTHREAD_LOCKING} +#define USE_PTHREAD_LOCKING ${USE_PTHREAD_LOCKING} #endif /* use OS malloc for all allocation */ #ifndef USE_SYSTEM_MALLOC -#cmakedefine USE_SYSTEM_MALLOC ${USE_SYSTEM_MALLOC} +#define USE_SYSTEM_MALLOC ${USE_SYSTEM_MALLOC} #endif /* use mmap in or-parallel allocation */ #ifndef USE_SYSTEM_MMAP -#cmakedefine USE_SYSTEM_MMAP ${USE_SYSTEM_MMAP} +#define USE_SYSTEM_MMAP ${USE_SYSTEM_MMAP} #endif /* use shm in or-parallel allocation */ #ifndef USE_SYSTEM_SHM -#cmakedefine USE_SYSTEM_SHM ${USE_SYSTEM_SHM} +#define USE_SYSTEM_SHM ${USE_SYSTEM_SHM} #endif /* Whether daylight savings time offset is set via the altzone variable */ diff --git a/include/YapErrors.h b/include/YapErrors.h index 9b480f0e8..51d12f06b 100644 --- a/include/YapErrors.h +++ b/include/YapErrors.h @@ -131,6 +131,7 @@ BEGIN_ERRORS() E(TYPE_ERROR_CALLABLE, TYPE_ERROR, "callable") E(TYPE_ERROR_CHAR, TYPE_ERROR, "char") E(TYPE_ERROR_CHARACTER, TYPE_ERROR, "character") + E(TYPE_ERROR_CHARACTER_CODE, TYPE_ERROR, "character_code") E(TYPE_ERROR_COMPOUND, TYPE_ERROR, "compound") E(TYPE_ERROR_DBREF, TYPE_ERROR, "dbref") E(TYPE_ERROR_DBTERM, TYPE_ERROR, "dbterm") diff --git a/misc/ATOMS b/misc/ATOMS index f30c26581..4e3d499c7 100644 --- a/misc/ATOMS +++ b/misc/ATOMS @@ -60,6 +60,7 @@ A Character N "character" A CharacterCode N "character_code" A Chars N "chars" A Charset N "charset" +A ChType F "$char_type" A CleanCall F "$clean_call" A Colomn N ":" A CodeSpace N "code_space" diff --git a/misc/HEAPFIELDS b/misc/HEAPFIELDS index c60b0b439..668d8dcc4 100644 --- a/misc/HEAPFIELDS +++ b/misc/HEAPFIELDS @@ -94,6 +94,7 @@ Term user_module USER_MODULE MkAT AtomUser Term idb_module IDB_MODULE MkAT AtomIDB Term attributes_module ATTRIBUTES_MODULE MkAT AtomAttributes Term charsio_module CHARSIO_MODULE MkAT AtomCharsio +Term chtype_module CHTYPE_MODULE MkAT AtomChType Term terms_module TERMS_MODULE MkAT AtomTerms Term system_module SYSTEM_MODULE MkAT AtomSystem Term operating_system_module OPERATING_SYSTEM_MODULE MkAT AtomOperatingSystemSupport diff --git a/os/charsio.c b/os/charsio.c index cd691f0ee..84bf08a96 100644 --- a/os/charsio.c +++ b/os/charsio.c @@ -172,7 +172,7 @@ static Int at_end_of_stream_0(USES_REGS1) { /* at_end_of_stream */ return out; } -static int yap_fflush(sno) { +static int yap_fflush(int sno) { Yap_ReadlineFlush(sno); if ((GLOBAL_Stream[sno].status & Output_Stream_f) && !(GLOBAL_Stream[sno].status & @@ -186,11 +186,11 @@ static int yap_fflush(sno) { static Int get(USES_REGS1) { /* '$get'(Stream,-N) */ int sno = Yap_CheckTextStream(ARG1, Input_Stream_f, "get/2"); int ch; - Int status; + //Int status; if (sno < 0) return FALSE; - status = GLOBAL_Stream[sno].status; + //status = GLOBAL_Stream[sno].status; while ((ch = GLOBAL_Stream[sno].stream_wgetc(sno)) <= 32 && ch >= 0) ; UNLOCK(GLOBAL_Stream[sno].streamlock); @@ -200,11 +200,11 @@ static Int get(USES_REGS1) { /* '$get'(Stream,-N) */ static Int get_char(USES_REGS1) { /* '$get'(Stream,-N) */ int sno = Yap_CheckTextStream(ARG1, Input_Stream_f, "get/2"); int ch; - Int status; + // Int status; if (sno < 0) return FALSE; - status = GLOBAL_Stream[sno].status; + //status = GLOBAL_Stream[sno].status; ch = GLOBAL_Stream[sno].stream_wgetc(sno); UNLOCK(GLOBAL_Stream[sno].streamlock); return (Yap_unify_constant(ARG2, MkCharTerm(ch))); @@ -212,12 +212,12 @@ static Int get_char(USES_REGS1) { /* '$get'(Stream,-N) */ static Int get_code(USES_REGS1) { /* get0(Stream,-N) */ int sno = Yap_CheckTextStream(ARG1, Input_Stream_f, "get0/2"); - Int status; + //Int status; Int out; if (sno < 0) return (FALSE); - status = GLOBAL_Stream[sno].status; + //status = GLOBAL_Stream[sno].status; out = GLOBAL_Stream[sno].stream_wgetc(sno); UNLOCK(GLOBAL_Stream[sno].streamlock); return (Yap_unify_constant(ARG2, MkIntegerTerm(out))); @@ -226,10 +226,10 @@ static Int get_code(USES_REGS1) { /* get0(Stream,-N) */ static Int get_1(USES_REGS1) { /* get_code1(Stream,-N) */ int sno = LOCAL_c_input_stream; int ch; - Int status; + //Int status; LOCK(GLOBAL_Stream[sno].streamlock); - status = GLOBAL_Stream[sno].status; + //status = GLOBAL_Stream[sno].status; while ((ch = GLOBAL_Stream[sno].stream_wgetc(sno)) <= 32 && ch >= 0) ; UNLOCK(GLOBAL_Stream[sno].streamlock); @@ -238,10 +238,10 @@ static Int get_1(USES_REGS1) { /* get_code1(Stream,-N) */ static Int getcode_1(USES_REGS1) { /* get0(Stream,-N) */ int sno = LOCAL_c_input_stream; - Int status; + //Int status; Int out; - status = GLOBAL_Stream[sno].status; + //status = GLOBAL_Stream[sno].status; LOCK(GLOBAL_Stream[sno].streamlock); out = GLOBAL_Stream[sno].stream_wgetc(sno); UNLOCK(GLOBAL_Stream[sno].streamlock); @@ -250,11 +250,11 @@ static Int getcode_1(USES_REGS1) { /* get0(Stream,-N) */ static Int getchar_1(USES_REGS1) { /* get0(Stream,-N) */ int sno = LOCAL_c_input_stream; - Int status; + //Int status; Int out; LOCK(GLOBAL_Stream[sno].streamlock); - status = GLOBAL_Stream[sno].status; + //status = GLOBAL_Stream[sno].status; out = GLOBAL_Stream[sno].stream_wgetc(sno); UNLOCK(GLOBAL_Stream[sno].streamlock); return (Yap_unify_constant(ARG1, MkCharTerm(out))); @@ -262,7 +262,7 @@ static Int getchar_1(USES_REGS1) { /* get0(Stream,-N) */ static Int get0_line_codes(USES_REGS1) { /* '$get0'(Stream,-N) */ int sno = Yap_CheckTextStream(ARG1, Input_Stream_f, "get0/2"); - Int status; + //Int status; Term out; Int ch = '\0'; int rewind; @@ -270,7 +270,7 @@ static Int get0_line_codes(USES_REGS1) { /* '$get0'(Stream,-N) */ if (sno < 0) return (FALSE); rewind = FALSE; - status = GLOBAL_Stream[sno].status; + //status = GLOBAL_Stream[sno].status; out = read_line(sno); UNLOCK(GLOBAL_Stream[sno].streamlock); if (rewind) diff --git a/os/chartypes.c b/os/chartypes.c index 72e5c02a1..7b8e7ebfe 100644 --- a/os/chartypes.c +++ b/os/chartypes.c @@ -1,23 +1,22 @@ /************************************************************************* -* * -* YAP Prolog * -* * -* Yap Prolog was developed at NCCUP - Universidade do Porto * -* * -* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 * -* * -************************************************************************** -* * -* File: charcodes.c * -* Last rev: 5/2/88 * -* mods: * -* comments: Character codes and character conversion * -* * -*************************************************************************/ + * * + * YAP Prolog * + * * + * Yap Prolog was developed at NCCUP - Universidade do Porto * + * * + * Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 * + * * + ************************************************************************** + * * + * File: charcodes.c * + * Last rev: 5/2/88 * + * mods: * + * comments: Character codes and character conversion * + * * + *************************************************************************/ #ifdef SCCS static char SccsId[] = "%W% %G%"; #endif - /* * This file includes the definition of a pipe related IO. * @@ -27,6 +26,7 @@ static char SccsId[] = "%W% %G%"; #include "Yatom.h" #include "YapHeap.h" #include "yapio.h" +#include "YapText.h" #include #if HAVE_UNISTD_H #include @@ -34,6 +34,12 @@ static char SccsId[] = "%W% %G%"; #if HAVE_STDARG_H #include #endif +#if HAVE_CTYPE_H +#include +#endif +#if HAVE_WCTYPE_H +#include +#endif #ifdef _WIN32 #if HAVE_IO_H /* Windows */ @@ -51,11 +57,10 @@ static char SccsId[] = "%W% %G%"; #include "eval.h" static Int p_change_type_of_char(USES_REGS1); -static Int p_type_of_char(USES_REGS1); Term Yap_StringToNumberTerm(char *s, encoding_t *encp) { CACHE_REGS - int sno; + int sno; Term t; sno = Yap_open_buf_read_stream(s, strlen(s), encp, MEM_BUF_USER); @@ -65,7 +70,7 @@ Term Yap_StringToNumberTerm(char *s, encoding_t *encp) { GLOBAL_Stream[sno].encoding = *encp; else GLOBAL_Stream[sno].encoding = LOCAL_encoding; - while (*s && isblank(*s++)) + while (*s && iswblank(*s++)) ; t = Yap_scan_num(GLOBAL_Stream + sno); Yap_CloseStream(sno); @@ -82,15 +87,15 @@ typedef struct enc_map { } enc_map_t; static enc_map_t ematches[] = { - {"UTF-8", ENC_ISO_UTF8}, - {"UTF-16", ENC_UTF16_LE}, // ok, this is a very bad name - {"UCS-2", ENC_UTF16_LE}, // ok, this is probably gone by now - {"ISO-LATIN1", ENC_ISO_LATIN1}, - {"ISO-8859-1", ENC_ISO_LATIN1}, - {"Windows-1252", ENC_ISO_LATIN1}, // almost, but not quite - {"CP-1252", ENC_ISO_LATIN1}, - {"C", ENC_ISO_ASCII}, - {NULL, ENC_OCTET}}; + {"UTF-8", ENC_ISO_UTF8}, + {"UTF-16", ENC_UTF16_LE}, // ok, this is a very bad name + {"UCS-2", ENC_UTF16_LE}, // ok, this is probably gone by now + {"ISO-LATIN1", ENC_ISO_LATIN1}, + {"ISO-8859-1", ENC_ISO_LATIN1}, + {"Windows-1252", ENC_ISO_LATIN1}, // almost, but not quite + {"CP-1252", ENC_ISO_LATIN1}, + {"C", ENC_ISO_ASCII}, + {NULL, ENC_OCTET}}; static encoding_t DefaultEncoding(void) { encoding_t rc; @@ -114,8 +119,8 @@ static encoding_t DefaultEncoding(void) { } i++; } -// by default, return UTF-8 -// except in _WIN32 + // by default, return UTF-8 + // except in _WIN32 #ifdef _WIN32 rc = ENC_UTF16_BE; #else @@ -132,12 +137,12 @@ static encoding_t DefaultEncoding(void) { encoding_t Yap_DefaultEncoding(void) { CACHE_REGS - return LOCAL_encoding; + return LOCAL_encoding; } void Yap_SetDefaultEncoding(encoding_t new_encoding) { CACHE_REGS - LOCAL_encoding = new_encoding; + LOCAL_encoding = new_encoding; } static Int get_default_encoding(USES_REGS1) { @@ -147,7 +152,7 @@ static Int get_default_encoding(USES_REGS1) { static Int p_encoding(USES_REGS1) { /* '$encoding'(Stream,N) */ int sno = - Yap_CheckStream(ARG1, Input_Stream_f | Output_Stream_f, "encoding/2"); + Yap_CheckStream(ARG1, Input_Stream_f | Output_Stream_f, "encoding/2"); Term t = Deref(ARG2); if (sno < 0) return FALSE; @@ -187,7 +192,7 @@ static Int tolower2(USES_REGS1) { } static Int - p_change_type_of_char(USES_REGS1) { /* change_type_of_char(+char,+type) */ +p_change_type_of_char(USES_REGS1) { /* change_type_of_char(+char,+type) */ Term t1 = Deref(ARG1); Term t2 = Deref(ARG2); if (!IsVarTerm(t1) && !IsIntegerTerm(t1)) @@ -198,16 +203,366 @@ static Int return TRUE; } -static Int p_type_of_char(USES_REGS1) { /* type_of_char(+char,-type) */ - Term t; - - Term t1 = Deref(ARG1); - if (!IsVarTerm(t1) && !IsIntegerTerm(t1)) - return FALSE; - t = MkIntTerm(Yap_chtype[IntegerOfTerm(t1)]); - return Yap_unify(t, ARG2); +static int get_char(Term t) { + if (IsVarTerm(t = Deref(t))) { + Yap_Error(INSTANTIATION_ERROR, t, NULL); + return 0; + } + if (!IsAtomTerm(t)) { + Yap_Error(REPRESENTATION_ERROR_CHARACTER, t, NULL); + return 0; + } + Atom at = AtomOfTerm(t); + if (IsWideAtom(at)) { + wchar_t *s0 = RepAtom(AtomOfTerm(t))->WStrOfAE; + if (s0[1] != '\0') { + Yap_Error(REPRESENTATION_ERROR_CHARACTER, t, NULL); + return 0; + } + return s0[0]; + } else { + char *s0 = RepAtom(AtomOfTerm(t))->StrOfAE; + if (s0[1] != '\0') { + Yap_Error(REPRESENTATION_ERROR_CHARACTER, t, NULL); + return 0; + } + return s0[0]; + } + return 0; } +static int get_code(Term t) { + if (IsVarTerm(t = Deref(t))) { + Yap_Error(INSTANTIATION_ERROR, t, NULL); + return 0; + } + if (!IsIntegerTerm(t)) { + Yap_Error(TYPE_ERROR_CHARACTER_CODE, t, NULL); + return 0; + } + Int ch = IntegerOfTerm(t); + if (ch < -1) { + Yap_Error(REPRESENTATION_ERROR_CHARACTER_CODE, t, NULL); + return 0; + } + return ch; +} + +static Int char_type_alnum(USES_REGS1) { + int ch = get_char(ARG1); + char_kind_t k = Yap_wide_chtype(ch); + return k == UC || k == LC || k == NU; +} + +static Int char_type_alpha(USES_REGS1) { + int ch = get_char(ARG1); + char_kind_t k = Yap_wide_chtype(ch); + return k == UC || k == LC; +} + +static Int char_type_csym(USES_REGS1) { + int ch = get_char(ARG1); + char_kind_t k = Yap_wide_chtype(ch); + return k >= UC && k <= NU; +} + +static Int char_type_csymf(USES_REGS1) { + int ch = get_char(ARG1); + char_kind_t k = Yap_wide_chtype(ch); + return k >= UC && k <= LC; +} + +static Int char_type_ascii(USES_REGS1) { + int ch = get_char(ARG1); + return isascii(ch); +} + +static Int char_type_white(USES_REGS1) { + int ch = get_char(ARG1); + if (ch < 256) { + char_kind_t k = Yap_chtype[ch]; + return k >= UC && k <= LC; + } + utf8proc_category_t ct = utf8proc_category(ch); + return ct == UTF8PROC_CATEGORY_ZS; +} + +static Int char_type_digit(USES_REGS1) { + Int ch = get_char(ARG1); + char_kind_t k = Yap_wide_chtype(ch); + return k == NU; +} + +static Int char_type_xdigit(USES_REGS1) { + Int ch = get_char(ARG1); +#if HAVE_ISWXDIGIT + return iswxdigit( ch ); +#elif HAVE_ISWHEXNUMBER + return iswhexnumber(ch); +#else + return iswdigit(ch) || ( (ch >= 'a' && ch <= 'f') && + (ch >= 'A' && ch <= 'F') ); +#endif +} + +static Int char_type_graph(USES_REGS1) { + Int ch = get_char(ARG1); + return iswgraph(ch); +} + +static Int char_type_lower(USES_REGS1) { + int ch = get_char(ARG1); + char_kind_t k = Yap_wide_chtype(ch); + return k == LC; +} + +static Int char_type_upper(USES_REGS1) { + int ch = get_char(ARG1); + char_kind_t k = Yap_wide_chtype(ch); + return k == UC; +} + +static Int char_type_punct(USES_REGS1) { + int ch = get_char(ARG1); + if (ch < 256) { + char_kind_t k = Yap_chtype[ch]; + return k >= QT && k <= BK; + } + return false; +} + +static Int char_type_space(USES_REGS1) { + int ch = get_char(ARG1); + if (ch < 256) { + char_kind_t k = Yap_chtype[ch]; + return k == BS; + } + utf8proc_category_t ct = utf8proc_category(ch); + return (ct >= UTF8PROC_CATEGORY_ZS && ct <= UTF8PROC_CATEGORY_PO); +} + +static Int char_type_end_of_file(USES_REGS1) { + Int ch = get_char(ARG1); + return ch == WEOF || ch == -1; +} + +static Int char_type_end_of_line(USES_REGS1) { + Int ch = get_char(ARG1); + if (ch < 256) { + return ch >= 10 && ch <= 13; + } + utf8proc_category_t ct = utf8proc_category(ch); + return (ct >= UTF8PROC_CATEGORY_ZL && ct <= UTF8PROC_CATEGORY_ZP); +} + +static Int char_type_newline(USES_REGS1) { + Int ch = get_char(ARG1); + if (ch < 256) { + return ch == 10; + } + return false; +} + + +static Int char_type_period(USES_REGS1) { + Int ch = get_char(ARG1); + return ch == '.' || ch == '!' || ch == '?'; +} + +static Int char_type_quote(USES_REGS1) { + Int ch = get_char(ARG1); + utf8proc_category_t ct = utf8proc_category(ch); + return ct == UTF8PROC_CATEGORY_PI || ct == UTF8PROC_CATEGORY_PF; +} + +static Int char_type_paren(USES_REGS1) { + Int ch = get_char(ARG1); + utf8proc_category_t ct = utf8proc_category(ch); + return ct == UTF8PROC_CATEGORY_PS || ct == UTF8PROC_CATEGORY_PE; +} + +static Int char_type_prolog_var_start(USES_REGS1) { + Int ch = get_char(ARG1); + char_kind_t k = Yap_wide_chtype(ch); + return k == LC || ch == '_'; +} + +static Int char_type_prolog_atom_start(USES_REGS1) { + Int ch = get_char(ARG1); + char_kind_t k = Yap_wide_chtype(ch); + return k == UC; +} + +static Int char_type_prolog_identifier_continue(USES_REGS1) { + int ch = get_char(ARG1); + char_kind_t k = Yap_wide_chtype(ch); + return k >= UC && k <= NU; +} + +static Int char_type_prolog_symbol(USES_REGS1) { + int ch = get_char(ARG1); + char_kind_t k = Yap_wide_chtype(ch); + return k == SL && k == SY; +} + +static Int code_type_alnum(USES_REGS1) { + int ch = get_code(ARG1); + char_kind_t k = Yap_wide_chtype(ch); + return k == UC || k == LC || k == NU; +} + +static Int code_type_alpha(USES_REGS1) { + int ch = get_code(ARG1); + char_kind_t k = Yap_wide_chtype(ch); + return k == UC || k == LC; +} + +static Int code_type_csym(USES_REGS1) { + int ch = get_code(ARG1); + char_kind_t k = Yap_wide_chtype(ch); + return k >= UC && k <= NU; +} + +static Int code_type_csymf(USES_REGS1) { + int ch = get_code(ARG1); + char_kind_t k = Yap_wide_chtype(ch); + return k >= UC && k <= LC; +} + +static Int code_type_ascii(USES_REGS1) { + int ch = get_code(ARG1); + return isascii(ch); +} + +static Int code_type_white(USES_REGS1) { + int ch = get_code(ARG1); + if (ch < 256) { + char_kind_t k = Yap_chtype[ch]; + return k >= UC && k <= LC; + } + utf8proc_category_t ct = utf8proc_category(ch); + return ct == UTF8PROC_CATEGORY_ZS; +} + +static Int code_type_digit(USES_REGS1) { + Int ch = get_code(ARG1); + char_kind_t k = Yap_wide_chtype(ch); + return k == NU; +} + +static Int code_type_xdigit(USES_REGS1) { + Int ch = get_code(ARG1); +#if HAVE_ISWXDIGIT + return iswxdigit( ch ); +#elif HAVE_ISWHEXNUMBER + return iswhexnumber(ch); +#else + return iswdigit(ch) || ( (ch >= 'a' && ch <= 'f') && + (ch >= 'A' && ch <= 'F') ); +#endif +} + +static Int code_type_graph(USES_REGS1) { + Int ch = get_code(ARG1); + return iswgraph(ch); +} + +static Int code_type_lower(USES_REGS1) { + int ch = get_code(ARG1); + char_kind_t k = Yap_wide_chtype(ch); + return k == LC; +} + +static Int code_type_upper(USES_REGS1) { + int ch = get_code(ARG1); + char_kind_t k = Yap_wide_chtype(ch); + return k == UC; +} + +static Int code_type_punct(USES_REGS1) { + int ch = get_char(ARG1); + if (ch < 256) { + char_kind_t k = Yap_chtype[ch]; + return k >= QT && k <= BK; + } + return false; +} + +static Int code_type_space(USES_REGS1) { + int ch = get_code(ARG1); + if (ch < 256) { + char_kind_t k = Yap_chtype[ch]; + return k == BS; + } + utf8proc_category_t ct = utf8proc_category(ch); + return (ct >= UTF8PROC_CATEGORY_ZS && ct <= UTF8PROC_CATEGORY_PO); +} + +static Int code_type_end_of_file(USES_REGS1) { + Int ch = get_code(ARG1); + return ch == WEOF || ch == -1; +} + +static Int code_type_end_of_line(USES_REGS1) { + Int ch = get_code(ARG1); + if (ch < 256) { + return ch >= 10 && ch <= 13; + } + utf8proc_category_t ct = utf8proc_category(ch); + return (ct >= UTF8PROC_CATEGORY_ZL && ct <= UTF8PROC_CATEGORY_ZP); +} + +static Int code_type_newline(USES_REGS1) { + Int ch = get_code(ARG1); + if (ch < 256) { + return ch == 10; + } + return false; +} + + +static Int code_type_period(USES_REGS1) { + Int ch = get_code(ARG1); + return ch == '.' || ch == '!' || ch == '?'; +} + +static Int code_type_quote(USES_REGS1) { + Int ch = get_code(ARG1); + utf8proc_category_t ct = utf8proc_category(ch); + return ct == UTF8PROC_CATEGORY_PI || ct == UTF8PROC_CATEGORY_PF; +} + +static Int code_type_paren(USES_REGS1) { + Int ch = get_code(ARG1); + utf8proc_category_t ct = utf8proc_category(ch); + return ct == UTF8PROC_CATEGORY_PS || ct == UTF8PROC_CATEGORY_PE; +} + +static Int code_type_prolog_var_start(USES_REGS1) { + Int ch = get_code(ARG1); + char_kind_t k = Yap_wide_chtype(ch); + return k == LC || ch == '_'; +} + +static Int code_type_prolog_atom_start(USES_REGS1) { + Int ch = get_code(ARG1); + char_kind_t k = Yap_wide_chtype(ch); + return k == UC; +} + +static Int code_type_prolog_identifier_continue(USES_REGS1) { + int ch = get_code(ARG1); + char_kind_t k = Yap_wide_chtype(ch); + return k >= UC && k <= NU; +} + +static Int code_type_prolog_symbol(USES_REGS1) { + int ch = get_code(ARG1); + char_kind_t k = Yap_wide_chtype(ch); + return k == SL && k == SY; +} + + int ISOWGetc(int sno) { int ch = GLOBAL_Stream[sno].stream_wgetc(sno); if (ch != EOF && GLOBAL_CharConversionTable != NULL) { @@ -239,27 +594,28 @@ static Int p_disable_char_conversion(USES_REGS1) { for (i = 0; i < MaxStreams; i++) { if (!(GLOBAL_Stream[i].status & Free_Stream_f)) - GLOBAL_Stream[i].stream_wgetc_for_read = GLOBAL_Stream[i].stream_wgetc; + GLOBAL_Stream[i].stream_wgetc_for_read = + GLOBAL_Stream[i].stream_wgetc; } GLOBAL_CharConversionTable = NULL; return (TRUE); } static Int char_conversion(USES_REGS1) { - Term t0 = Deref(ARG1), t1 = Deref(ARG2); + Term t = Deref(ARG1), t1 = Deref(ARG2); unsigned char *s0, *s1; - if (IsVarTerm(t0)) { - Yap_Error(INSTANTIATION_ERROR, t0, "char_conversion/2"); + if (IsVarTerm(t)) { + Yap_Error(INSTANTIATION_ERROR, t, "char_conversion/2"); return (FALSE); } - if (!IsAtomTerm(t0)) { - Yap_Error(REPRESENTATION_ERROR_CHARACTER, t0, "char_conversion/2"); + if (!IsAtomTerm(t)) { + Yap_Error(REPRESENTATION_ERROR_CHARACTER, t, "char_conversion/2"); return (FALSE); } - s0 = RepAtom(AtomOfTerm(t0))->UStrOfAE; + s0 = RepAtom(AtomOfTerm(t))->UStrOfAE; if (s0[1] != '\0') { - Yap_Error(REPRESENTATION_ERROR_CHARACTER, t0, "char_conversion/2"); + Yap_Error(REPRESENTATION_ERROR_CHARACTER, t, "char_conversion/2"); return (FALSE); } if (IsVarTerm(t1)) { @@ -283,17 +639,17 @@ static Int char_conversion(USES_REGS1) { if (s0[0] == s1[0]) return (TRUE); GLOBAL_CharConversionTable2 = - Yap_AllocCodeSpace(NUMBER_OF_CHARS * sizeof(char)); + Yap_AllocCodeSpace(NUMBER_OF_CHARS * sizeof(char)); while (GLOBAL_CharConversionTable2 == NULL) { if (!Yap_growheap(FALSE, NUMBER_OF_CHARS * sizeof(char), NULL)) { - Yap_Error(RESOURCE_ERROR_HEAP, TermNil, LOCAL_ErrorMessage); - return (FALSE); + Yap_Error(RESOURCE_ERROR_HEAP, TermNil, LOCAL_ErrorMessage); + return (FALSE); } } if (trueGlobalPrologFlag(CHAR_CONVERSION_FLAG)) { CACHE_REGS - if (p_force_char_conversion(PASS_REGS1) == FALSE) - return (FALSE); + if (p_force_char_conversion(PASS_REGS1) == FALSE) + return (FALSE); } for (i = 0; i < NUMBER_OF_CHARS; i++) GLOBAL_CharConversionTable2[i] = i; @@ -305,24 +661,26 @@ static Int char_conversion(USES_REGS1) { } static Int p_current_char_conversion(USES_REGS1) { - Term t0, t1; + Term t, t1; unsigned char *s0, *s1; if (GLOBAL_CharConversionTable == NULL) { return (FALSE); } - t0 = Deref(ARG1); - if (IsVarTerm(t0)) { - Yap_Error(INSTANTIATION_ERROR, t0, "current_char_conversion/2"); + t = Deref(ARG1); + if (IsVarTerm(t)) { + Yap_Error(INSTANTIATION_ERROR, t, "current_char_conversion/2"); return (FALSE); } - if (!IsAtomTerm(t0)) { - Yap_Error(REPRESENTATION_ERROR_CHARACTER, t0, "current_char_conversion/2"); + if (!IsAtomTerm(t)) { + Yap_Error(REPRESENTATION_ERROR_CHARACTER, t, + "current_char_conversion/2"); return (FALSE); } - s0 = RepAtom(AtomOfTerm(t0))->UStrOfAE; + s0 = RepAtom(AtomOfTerm(t))->UStrOfAE; if (s0[1] != '\0') { - Yap_Error(REPRESENTATION_ERROR_CHARACTER, t0, "current_char_conversion/2"); + Yap_Error(REPRESENTATION_ERROR_CHARACTER, t, + "current_char_conversion/2"); return (FALSE); } t1 = Deref(ARG2); @@ -335,16 +693,18 @@ static Int p_current_char_conversion(USES_REGS1) { return (Yap_unify(ARG2, MkAtomTerm(Yap_LookupAtom(out)))); } if (!IsAtomTerm(t1)) { - Yap_Error(REPRESENTATION_ERROR_CHARACTER, t1, "current_char_conversion/2"); + Yap_Error(REPRESENTATION_ERROR_CHARACTER, t1, + "current_char_conversion/2"); return (FALSE); } s1 = RepAtom(AtomOfTerm(t1))->UStrOfAE; if (s1[1] != '\0') { - Yap_Error(REPRESENTATION_ERROR_CHARACTER, t1, "current_char_conversion/2"); + Yap_Error(REPRESENTATION_ERROR_CHARACTER, t1, + "current_char_conversion/2"); return (FALSE); } else { return (GLOBAL_CharConversionTable[(int)s0[0]] == '\0' && - GLOBAL_CharConversionTable[(int)s0[0]] == s1[0]); + GLOBAL_CharConversionTable[(int)s0[0]] == s1[0]); } } @@ -375,24 +735,88 @@ static Int p_all_char_conversions(USES_REGS1) { void Yap_InitChtypes(void) { DefaultEncoding(); Yap_InitCPred("$change_type_of_char", 2, p_change_type_of_char, - SafePredFlag | SyncPredFlag | HiddenPredFlag); - Yap_InitCPred("$type_of_char", 2, p_type_of_char, - SafePredFlag | SyncPredFlag | HiddenPredFlag); + SafePredFlag | SyncPredFlag | HiddenPredFlag); Yap_InitCPred("toupper", 2, toupper2, SafePredFlag); Yap_InitCPred("tolower", 2, tolower2, SafePredFlag); Yap_InitCPred("char_conversion", 2, char_conversion, SyncPredFlag); Yap_InitCPred("$get_default_encoding", 1, get_default_encoding, - SafePredFlag | HiddenPredFlag); + SafePredFlag | HiddenPredFlag); Yap_InitCPred("$encoding", 2, p_encoding, SafePredFlag | SyncPredFlag), - Yap_InitCPred("$current_char_conversion", 2, p_current_char_conversion, - SyncPredFlag | HiddenPredFlag); + Yap_InitCPred("$current_char_conversion", 2, + p_current_char_conversion, + SyncPredFlag | HiddenPredFlag); Yap_InitCPred("$all_char_conversions", 1, p_all_char_conversions, - SyncPredFlag | HiddenPredFlag); + SyncPredFlag | HiddenPredFlag); Yap_InitCPred("$force_char_conversion", 0, p_force_char_conversion, - SyncPredFlag | HiddenPredFlag); + SyncPredFlag | HiddenPredFlag); Yap_InitCPred("$disable_char_conversion", 0, p_disable_char_conversion, - SyncPredFlag | HiddenPredFlag); -} + SyncPredFlag | HiddenPredFlag); + CurrentModule = CHTYPE_MODULE; + Yap_InitCPred("char_type_alnum", 1, char_type_alnum, SafePredFlag); + Yap_InitCPred("char_type_alpha", 1, char_type_alpha, SafePredFlag); + Yap_InitCPred("char_type_csym", 1, char_type_csym, SafePredFlag); + Yap_InitCPred("char_type_csymf", 1, char_type_csymf, SafePredFlag); + Yap_InitCPred("char_type_ascii", 1, char_type_ascii, SafePredFlag); + Yap_InitCPred("char_type_white", 1, char_type_white, SafePredFlag); + Yap_InitCPred("char_type_digit", 1, char_type_digit, SafePredFlag); + Yap_InitCPred("char_type_xdigit", 1, char_type_xdigit, SafePredFlag); + Yap_InitCPred("char_type_graph", 1, char_type_graph, SafePredFlag); + Yap_InitCPred("char_type_lower", 1, char_type_lower, SafePredFlag); + Yap_InitCPred("char_type_upper", 1, char_type_upper, SafePredFlag); + Yap_InitCPred("char_type_punct", 1, char_type_punct, SafePredFlag); + Yap_InitCPred("char_type_space", 1, char_type_space, SafePredFlag); + Yap_InitCPred("char_type_end_of_file", 1, char_type_end_of_file, + SafePredFlag); + Yap_InitCPred("char_type_end_of_line", 1, char_type_end_of_line, + SafePredFlag); + Yap_InitCPred("char_type_newline", 1, char_type_newline, SafePredFlag); + Yap_InitCPred("char_type_period", 1, char_type_period, SafePredFlag); + Yap_InitCPred("char_type_quote", 1, char_type_quote, SafePredFlag); + Yap_InitCPred("char_type_paren", 1, char_type_paren, SafePredFlag); + Yap_InitCPred("char_type_prolog_var_start", 1, char_type_prolog_var_start, + SafePredFlag); + Yap_InitCPred("char_type_prolog_symbol", 1, char_type_prolog_symbol, + SafePredFlag); + Yap_InitCPred("char_type_prolog_atom_start", 1, + char_type_prolog_atom_start, SafePredFlag); + Yap_InitCPred("char_type_prolog_identifier_continue", 1, + char_type_prolog_identifier_continue, SafePredFlag); + Yap_InitCPred("char_typetype_prolog_symbol", 1, + char_type_prolog_symbol, + SafePredFlag); + Yap_InitCPred("code_type_alnum", 1, code_type_alnum, SafePredFlag); + Yap_InitCPred("code_type_alpha", 1, code_type_alpha, SafePredFlag); + Yap_InitCPred("code_type_csym", 1, code_type_csym, SafePredFlag); + Yap_InitCPred("code_type_csymf", 1, code_type_csymf, SafePredFlag); + Yap_InitCPred("code_type_ascii", 1, code_type_ascii, SafePredFlag); + Yap_InitCPred("code_type_white", 1, code_type_white, SafePredFlag); + Yap_InitCPred("code_type_digit", 1, code_type_digit, SafePredFlag); + Yap_InitCPred("code_type_xdigit", 1, code_type_xdigit, SafePredFlag); + Yap_InitCPred("code_type_graph", 1, code_type_graph, SafePredFlag); + Yap_InitCPred("code_type_lower", 1, code_type_lower, SafePredFlag); + Yap_InitCPred("code_type_upper", 1, code_type_upper, SafePredFlag); + Yap_InitCPred("code_type_punct", 1, code_type_punct, SafePredFlag); + Yap_InitCPred("code_type_space", 1, code_type_space, SafePredFlag); + Yap_InitCPred("code_type_end_of_file", 1, code_type_end_of_file, + SafePredFlag); + Yap_InitCPred("code_type_end_of_line", 1, code_type_end_of_line, + SafePredFlag); + Yap_InitCPred("code_type_newline", 1, code_type_newline, SafePredFlag); + Yap_InitCPred("code_type_period", 1, code_type_period, SafePredFlag); + Yap_InitCPred("code_type_quote", 1, code_type_quote, SafePredFlag); + Yap_InitCPred("code_type_paren", 1, code_type_paren, SafePredFlag); + Yap_InitCPred("code_type_prolog_var_start", 1, + code_type_prolog_var_start, SafePredFlag); + Yap_InitCPred("code_type_prolog_symbol", 1, code_type_prolog_symbol, + SafePredFlag); + Yap_InitCPred("code_type_prolog_atom_start", 1, + code_type_prolog_atom_start, SafePredFlag); + Yap_InitCPred("code_type_prolog_identifier_continue", 1, + code_type_prolog_identifier_continue, SafePredFlag); + Yap_InitCPred("code_type_prolog_symbol", 1, code_type_prolog_symbol, + SafePredFlag); + CurrentModule = PROLOG_MODULE; + } diff --git a/os/chartypes.yap b/os/chartypes.yap index a4771e2bc..acdb8e566 100644 --- a/os/chartypes.yap +++ b/os/chartypes.yap @@ -1,525 +1,1820 @@ +:- module('$char_type',[ + op(1150, fx, block) + %dif/2, + %when/2, + %block/1, + %wait/1, + %frozen/2 + ]). -/************************************************************************* -* * -* YAP Prolog * -* * -* Yap Prolog was developed at NCCUP - Universidade do Porto * -* * -* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 * -* * -************************************************************************** -* * -* File: charcodes.c * -* Last rev: 5/2/88 * -* mods: * -* comments: Character codes and character conversion * -* * -*************************************************************************/ -#ifdef SCCS -static char SccsId[] = "%W% %G%"; -#endif +/** + @defgroup CharacterCodes Character Encoding and Manipulation. + @ingroup TextProcessing + @{ -/* - * This file includes the definition of a pipe related IO. - * - */ +The Prolog library includes a set of built-in predicates designed to +support manipulation of sequences of text, represented either as +lists, atoms or strings. -#include "Yap.h" -#include "Yatom.h" -#include "YapHeap.h" -#include "yapio.h" -#include -#if HAVE_UNISTD_H -#include -#endif -#if HAVE_STDARG_H -#include -#endif -#ifdef _WIN32 -#if HAVE_IO_H -/* Windows */ -#include -#endif -#if HAVE_SOCKET -#include -#endif -#include -#ifndef S_ISDIR -#define S_ISDIR(x) (((x)&_S_IFDIR)==_S_IFDIR) -#endif -#endif -#include "iopreds.h" +The char_type family of predicates support manipulation of individual characters, represented either as numbers (codes) or atoms (chars). -Term - Yap_StringToNumberTerm(char *s, encoding_t enc) -{ - int sno; - Term t; +YAP supports UNICODE through the library utf8proc for compatibility +across operating systems. The implementation extends the original +(ASCII-based) character classification used by early Prologs, but +supports UNICODE.As usual, YAP tried to follow SWI-Prolog as much as +possible: - sno = Yap_open_buf_read_stream(s, strlen(s)+1, MEM_BUF_USER); - if (sno < 0) - return FALSE; - GLOBAL_Stream[sno].encoding = enc; - UNLOCK(GLOBAL_Stream[sno].streamlock); - while(*s && isblank(*s++)); - t = Yap_scan_num(GLOBAL_Stream+sno); - GLOBAL_Stream[sno].status = Free_Stream_f; - if (t == TermNil) { - int sign = 1; - if (s[0] == '+') { - s++; - } - if (s[0] == '-') { - s++; - sign = -1; - } - if(strcmp(s,"inf") == 0) { - if (sign > 0) { - return MkFloatTerm(INFINITY); - } else { - return MkFloatTerm(-INFINITY); - } - } - if(strcmp(s,"nan") == 0) { - if (sign > 0) { - return MkFloatTerm(NAN); - } else { - return MkFloatTerm(-NAN); - } - } - } - return t; -} + + char_type/2 and code_type/2 support all documented SWI-Prolog flags, +but are strict in argument checking. -Term - Yap_StringToTerm(const char *s, size_t len, encoding_t enc, int prio, Term *tp) -{ - int sno = Yap_open_buf_read_stream(s, strlen(s)+1); - Term t; - TokEntry *tokstart; - tr_fr_ptr TR_before_parse; - Term tpos = TermNil; - read_data rd; + + letters with no case are considered as lower-case. Hence, a + variable can only start with an underscore or a unicode point in + category LU. - GLOBAL_Stream[sno].encoding = enc; - init_read_data(&rd, GLOBAL_Stream+sno); - if (sno < 0) - return FALSE; - UNLOCK(GLOBAL_Stream[sno].streamlock); - TR_before_parse = TR; - tokstart = LOCAL_tokptr = LOCAL_toktide = Yap_tokenizer(GLOBAL_Stream+sno, false, &tpos, &rd); - if (tokstart == NIL && tokstart->Tok == Ord (eot_tok)) { - if (tp) { - *tp = MkAtomTerm(AtomEOFBeforeEOT); - } - Yap_clean_tokenizer(tokstart, LOCAL_VarTable, LOCAL_AnonVarTable); - /* cannot actually use CloseStream, because we didn't allocate the buffer */ - GLOBAL_Stream[sno].status = Free_Stream_f; - return FALSE; - } else if (LOCAL_ErrorMessage) { - if (tp) { - *tp = MkAtomTerm(Yap_LookupAtom(LOCAL_ErrorMessage)); - } - Yap_clean_tokenizer(tokstart, LOCAL_VarTable, LOCAL_AnonVarTable); - /* cannot actually use CloseStream, because we didn't allocate the buffer */ - GLOBAL_Stream[sno].status = Free_Stream_f; - return FALSE; - } - t = Yap_Parse(&rd); - TR = TR_before_parse; - if (!t && !LOCAL_ErrorMessage) { - if (tp) { - t = MkVarTerm(); - *tp = syntax_error(tokstart, sno, &t); - } - Yap_clean_tokenizer(tokstart, LOCAL_VarTable, LOCAL_AnonVarTable); - /* cannot actually use CloseStream, because we didn't allocate the buffer */ - GLOBAL_Stream[sno].status = Free_Stream_f; - return FALSE; - } - Yap_clean_tokenizer(tokstart, LOCAL_VarTable, LOCAL_AnonVarTable); - /* cannot actually use CloseStream, because we didn't allocate the buffer */ - GLOBAL_Stream[sno].status = Free_Stream_f; - return t; -} + + number letters are consideed numbers. -char * -Yap_TermToString(Term t, char *s, size_t sz, size_t *length, encoding_t *encp, int flags) -{ - CACHE_REGS - int sno = Yap_open_buf_write_stream(&s, &sz); - if (sno < 0) - return FALSE; - GLOBAL_Stream[sno].encoding = enc; - UNLOCK(GLOBAL_Stream[sno].streamlock); - while(*s && isblank(*s++)); - t = Yap_scan_num(GLOBAL_Stream+sno); - GLOBAL_Stream[sno].status = Free_Stream_f; - if (t == TermNil) { - int sign = 1; - if (s[0] == '+') { - s++; - } - if (s[0] == '-') { - s++; - sign = -1; - } - if(strcmp(s,"inf") == 0) { - if (sign > 0) { - return MkFloatTerm(INFINITY); - } else { - return MkFloatTerm(-INFINITY); - } - } - if(strcmp(s,"nan") == 0) { - if (sign > 0) { - return MkFloatTerm(NAN); - } else { - return MkFloatTerm(-NAN); - } - } - } - return t; -} + + connectors, dashes, are considered solo characters. -Term - Yap_StringToTerm(const char *s, size_t len, encoding_t enc, int prio, Term *tp) -{ - int sno = Yap_open_buf_read_stream(s, strlen(s)+1); - Term t; - TokEntry *tokstart; - tr_fr_ptr TR_before_parse; - Term tpos = TermNil; - read_data rd; + + YAP does currently distinguish opening and closing quotes. - GLOBAL_Stream[sno].encoding = enc; - init_read_data(&rd, GLOBAL_Stream+sno); - if (sno < 0) - return FALSE; - UNLOCK(GLOBAL_Stream[sno].streamlock); - TR_before_parse = TR; - tokstart = LOCAL_tokptr = LOCAL_toktide = Yap_tokenizer(GLOBAL_Stream+sno, false, &tpos, &rd); - if (tokstart == NIL && tokstart->Tok == Ord (eot_tok)) { - if (tp) { - *tp = MkAtomTerm(AtomEOFBeforeEOT); - } - Yap_clean_tokenizer(tokstart, LOCAL_VarTable, LOCAL_AnonVarTable); - /* cannot actually use CloseStream, because we didn't allocate the buffer */ - GLOBAL_Stream[sno].status = Free_Stream_f; - return FALSE; - } else if (LOCAL_ErrorMessage) { - if (tp) { - *tp = MkAtomTerm(Yap_LookupAtom(LOCAL_ErrorMessage)); - } - Yap_clean_tokenizer(tokstart, LOCAL_VarTable, LOCAL_AnonVarTable); - /* cannot actually use CloseStream, because we didn't allocate the buffer */ - GLOBAL_Stream[sno].status = Free_Stream_f; - return FALSE; - } - t = Yap_Parse(&rd); - TR = TR_before_parse; - if (!t && !LOCAL_ErrorMessage) { - if (tp) { - t = MkVarTerm(); - *tp = syntax_error(tokstart, sno, &t); - } - Yap_clean_tokenizer(tokstart, LOCAL_VarTable, LOCAL_AnonVarTable); - /* cannot actually use CloseStream, because we didn't allocate the buffer */ - GLOBAL_Stream[sno].status = Free_Stream_f; - return FALSE; - } - Yap_clean_tokenizer(tokstart, LOCAL_VarTable, LOCAL_AnonVarTable); - /* cannot actually use CloseStream, because we didn't allocate the buffer */ - GLOBAL_Stream[sno].status = Free_Stream_f; - return t; -} + + Symbols are processed as Prolog symbols, exception are modifiers + that are handled as lower-case letters. -char * - Yap_TermToString(Term t, char *s, size_t sz, size_t *length, encoding_t *encp, int flags) -{ - CACHE_REGS - int sno = Yap_open_buf_write_stream(&s, &sz); - int old_output_stream = LOCAL_output_stream; +*/ - if (sno < 0) - return NULL; - LOCAL_output_stream = sno; - if (encp ) - GLOBAL_Stream[sno].encoding = encp; - Yap_plwrite (t, GLOBAL_Stream[sno].stream_wputc, 0, flags, 1200); - LOCK(GLOBAL_Stream[sno].streamlock); - GLOBAL_Stream[sno].status = Free_Stream_f; - UNLOCK(GLOBAL_Stream[sno].streamlock); - LOCAL_output_stream = old_output_stream; - if ( EX == 0 ) return s; - return NULL; -} +/** @predicate char_type(?_Char_ , ?Type) -encoding_t -Yap_DefaultEncoding(void) -{ - return LOCAL_encoding; -} +The character _Char_ has type _Type_. The types included here are +based on SWI-Prolog's documentation, and they include several types +from the C-library. It it is possible for a character to have +different types. -void -Yap_SetDefaultEncoding(encoding_t new_encoding) -{ - LOCAL_encoding = new_encoding; -} + + alnum + Char is a letter (upper- or lowercase) or digit. + + +alpha + Char is a letter (upper- or lowercase). -encoding_t -Yap_InitialEncoding(void) -{ - char *s = getenv("LANG"); - size_t sz; + + csym + Char is a letter (upper- or lowercase), digit or the underscore (_). These are valid C and Prolog symbol characters. - /* if we don't have a LANG then just use ISO_LATIN1 */ - if (s == NULL) - s = getenv("LC_CTYPE"); - if (s == NULL) - return ENC_ISO_LATIN1; - sz = strlen(s); - if (sz >= 5) { - if (s[sz-5] == 'U' && - s[sz-4] == 'T' && - s[sz-3] == 'F' && - s[sz-2] == '-' && - s[sz-1] == '8') { - return ENC_ISO_UTF8; - } - } - return ENC_ISO_ANSI; -} + + csymf +Char is a letter (upper- or lowercase) or the underscore (_). These are valid first characters for C and Prolog symbols. + + + ascii + Char is a 7-bit ASCII character (0..127). + + + white + Char is a space or tab, i.e. white space inside a line. + + + cntrl + Char is an ASCII control character (0..31). + + + digit + Char is a digit. + + + digit(Weight) + Char is a digit with value Weight. I.e. char_type(X, digit(6) yields X = '6'. Useful for parsing numbers. + ++ xdigit(Weight) + Char is a hexadecimal digit with value Weight. I.e. char_type(a, xdigit(X) yields X = '10'. Useful for parsing numbers. + + + graph + Char produces a visible mark on a page when printed. Note that the space is not included! + + + lower + Char is a lowercase letter. + + + lower(Upper) + Char is a lowercase version of Upper. Only true if Char is lowercase and Upper uppercase. + + + to_lower(Upper) + Char is a lowercase version of Upper. For non-letters, or letter without case, Char and Lower are the same. See also upcase_atom/2 and downcase_atom/2. + + + upper + Char is an uppercase letter. + + + upper(Lower) +Char is an uppercase version of Lower. Only true if Char is uppercase and Lower lowercase. + + + to_upper(Lower) + Char is an uppercase version of Lower. For non-letters, or letter without case, Char and Lower are the same. See also upcase_atom/2 and downcase_atom/2. + + + punct + Char is a punctuation character. This is a graph character that is not a letter or digit. + + + space + Char is some form of layout character (tab, vertical tab, newline, etc.). + + + end_of_file + Char is -1. + + + end_of_line + Char ends a line (ASCII: 10..13). + + + newline + Char is a newline character (10). + + + period + Char counts as the end of a sentence (.,!,?). + + + quote + Char is a quote character (", ', `). + + + paren(Close) + Char is an open parenthesis and Close is the corresponding close parenthesis. + + + prolog_var_start + Char can start a Prolog variable name. + + + prolog_atom_start + Char can start a unquoted Prolog atom that is not a symbol. + + + prolog_identifier_continue + Char can continue a Prolog variable name or atom. + + + prolog_prolog_symbol + Char is a Prolog symbol character. Sequences of Prolog symbol characters glue together to form an unquoted atom. Examples are =.., \=, etc. +*/ + +:- discontiguous digit_weight/2, digit_weight/3. + +char_type( CH, TYPE) :- + ( var( CH ) -> between(-1,+inf,CH) ). +char_type( ALNUM, alnum) :- + char_type_alnum( ALNUM ). +char_type( ALPHA, alpha) :- + char_type_alpha( ALPHA). +char_type( CSYM, csym) :- + char_type_csym( CSYM ). +char_type( CSYMF, csymf) :- + char_type_csymf( CSYMF). +char_type( ASCII, ascii ) :- + char_type_ascii( ASCII ). +char_type( WHITE, white) :- + char_type_white( WHITE ). +char_type( CNTRL , cntrl) :- + char_type_cntrl( CNTRL ). +char_type( DIGIT , digit) :- + char_type_digit( DIGIT ). +char_type( DIGIT, digit(Weight) ) :- + char_type_digit( DIGIT ), + digit_weight( DIGIT, Weight ). +char_type( XDIGIT, sdigit(Weight) ) :- + char_type_digit( DIGIT ), + xdigit_weight( DIGIT, Weight ). +char_type( GRAPH , graph) :- + char_type_graph( GRAPH ). +char_type( LOWER , lower) :- + char_type_lower( LOWER ). +char_type( LOWER, lower( Upper)) :- + char_type_lower( LOWER ), + tolower( Upper, LOWER). +char_type( LOWER, to_lower( Upper)) + tolower( Upper, LOWER). +char_type( UPPER, upper ) :- + char_type_upper( upper ). +char_type( UPPER , upper( Lower)) :- + char_type_upper( UPPER ), + toupper( Upper, Lower). +char_type( UPPER, to_upper( Lower) ) :- + toupper( Upper,Lower). +char_type( PUNCT , punct) :- + char_type_punct( PUNCT ). +char_type( SPACE , space) :- + char_type_space( SPACE ). +char_type( END_OF_FILE , end_of_file) :- + char_type_end_of_file( END_OF_FILE ). +char_type( END_OF_LINE , end_of_line) :- + char_type_end_of_line( END_OF_LINE ). +char_type( NEWLINE , newline) :- + char_type( _newline( NEWLINE ). +char_type( PERIOD , period) :- + char_type(_period( PERIOD ). +char_type( QUOTE , quote) :- + char_type_quote( QUOTE ). +char_type( Parent_Open paren( PAREN_CLOSE) ) :- + paren_paren(Parent_Open, PAREN_CLOSE). +char_type( PROLOG_VAR_START , prolog_var_start) :- + char_type_prolog_var_start( PROLOG_VAR_START ). +char_type( PROLOG_ATOM_START , prolog_atom_start) :- + char_type_prolog_atom_start( PROLOG_ATOM_START ). +char_type( PROLOG_IDENTIFIER_CONTINUE , prolog_identifier_continue) :- + char_type_prolog_identifier_continue( PROLOG_IDENTIFIER_CONTINUE ). +char_type( PROLOG_PROLOG_SYMBOL , prolog_prolog_symbol) :- + char_type_prolog_prolog_symbol( PROLOG_PROLOG_SYMBOL ). -static Int -toupper( USES_REGS1 ) -{ - Int out = IntegerOfTerm(Deref(ARG1)), uout; - if (out < 0) { - Yap_Error(REPRESENTATION_ERROR_CHARACTER_CODE, ARG1, "toupper"); - return FALSE; - } - if (out < 128) - uout = toupper(out); - else - uout = towupper(out); - return Yap_unify(ARG2, MkIntegerTerm(uout)); -} +/* numeric code sequences, obtained from +http://www.unicode.org/Public/8.0.0/ucd/extracted/DerivedNumericValues.txt -static Int -tolower( USES_REGS1 ) -{ - Int out = IntegerOfTerm(Deref(ARG1)), uout; - if (out < 0) { - Yap_Error(REPRESENTATION_ERROR_CHARACTER_CODE, ARG1, "tolower"); - return FALSE; - } - if (out < 128) - uout = tolower(out); - else - uout = towlower(out); - return Yap_unify(ARG2, MkIntegerTerm(uout)); -} +by using: -static Int -p_change_type_of_char ( USES_REGS1 ) -{ /* change_type_of_char(+char,+type) */ - Term t1 = Deref (ARG1); - Term t2 = Deref (ARG2); - if (!IsVarTerm (t1) && !IsIntegerTerm (t1)) - return FALSE; - if (!IsVarTerm(t2) && !IsIntegerTerm(t2)) - return FALSE; - Yap_chtype[IntegerOfTerm(t1)] = IntegerOfTerm(t2); - return TRUE; -} + grep '[ \t]\#' DerivedNumericValues.txt | awk '{ print "ch( 0x" $1 ", "$6 ")." }' -static Int -p_type_of_char ( USES_REGS1 ) -{ /* type_of_char(+char,-type) */ - Term t; +*/ - Term t1 = Deref (ARG1); - if (!IsVarTerm (t1) && !IsIntegerTerm (t1)) - return FALSE; - t = MkIntTerm(Yap_chtype[IntegerOfTerm (t1)]); - return Yap_unify(t,ARG2); -} +digit_weight( 0x0F33, -1/2). +digit_weight( 0x0030, 0). +digit_weight( 0x0660, 0). +digit_weight( 0x06F0, 0). +digit_weight( 0x07C0, 0). +digit_weight( 0x0966, 0). +digit_weight( 0x09E6, 0). +digit_weight( 0x0A66, 0). +digit_weight( 0x0AE6, 0). +digit_weight( 0x0B66, 0). +digit_weight( 0x0BE6, 0). +digit_weight( 0x0C66, 0). +digit_weight( 0x0C78, 0). +digit_weight( 0x0CE6, 0). +digit_weight( 0x0D66, 0). +digit_weight( 0x0DE6, 0). +digit_weight( 0x0E50, 0). +digit_weight( 0x0ED0, 0). +digit_weight( 0x0F20, 0). +digit_weight( 0x1040, 0). +digit_weight( 0x1090, 0). +digit_weight( 0x17E0, 0). +digit_weight( 0x17F0, 0). +digit_weight( 0x1810, 0). +digit_weight( 0x1946, 0). +digit_weight( 0x19D0, 0). +digit_weight( 0x1A80, 0). +digit_weight( 0x1A90, 0). +digit_weight( 0x1B50, 0). +digit_weight( 0x1BB0, 0). +digit_weight( 0x1C40, 0). +digit_weight( 0x1C50, 0). +digit_weight( 0x2070, 0). +digit_weight( 0x2080, 0). +digit_weight( 0x2189, 0). +digit_weight( 0x24EA, 0). +digit_weight( 0x24FF, 0). +digit_weight( 0x3007, 0). +digit_weight( 0x96F6, 0). +digit_weight( 0xA620, 0). +digit_weight( 0xA6EF, 0). +digit_weight( 0xA8D0, 0). +digit_weight( 0xA900, 0). +digit_weight( 0xA9D0, 0). +digit_weight( 0xA9F0, 0). +digit_weight( 0xAA50, 0). +digit_weight( 0xABF0, 0). +digit_weight( 0xF9B2, 0). +digit_weight( 0xFF10, 0). +digit_weight( 0x1018A, 0). +digit_weight( 0x104A0, 0). +digit_weight( 0x11066, 0). +digit_weight( 0x110F0, 0). +digit_weight( 0x11136, 0). +digit_weight( 0x111D0, 0). +digit_weight( 0x112F0, 0). +digit_weight( 0x114D0, 0). +digit_weight( 0x11650, 0). +digit_weight( 0x116C0, 0). +digit_weight( 0x11730, 0). +digit_weight( 0x118E0, 0). +digit_weight( 0x16A60, 0). +digit_weight( 0x16B50, 0). +digit_weight( 0x1D7CE, 0). +digit_weight( 0x1D7D8, 0). +digit_weight( 0x1D7E2, 0). +digit_weight( 0x1D7EC, 0). +digit_weight( 0x1D7F6, 0). +digit_weight( 0x1F100, 0x1F101, 0). +digit_weight( 0x1F10B, 0x1F10C, 0). +digit_weight( 0x09F4, 1/16). +digit_weight( 0x0B75, 1/16). +digit_weight( 0xA833, 1/16). +digit_weight( 0x109F6, 1/12). +digit_weight( 0x2152, 1/10). +digit_weight( 0x2151, 1/9). +digit_weight( 0x09F5, 1/8). +digit_weight( 0x0B76, 1/8). +digit_weight( 0x215B, 1/8). +digit_weight( 0xA834, 1/8). +digit_weight( 0x1245F, 1/8). +digit_weight( 0x2150, 1/7). +digit_weight( 0x2159, 1/6). +digit_weight( 0x109F7, 1/6). +digit_weight( 0x12461, 1/6). +digit_weight( 0x09F6, 3/16). +digit_weight( 0x0B77, 3/16). +digit_weight( 0xA835, 3/16). +digit_weight( 0x2155, 1/5). +digit_weight( 0x00BC, 1/4). +digit_weight( 0x09F7, 1/4). +digit_weight( 0x0B72, 1/4). +digit_weight( 0x0D73, 1/4). +digit_weight( 0xA830, 1/4). +digit_weight( 0x10140, 1/4). +digit_weight( 0x1018B, 1/4). +digit_weight( 0x109F8, 1/4). +digit_weight( 0x10E7C, 1/4). +digit_weight( 0x12460, 1/4). +digit_weight( 0x12462, 0x12463, 1/4). +digit_weight( 0x2153, 1/3). +digit_weight( 0x109F9, 1/3). +digit_weight( 0x10E7D, 1/3). +digit_weight( 0x1245A, 1/3). +digit_weight( 0x1245D, 1/3). +digit_weight( 0x12465, 1/3). +digit_weight( 0x215C, 3/8). +digit_weight( 0x2156, 2/5). +digit_weight( 0x109FA, 5/12). +digit_weight( 0x00BD, 1/2). +digit_weight( 0x0B73, 1/2). +digit_weight( 0x0D74, 1/2). +digit_weight( 0x0F2A, 1/2). +digit_weight( 0x2CFD, 1/2). +digit_weight( 0xA831, 1/2). +digit_weight( 0x10141, 1/2). +digit_weight( 0x10175, 0x10176, 1/2). +digit_weight( 0x109BD, 1/2). +digit_weight( 0x109FB, 1/2). +digit_weight( 0x10E7B, 1/2). +digit_weight( 0x12464, 1/2). +digit_weight( 0x109FC, 7/12). +digit_weight( 0x2157, 3/5). +digit_weight( 0x215D, 5/8). +digit_weight( 0x2154, 2/3). +digit_weight( 0x10177, 2/3). +digit_weight( 0x109FD, 2/3). +digit_weight( 0x10E7E, 2/3). +digit_weight( 0x1245B, 2/3). +digit_weight( 0x1245E, 2/3). +digit_weight( 0x12466, 2/3). +digit_weight( 0x00BE, 3/4). +digit_weight( 0x09F8, 3/4). +digit_weight( 0x0B74, 3/4). +digit_weight( 0x0D75, 3/4). +digit_weight( 0xA832, 3/4). +digit_weight( 0x10178, 3/4). +digit_weight( 0x109FE, 3/4). +digit_weight( 0x2158, 4/5). +digit_weight( 0x215A, 5/6). +digit_weight( 0x109FF, 5/6). +digit_weight( 0x1245C, 5/6). +digit_weight( 0x215E, 7/8). +digit_weight( 0x109BC, 11/12). +digit_weight( 0x0031, 1). +digit_weight( 0x00B9, 1). +digit_weight( 0x0661, 1). +digit_weight( 0x06F1, 1). +digit_weight( 0x07C1, 1). +digit_weight( 0x0967, 1). +digit_weight( 0x09E7, 1). +digit_weight( 0x0A67, 1). +digit_weight( 0x0AE7, 1). +digit_weight( 0x0B67, 1). +digit_weight( 0x0BE7, 1). +digit_weight( 0x0C67, 1). +digit_weight( 0x0C79, 1). +digit_weight( 0x0C7C, 1). +digit_weight( 0x0CE7, 1). +digit_weight( 0x0D67, 1). +digit_weight( 0x0DE7, 1). +digit_weight( 0x0E51, 1). +digit_weight( 0x0ED1, 1). +digit_weight( 0x0F21, 1). +digit_weight( 0x1041, 1). +digit_weight( 0x1091, 1). +digit_weight( 0x1369, 1). +digit_weight( 0x17E1, 1). +digit_weight( 0x17F1, 1). +digit_weight( 0x1811, 1). +digit_weight( 0x1947, 1). +digit_weight( 0x19D1, 1). +digit_weight( 0x19DA, 1). +digit_weight( 0x1A81, 1). +digit_weight( 0x1A91, 1). +digit_weight( 0x1B51, 1). +digit_weight( 0x1BB1, 1). +digit_weight( 0x1C41, 1). +digit_weight( 0x1C51, 1). +digit_weight( 0x2081, 1). +digit_weight( 0x215F, 1). +digit_weight( 0x2160, 1). +digit_weight( 0x2170, 1). +digit_weight( 0x2460, 1). +digit_weight( 0x2474, 1). +digit_weight( 0x2488, 1). +digit_weight( 0x24F5, 1). +digit_weight( 0x2776, 1). +digit_weight( 0x2780, 1). +digit_weight( 0x278A, 1). +digit_weight( 0x3021, 1). +digit_weight( 0x3192, 1). +digit_weight( 0x3220, 1). +digit_weight( 0x3280, 1). +digit_weight( 0x4E00, 1). +digit_weight( 0x58F1, 1). +digit_weight( 0x58F9, 1). +digit_weight( 0x5E7A, 1). +digit_weight( 0x5F0C, 1). +digit_weight( 0xA621, 1). +digit_weight( 0xA6E6, 1). +digit_weight( 0xA8D1, 1). +digit_weight( 0xA901, 1). +digit_weight( 0xA9D1, 1). +digit_weight( 0xA9F1, 1). +digit_weight( 0xAA51, 1). +digit_weight( 0xABF1, 1). +digit_weight( 0xFF11, 1). +digit_weight( 0x10107, 1). +digit_weight( 0x10142, 1). +digit_weight( 0x10158, 0x1015A, 1). +digit_weight( 0x102E1, 1). +digit_weight( 0x10320, 1). +digit_weight( 0x103D1, 1). +digit_weight( 0x104A1, 1). +digit_weight( 0x10858, 1). +digit_weight( 0x10879, 1). +digit_weight( 0x108A7, 1). +digit_weight( 0x108FB, 1). +digit_weight( 0x10916, 1). +digit_weight( 0x109C0, 1). +digit_weight( 0x10A40, 1). +digit_weight( 0x10A7D, 1). +digit_weight( 0x10A9D, 1). +digit_weight( 0x10AEB, 1). +digit_weight( 0x10B58, 1). +digit_weight( 0x10B78, 1). +digit_weight( 0x10BA9, 1). +digit_weight( 0x10CFA, 1). +digit_weight( 0x10E60, 1). +digit_weight( 0x11052, 1). +digit_weight( 0x11067, 1). +digit_weight( 0x110F1, 1). +digit_weight( 0x11137, 1). +digit_weight( 0x111D1, 1). +digit_weight( 0x111E1, 1). +digit_weight( 0x112F1, 1). +digit_weight( 0x114D1, 1). +digit_weight( 0x11651, 1). +digit_weight( 0x116C1, 1). +digit_weight( 0x11731, 1). +digit_weight( 0x118E1, 1). +digit_weight( 0x12415, 1). +digit_weight( 0x1241E, 1). +digit_weight( 0x1242C, 1). +digit_weight( 0x12434, 1). +digit_weight( 0x1244F, 1). +digit_weight( 0x12458, 1). +digit_weight( 0x16A61, 1). +digit_weight( 0x16B51, 1). +digit_weight( 0x1D360, 1). +digit_weight( 0x1D7CF, 1). +digit_weight( 0x1D7D9, 1). +digit_weight( 0x1D7E3, 1). +digit_weight( 0x1D7ED, 1). +digit_weight( 0x1D7F7, 1). +digit_weight( 0x1E8C7, 1). +digit_weight( 0x1F102, 1). +digit_weight( 0x2092A, 1). +digit_weight( 0x0F2B, 3/2). +digit_weight( 0x0032, 2). +digit_weight( 0x00B2, 2). +digit_weight( 0x0662, 2). +digit_weight( 0x06F2, 2). +digit_weight( 0x07C2, 2). +digit_weight( 0x0968, 2). +digit_weight( 0x09E8, 2). +digit_weight( 0x0A68, 2). +digit_weight( 0x0AE8, 2). +digit_weight( 0x0B68, 2). +digit_weight( 0x0BE8, 2). +digit_weight( 0x0C68, 2). +digit_weight( 0x0C7A, 2). +digit_weight( 0x0C7D, 2). +digit_weight( 0x0CE8, 2). +digit_weight( 0x0D68, 2). +digit_weight( 0x0DE8, 2). +digit_weight( 0x0E52, 2). +digit_weight( 0x0ED2, 2). +digit_weight( 0x0F22, 2). +digit_weight( 0x1042, 2). +digit_weight( 0x1092, 2). +digit_weight( 0x136A, 2). +digit_weight( 0x17E2, 2). +digit_weight( 0x17F2, 2). +digit_weight( 0x1812, 2). +digit_weight( 0x1948, 2). +digit_weight( 0x19D2, 2). +digit_weight( 0x1A82, 2). +digit_weight( 0x1A92, 2). +digit_weight( 0x1B52, 2). +digit_weight( 0x1BB2, 2). +digit_weight( 0x1C42, 2). +digit_weight( 0x1C52, 2). +digit_weight( 0x2082, 2). +digit_weight( 0x2161, 2). +digit_weight( 0x2171, 2). +digit_weight( 0x2461, 2). +digit_weight( 0x2475, 2). +digit_weight( 0x2489, 2). +digit_weight( 0x24F6, 2). +digit_weight( 0x2777, 2). +digit_weight( 0x2781, 2). +digit_weight( 0x278B, 2). +digit_weight( 0x3022, 2). +digit_weight( 0x3193, 2). +digit_weight( 0x3221, 2). +digit_weight( 0x3281, 2). +digit_weight( 0x3483, 2). +digit_weight( 0x4E8C, 2). +digit_weight( 0x5169, 2). +digit_weight( 0x5F0D, 2). +digit_weight( 0x5F10, 2). +digit_weight( 0x8CAE, 2). +digit_weight( 0x8CB3, 2). +digit_weight( 0x8D30, 2). +digit_weight( 0xA622, 2). +digit_weight( 0xA6E7, 2). +digit_weight( 0xA8D2, 2). +digit_weight( 0xA902, 2). +digit_weight( 0xA9D2, 2). +digit_weight( 0xA9F2, 2). +digit_weight( 0xAA52, 2). +digit_weight( 0xABF2, 2). +digit_weight( 0xF978, 2). +digit_weight( 0xFF12, 2). +digit_weight( 0x10108, 2). +digit_weight( 0x1015B, 0x1015E, 2). +digit_weight( 0x102E2, 2). +digit_weight( 0x103D2, 2). +digit_weight( 0x104A2, 2). +digit_weight( 0x10859, 2). +digit_weight( 0x1087A, 2). +digit_weight( 0x108A8, 2). +digit_weight( 0x1091A, 2). +digit_weight( 0x109C1, 2). +digit_weight( 0x10A41, 2). +digit_weight( 0x10B59, 2). +digit_weight( 0x10B79, 2). +digit_weight( 0x10BAA, 2). +digit_weight( 0x10E61, 2). +digit_weight( 0x11053, 2). +digit_weight( 0x11068, 2). +digit_weight( 0x110F2, 2). +digit_weight( 0x11138, 2). +digit_weight( 0x111D2, 2). +digit_weight( 0x111E2, 2). +digit_weight( 0x112F2, 2). +digit_weight( 0x114D2, 2). +digit_weight( 0x11652, 2). +digit_weight( 0x116C2, 2). +digit_weight( 0x11732, 2). +digit_weight( 0x118E2, 2). +digit_weight( 0x12400, 2). +digit_weight( 0x12416, 2). +digit_weight( 0x1241F, 2). +digit_weight( 0x12423, 2). +digit_weight( 0x1242D, 2). +digit_weight( 0x12435, 2). +digit_weight( 0x1244A, 2). +digit_weight( 0x12450, 2). +digit_weight( 0x12456, 2). +digit_weight( 0x12459, 2). +digit_weight( 0x16A62, 2). +digit_weight( 0x16B52, 2). +digit_weight( 0x1D361, 2). +digit_weight( 0x1D7D0, 2). +digit_weight( 0x1D7DA, 2). +digit_weight( 0x1D7E4, 2). +digit_weight( 0x1D7EE, 2). +digit_weight( 0x1D7F8, 2). +digit_weight( 0x1E8C8, 2). +digit_weight( 0x1F103, 2). +digit_weight( 0x22390, 2). +digit_weight( 0x0F2C, 5/2). +digit_weight( 0x0033, 3). +digit_weight( 0x00B3, 3). +digit_weight( 0x0663, 3). +digit_weight( 0x06F3, 3). +digit_weight( 0x07C3, 3). +digit_weight( 0x0969, 3). +digit_weight( 0x09E9, 3). +digit_weight( 0x0A69, 3). +digit_weight( 0x0AE9, 3). +digit_weight( 0x0B69, 3). +digit_weight( 0x0BE9, 3). +digit_weight( 0x0C69, 3). +digit_weight( 0x0C7B, 3). +digit_weight( 0x0C7E, 3). +digit_weight( 0x0CE9, 3). +digit_weight( 0x0D69, 3). +digit_weight( 0x0DE9, 3). +digit_weight( 0x0E53, 3). +digit_weight( 0x0ED3, 3). +digit_weight( 0x0F23, 3). +digit_weight( 0x1043, 3). +digit_weight( 0x1093, 3). +digit_weight( 0x136B, 3). +digit_weight( 0x17E3, 3). +digit_weight( 0x17F3, 3). +digit_weight( 0x1813, 3). +digit_weight( 0x1949, 3). +digit_weight( 0x19D3, 3). +digit_weight( 0x1A83, 3). +digit_weight( 0x1A93, 3). +digit_weight( 0x1B53, 3). +digit_weight( 0x1BB3, 3). +digit_weight( 0x1C43, 3). +digit_weight( 0x1C53, 3). +digit_weight( 0x2083, 3). +digit_weight( 0x2162, 3). +digit_weight( 0x2172, 3). +digit_weight( 0x2462, 3). +digit_weight( 0x2476, 3). +digit_weight( 0x248A, 3). +digit_weight( 0x24F7, 3). +digit_weight( 0x2778, 3). +digit_weight( 0x2782, 3). +digit_weight( 0x278C, 3). +digit_weight( 0x3023, 3). +digit_weight( 0x3194, 3). +digit_weight( 0x3222, 3). +digit_weight( 0x3282, 3). +digit_weight( 0x4E09, 3). +digit_weight( 0x4EE8, 3). +digit_weight( 0x53C1, 0x53C4, 3). +digit_weight( 0x5F0E, 3). +digit_weight( 0xA623, 3). +digit_weight( 0xA6E8, 3). +digit_weight( 0xA8D3, 3). +digit_weight( 0xA903, 3). +digit_weight( 0xA9D3, 3). +digit_weight( 0xA9F3, 3). +digit_weight( 0xAA53, 3). +digit_weight( 0xABF3, 3). +digit_weight( 0xF96B, 3). +digit_weight( 0xFF13, 3). +digit_weight( 0x10109, 3). +digit_weight( 0x102E3, 3). +digit_weight( 0x104A3, 3). +digit_weight( 0x1085A, 3). +digit_weight( 0x1087B, 3). +digit_weight( 0x108A9, 3). +digit_weight( 0x1091B, 3). +digit_weight( 0x109C2, 3). +digit_weight( 0x10A42, 3). +digit_weight( 0x10B5A, 3). +digit_weight( 0x10B7A, 3). +digit_weight( 0x10BAB, 3). +digit_weight( 0x10E62, 3). +digit_weight( 0x11054, 3). +digit_weight( 0x11069, 3). +digit_weight( 0x110F3, 3). +digit_weight( 0x11139, 3). +digit_weight( 0x111D3, 3). +digit_weight( 0x111E3, 3). +digit_weight( 0x112F3, 3). +digit_weight( 0x114D3, 3). +digit_weight( 0x11653, 3). +digit_weight( 0x116C3, 3). +digit_weight( 0x11733, 3). +digit_weight( 0x118E3, 3). +digit_weight( 0x12401, 3). +digit_weight( 0x12408, 3). +digit_weight( 0x12417, 3). +digit_weight( 0x12420, 3). +digit_weight( 0x12424, 0x12425, 3). +digit_weight( 0x1242E, 0x1242F, 3). +digit_weight( 0x12436, 0x12437, 3). +digit_weight( 0x1243A, 0x1243B, 3). +digit_weight( 0x1244B, 3). +digit_weight( 0x12451, 3). +digit_weight( 0x12457, 3). +digit_weight( 0x16A63, 3). +digit_weight( 0x16B53, 3). +digit_weight( 0x1D362, 3). +digit_weight( 0x1D7D1, 3). +digit_weight( 0x1D7DB, 3). +digit_weight( 0x1D7E5, 3). +digit_weight( 0x1D7EF, 3). +digit_weight( 0x1D7F9, 3). +digit_weight( 0x1E8C9, 3). +digit_weight( 0x1F104, 3). +digit_weight( 0x20AFD, 3). +digit_weight( 0x20B19, 3). +digit_weight( 0x22998, 3). +digit_weight( 0x23B1B, 3). +digit_weight( 0x0F2D, 7/2). +digit_weight( 0x0034, 4). +digit_weight( 0x0664, 4). +digit_weight( 0x06F4, 4). +digit_weight( 0x07C4, 4). +digit_weight( 0x096A, 4). +digit_weight( 0x09EA, 4). +digit_weight( 0x0A6A, 4). +digit_weight( 0x0AEA, 4). +digit_weight( 0x0B6A, 4). +digit_weight( 0x0BEA, 4). +digit_weight( 0x0C6A, 4). +digit_weight( 0x0CEA, 4). +digit_weight( 0x0D6A, 4). +digit_weight( 0x0DEA, 4). +digit_weight( 0x0E54, 4). +digit_weight( 0x0ED4, 4). +digit_weight( 0x0F24, 4). +digit_weight( 0x1044, 4). +digit_weight( 0x1094, 4). +digit_weight( 0x136C, 4). +digit_weight( 0x17E4, 4). +digit_weight( 0x17F4, 4). +digit_weight( 0x1814, 4). +digit_weight( 0x194A, 4). +digit_weight( 0x19D4, 4). +digit_weight( 0x1A84, 4). +digit_weight( 0x1A94, 4). +digit_weight( 0x1B54, 4). +digit_weight( 0x1BB4, 4). +digit_weight( 0x1C44, 4). +digit_weight( 0x1C54, 4). +digit_weight( 0x2074, 4). +digit_weight( 0x2084, 4). +digit_weight( 0x2163, 4). +digit_weight( 0x2173, 4). +digit_weight( 0x2463, 4). +digit_weight( 0x2477, 4). +digit_weight( 0x248B, 4). +digit_weight( 0x24F8, 4). +digit_weight( 0x2779, 4). +digit_weight( 0x2783, 4). +digit_weight( 0x278D, 4). +digit_weight( 0x3024, 4). +digit_weight( 0x3195, 4). +digit_weight( 0x3223, 4). +digit_weight( 0x3283, 4). +digit_weight( 0x4E96, 4). +digit_weight( 0x56DB, 4). +digit_weight( 0x8086, 4). +digit_weight( 0xA624, 4). +digit_weight( 0xA6E9, 4). +digit_weight( 0xA8D4, 4). +digit_weight( 0xA904, 4). +digit_weight( 0xA9D4, 4). +digit_weight( 0xA9F4, 4). +digit_weight( 0xAA54, 4). +digit_weight( 0xABF4, 4). +digit_weight( 0xFF14, 4). +digit_weight( 0x1010A, 4). +digit_weight( 0x102E4, 4). +digit_weight( 0x104A4, 4). +digit_weight( 0x1087C, 4). +digit_weight( 0x108AA, 0x108AB, 4). +digit_weight( 0x109C3, 4). +digit_weight( 0x10A43, 4). +digit_weight( 0x10B5B, 4). +digit_weight( 0x10B7B, 4). +digit_weight( 0x10BAC, 4). +digit_weight( 0x10E63, 4). +digit_weight( 0x11055, 4). +digit_weight( 0x1106A, 4). +digit_weight( 0x110F4, 4). +digit_weight( 0x1113A, 4). +digit_weight( 0x111D4, 4). +digit_weight( 0x111E4, 4). +digit_weight( 0x112F4, 4). +digit_weight( 0x114D4, 4). +digit_weight( 0x11654, 4). +digit_weight( 0x116C4, 4). +digit_weight( 0x11734, 4). +digit_weight( 0x118E4, 4). +digit_weight( 0x12402, 4). +digit_weight( 0x12409, 4). +digit_weight( 0x1240F, 4). +digit_weight( 0x12418, 4). +digit_weight( 0x12421, 4). +digit_weight( 0x12426, 4). +digit_weight( 0x12430, 4). +digit_weight( 0x12438, 4). +digit_weight( 0x1243C, 0x1243F, 4). +digit_weight( 0x1244C, 4). +digit_weight( 0x12452, 0x12453, 4). +digit_weight( 0x12469, 4). +digit_weight( 0x16A64, 4). +digit_weight( 0x16B54, 4). +digit_weight( 0x1D363, 4). +digit_weight( 0x1D7D2, 4). +digit_weight( 0x1D7DC, 4). +digit_weight( 0x1D7E6, 4). +digit_weight( 0x1D7F0, 4). +digit_weight( 0x1D7FA, 4). +digit_weight( 0x1E8CA, 4). +digit_weight( 0x1F105, 4). +digit_weight( 0x20064, 4). +digit_weight( 0x200E2, 4). +digit_weight( 0x2626D, 4). +digit_weight( 0x0F2E, 9/2). +digit_weight( 0x0035, 5). +digit_weight( 0x0665, 5). +digit_weight( 0x06F5, 5). +digit_weight( 0x07C5, 5). +digit_weight( 0x096B, 5). +digit_weight( 0x09EB, 5). +digit_weight( 0x0A6B, 5). +digit_weight( 0x0AEB, 5). +digit_weight( 0x0B6B, 5). +digit_weight( 0x0BEB, 5). +digit_weight( 0x0C6B, 5). +digit_weight( 0x0CEB, 5). +digit_weight( 0x0D6B, 5). +digit_weight( 0x0DEB, 5). +digit_weight( 0x0E55, 5). +digit_weight( 0x0ED5, 5). +digit_weight( 0x0F25, 5). +digit_weight( 0x1045, 5). +digit_weight( 0x1095, 5). +digit_weight( 0x136D, 5). +digit_weight( 0x17E5, 5). +digit_weight( 0x17F5, 5). +digit_weight( 0x1815, 5). +digit_weight( 0x194B, 5). +digit_weight( 0x19D5, 5). +digit_weight( 0x1A85, 5). +digit_weight( 0x1A95, 5). +digit_weight( 0x1B55, 5). +digit_weight( 0x1BB5, 5). +digit_weight( 0x1C45, 5). +digit_weight( 0x1C55, 5). +digit_weight( 0x2075, 5). +digit_weight( 0x2085, 5). +digit_weight( 0x2164, 5). +digit_weight( 0x2174, 5). +digit_weight( 0x2464, 5). +digit_weight( 0x2478, 5). +digit_weight( 0x248C, 5). +digit_weight( 0x24F9, 5). +digit_weight( 0x277A, 5). +digit_weight( 0x2784, 5). +digit_weight( 0x278E, 5). +digit_weight( 0x3025, 5). +digit_weight( 0x3224, 5). +digit_weight( 0x3284, 5). +digit_weight( 0x3405, 5). +digit_weight( 0x382A, 5). +digit_weight( 0x4E94, 5). +digit_weight( 0x4F0D, 5). +digit_weight( 0xA625, 5). +digit_weight( 0xA6EA, 5). +digit_weight( 0xA8D5, 5). +digit_weight( 0xA905, 5). +digit_weight( 0xA9D5, 5). +digit_weight( 0xA9F5, 5). +digit_weight( 0xAA55, 5). +digit_weight( 0xABF5, 5). +digit_weight( 0xFF15, 5). +digit_weight( 0x1010B, 5). +digit_weight( 0x10143, 5). +digit_weight( 0x10148, 5). +digit_weight( 0x1014F, 5). +digit_weight( 0x1015F, 5). +digit_weight( 0x10173, 5). +digit_weight( 0x102E5, 5). +digit_weight( 0x10321, 5). +digit_weight( 0x104A5, 5). +digit_weight( 0x1087D, 5). +digit_weight( 0x108AC, 5). +digit_weight( 0x108FC, 5). +digit_weight( 0x109C4, 5). +digit_weight( 0x10AEC, 5). +digit_weight( 0x10CFB, 5). +digit_weight( 0x10E64, 5). +digit_weight( 0x11056, 5). +digit_weight( 0x1106B, 5). +digit_weight( 0x110F5, 5). +digit_weight( 0x1113B, 5). +digit_weight( 0x111D5, 5). +digit_weight( 0x111E5, 5). +digit_weight( 0x112F5, 5). +digit_weight( 0x114D5, 5). +digit_weight( 0x11655, 5). +digit_weight( 0x116C5, 5). +digit_weight( 0x11735, 5). +digit_weight( 0x118E5, 5). +digit_weight( 0x12403, 5). +digit_weight( 0x1240A, 5). +digit_weight( 0x12410, 5). +digit_weight( 0x12419, 5). +digit_weight( 0x12422, 5). +digit_weight( 0x12427, 5). +digit_weight( 0x12431, 5). +digit_weight( 0x12439, 5). +digit_weight( 0x1244D, 5). +digit_weight( 0x12454, 0x12455, 5). +digit_weight( 0x1246A, 5). +digit_weight( 0x16A65, 5). +digit_weight( 0x16B55, 5). +digit_weight( 0x1D364, 5). +digit_weight( 0x1D7D3, 5). +digit_weight( 0x1D7DD, 5). +digit_weight( 0x1D7E7, 5). +digit_weight( 0x1D7F1, 5). +digit_weight( 0x1D7FB, 5). +digit_weight( 0x1E8CB, 5). +digit_weight( 0x1F106, 5). +digit_weight( 0x20121, 5). +digit_weight( 0x0F2F, 11/2). +digit_weight( 0x0036, 6). +digit_weight( 0x0666, 6). +digit_weight( 0x06F6, 6). +digit_weight( 0x07C6, 6). +digit_weight( 0x096C, 6). +digit_weight( 0x09EC, 6). +digit_weight( 0x0A6C, 6). +digit_weight( 0x0AEC, 6). +digit_weight( 0x0B6C, 6). +digit_weight( 0x0BEC, 6). +digit_weight( 0x0C6C, 6). +digit_weight( 0x0CEC, 6). +digit_weight( 0x0D6C, 6). +digit_weight( 0x0DEC, 6). +digit_weight( 0x0E56, 6). +digit_weight( 0x0ED6, 6). +digit_weight( 0x0F26, 6). +digit_weight( 0x1046, 6). +digit_weight( 0x1096, 6). +digit_weight( 0x136E, 6). +digit_weight( 0x17E6, 6). +digit_weight( 0x17F6, 6). +digit_weight( 0x1816, 6). +digit_weight( 0x194C, 6). +digit_weight( 0x19D6, 6). +digit_weight( 0x1A86, 6). +digit_weight( 0x1A96, 6). +digit_weight( 0x1B56, 6). +digit_weight( 0x1BB6, 6). +digit_weight( 0x1C46, 6). +digit_weight( 0x1C56, 6). +digit_weight( 0x2076, 6). +digit_weight( 0x2086, 6). +digit_weight( 0x2165, 6). +digit_weight( 0x2175, 6). +digit_weight( 0x2185, 6). +digit_weight( 0x2465, 6). +digit_weight( 0x2479, 6). +digit_weight( 0x248D, 6). +digit_weight( 0x24FA, 6). +digit_weight( 0x277B, 6). +digit_weight( 0x2785, 6). +digit_weight( 0x278F, 6). +digit_weight( 0x3026, 6). +digit_weight( 0x3225, 6). +digit_weight( 0x3285, 6). +digit_weight( 0x516D, 6). +digit_weight( 0x9646, 6). +digit_weight( 0x9678, 6). +digit_weight( 0xA626, 6). +digit_weight( 0xA6EB, 6). +digit_weight( 0xA8D6, 6). +digit_weight( 0xA906, 6). +digit_weight( 0xA9D6, 6). +digit_weight( 0xA9F6, 6). +digit_weight( 0xAA56, 6). +digit_weight( 0xABF6, 6). +digit_weight( 0xF9D1, 6). +digit_weight( 0xF9D3, 6). +digit_weight( 0xFF16, 6). +digit_weight( 0x1010C, 6). +digit_weight( 0x102E6, 6). +digit_weight( 0x104A6, 6). +digit_weight( 0x109C5, 6). +digit_weight( 0x10E65, 6). +digit_weight( 0x11057, 6). +digit_weight( 0x1106C, 6). +digit_weight( 0x110F6, 6). +digit_weight( 0x1113C, 6). +digit_weight( 0x111D6, 6). +digit_weight( 0x111E6, 6). +digit_weight( 0x112F6, 6). +digit_weight( 0x114D6, 6). +digit_weight( 0x11656, 6). +digit_weight( 0x116C6, 6). +digit_weight( 0x11736, 6). +digit_weight( 0x118E6, 6). +digit_weight( 0x12404, 6). +digit_weight( 0x1240B, 6). +digit_weight( 0x12411, 6). +digit_weight( 0x1241A, 6). +digit_weight( 0x12428, 6). +digit_weight( 0x12440, 6). +digit_weight( 0x1244E, 6). +digit_weight( 0x1246B, 6). +digit_weight( 0x16A66, 6). +digit_weight( 0x16B56, 6). +digit_weight( 0x1D365, 6). +digit_weight( 0x1D7D4, 6). +digit_weight( 0x1D7DE, 6). +digit_weight( 0x1D7E8, 6). +digit_weight( 0x1D7F2, 6). +digit_weight( 0x1D7FC, 6). +digit_weight( 0x1E8CC, 6). +digit_weight( 0x1F107, 6). +digit_weight( 0x20AEA, 6). +digit_weight( 0x0F30, 13/2). +digit_weight( 0x0037, 7). +digit_weight( 0x0667, 7). +digit_weight( 0x06F7, 7). +digit_weight( 0x07C7, 7). +digit_weight( 0x096D, 7). +digit_weight( 0x09ED, 7). +digit_weight( 0x0A6D, 7). +digit_weight( 0x0AED, 7). +digit_weight( 0x0B6D, 7). +digit_weight( 0x0BED, 7). +digit_weight( 0x0C6D, 7). +digit_weight( 0x0CED, 7). +digit_weight( 0x0D6D, 7). +digit_weight( 0x0DED, 7). +digit_weight( 0x0E57, 7). +digit_weight( 0x0ED7, 7). +digit_weight( 0x0F27, 7). +digit_weight( 0x1047, 7). +digit_weight( 0x1097, 7). +digit_weight( 0x136F, 7). +digit_weight( 0x17E7, 7). +digit_weight( 0x17F7, 7). +digit_weight( 0x1817, 7). +digit_weight( 0x194D, 7). +digit_weight( 0x19D7, 7). +digit_weight( 0x1A87, 7). +digit_weight( 0x1A97, 7). +digit_weight( 0x1B57, 7). +digit_weight( 0x1BB7, 7). +digit_weight( 0x1C47, 7). +digit_weight( 0x1C57, 7). +digit_weight( 0x2077, 7). +digit_weight( 0x2087, 7). +digit_weight( 0x2166, 7). +digit_weight( 0x2176, 7). +digit_weight( 0x2466, 7). +digit_weight( 0x247A, 7). +digit_weight( 0x248E, 7). +digit_weight( 0x24FB, 7). +digit_weight( 0x277C, 7). +digit_weight( 0x2786, 7). +digit_weight( 0x2790, 7). +digit_weight( 0x3027, 7). +digit_weight( 0x3226, 7). +digit_weight( 0x3286, 7). +digit_weight( 0x3B4D, 7). +digit_weight( 0x4E03, 7). +digit_weight( 0x67D2, 7). +digit_weight( 0x6F06, 7). +digit_weight( 0xA627, 7). +digit_weight( 0xA6EC, 7). +digit_weight( 0xA8D7, 7). +digit_weight( 0xA907, 7). +digit_weight( 0xA9D7, 7). +digit_weight( 0xA9F7, 7). +digit_weight( 0xAA57, 7). +digit_weight( 0xABF7, 7). +digit_weight( 0xFF17, 7). +digit_weight( 0x1010D, 7). +digit_weight( 0x102E7, 7). +digit_weight( 0x104A7, 7). +digit_weight( 0x109C6, 7). +digit_weight( 0x10E66, 7). +digit_weight( 0x11058, 7). +digit_weight( 0x1106D, 7). +digit_weight( 0x110F7, 7). +digit_weight( 0x1113D, 7). +digit_weight( 0x111D7, 7). +digit_weight( 0x111E7, 7). +digit_weight( 0x112F7, 7). +digit_weight( 0x114D7, 7). +digit_weight( 0x11657, 7). +digit_weight( 0x116C7, 7). +digit_weight( 0x11737, 7). +digit_weight( 0x118E7, 7). +digit_weight( 0x12405, 7). +digit_weight( 0x1240C, 7). +digit_weight( 0x12412, 7). +digit_weight( 0x1241B, 7). +digit_weight( 0x12429, 7). +digit_weight( 0x12441, 0x12443, 7). +digit_weight( 0x1246C, 7). +digit_weight( 0x16A67, 7). +digit_weight( 0x16B57, 7). +digit_weight( 0x1D366, 7). +digit_weight( 0x1D7D5, 7). +digit_weight( 0x1D7DF, 7). +digit_weight( 0x1D7E9, 7). +digit_weight( 0x1D7F3, 7). +digit_weight( 0x1D7FD, 7). +digit_weight( 0x1E8CD, 7). +digit_weight( 0x1F108, 7). +digit_weight( 0x20001, 7). +digit_weight( 0x0F31, 15/2). +digit_weight( 0x0038, 8). +digit_weight( 0x0668, 8). +digit_weight( 0x06F8, 8). +digit_weight( 0x07C8, 8). +digit_weight( 0x096E, 8). +digit_weight( 0x09EE, 8). +digit_weight( 0x0A6E, 8). +digit_weight( 0x0AEE, 8). +digit_weight( 0x0B6E, 8). +digit_weight( 0x0BEE, 8). +digit_weight( 0x0C6E, 8). +digit_weight( 0x0CEE, 8). +digit_weight( 0x0D6E, 8). +digit_weight( 0x0DEE, 8). +digit_weight( 0x0E58, 8). +digit_weight( 0x0ED8, 8). +digit_weight( 0x0F28, 8). +digit_weight( 0x1048, 8). +digit_weight( 0x1098, 8). +digit_weight( 0x1370, 8). +digit_weight( 0x17E8, 8). +digit_weight( 0x17F8, 8). +digit_weight( 0x1818, 8). +digit_weight( 0x194E, 8). +digit_weight( 0x19D8, 8). +digit_weight( 0x1A88, 8). +digit_weight( 0x1A98, 8). +digit_weight( 0x1B58, 8). +digit_weight( 0x1BB8, 8). +digit_weight( 0x1C48, 8). +digit_weight( 0x1C58, 8). +digit_weight( 0x2078, 8). +digit_weight( 0x2088, 8). +digit_weight( 0x2167, 8). +digit_weight( 0x2177, 8). +digit_weight( 0x2467, 8). +digit_weight( 0x247B, 8). +digit_weight( 0x248F, 8). +digit_weight( 0x24FC, 8). +digit_weight( 0x277D, 8). +digit_weight( 0x2787, 8). +digit_weight( 0x2791, 8). +digit_weight( 0x3028, 8). +digit_weight( 0x3227, 8). +digit_weight( 0x3287, 8). +digit_weight( 0x516B, 8). +digit_weight( 0x634C, 8). +digit_weight( 0xA628, 8). +digit_weight( 0xA6ED, 8). +digit_weight( 0xA8D8, 8). +digit_weight( 0xA908, 8). +digit_weight( 0xA9D8, 8). +digit_weight( 0xA9F8, 8). +digit_weight( 0xAA58, 8). +digit_weight( 0xABF8, 8). +digit_weight( 0xFF18, 8). +digit_weight( 0x1010E, 8). +digit_weight( 0x102E8, 8). +digit_weight( 0x104A8, 8). +digit_weight( 0x109C7, 8). +digit_weight( 0x10E67, 8). +digit_weight( 0x11059, 8). +digit_weight( 0x1106E, 8). +digit_weight( 0x110F8, 8). +digit_weight( 0x1113E, 8). +digit_weight( 0x111D8, 8). +digit_weight( 0x111E8, 8). +digit_weight( 0x112F8, 8). +digit_weight( 0x114D8, 8). +digit_weight( 0x11658, 8). +digit_weight( 0x116C8, 8). +digit_weight( 0x11738, 8). +digit_weight( 0x118E8, 8). +digit_weight( 0x12406, 8). +digit_weight( 0x1240D, 8). +digit_weight( 0x12413, 8). +digit_weight( 0x1241C, 8). +digit_weight( 0x1242A, 8). +digit_weight( 0x12444, 0x12445, 8). +digit_weight( 0x1246D, 8). +digit_weight( 0x16A68, 8). +digit_weight( 0x16B58, 8). +digit_weight( 0x1D367, 8). +digit_weight( 0x1D7D6, 8). +digit_weight( 0x1D7E0, 8). +digit_weight( 0x1D7EA, 8). +digit_weight( 0x1D7F4, 8). +digit_weight( 0x1D7FE, 8). +digit_weight( 0x1E8CE, 8). +digit_weight( 0x1F109, 8). +digit_weight( 0x0F32, 17/2). +digit_weight( 0x0039, 9). +digit_weight( 0x0669, 9). +digit_weight( 0x06F9, 9). +digit_weight( 0x07C9, 9). +digit_weight( 0x096F, 9). +digit_weight( 0x09EF, 9). +digit_weight( 0x0A6F, 9). +digit_weight( 0x0AEF, 9). +digit_weight( 0x0B6F, 9). +digit_weight( 0x0BEF, 9). +digit_weight( 0x0C6F, 9). +digit_weight( 0x0CEF, 9). +digit_weight( 0x0D6F, 9). +digit_weight( 0x0DEF, 9). +digit_weight( 0x0E59, 9). +digit_weight( 0x0ED9, 9). +digit_weight( 0x0F29, 9). +digit_weight( 0x1049, 9). +digit_weight( 0x1099, 9). +digit_weight( 0x1371, 9). +digit_weight( 0x17E9, 9). +digit_weight( 0x17F9, 9). +digit_weight( 0x1819, 9). +digit_weight( 0x194F, 9). +digit_weight( 0x19D9, 9). +digit_weight( 0x1A89, 9). +digit_weight( 0x1A99, 9). +digit_weight( 0x1B59, 9). +digit_weight( 0x1BB9, 9). +digit_weight( 0x1C49, 9). +digit_weight( 0x1C59, 9). +digit_weight( 0x2079, 9). +digit_weight( 0x2089, 9). +digit_weight( 0x2168, 9). +digit_weight( 0x2178, 9). +digit_weight( 0x2468, 9). +digit_weight( 0x247C, 9). +digit_weight( 0x2490, 9). +digit_weight( 0x24FD, 9). +digit_weight( 0x277E, 9). +digit_weight( 0x2788, 9). +digit_weight( 0x2792, 9). +digit_weight( 0x3029, 9). +digit_weight( 0x3228, 9). +digit_weight( 0x3288, 9). +digit_weight( 0x4E5D, 9). +digit_weight( 0x5EFE, 9). +digit_weight( 0x7396, 9). +digit_weight( 0xA629, 9). +digit_weight( 0xA6EE, 9). +digit_weight( 0xA8D9, 9). +digit_weight( 0xA909, 9). +digit_weight( 0xA9D9, 9). +digit_weight( 0xA9F9, 9). +digit_weight( 0xAA59, 9). +digit_weight( 0xABF9, 9). +digit_weight( 0xFF19, 9). +digit_weight( 0x1010F, 9). +digit_weight( 0x102E9, 9). +digit_weight( 0x104A9, 9). +digit_weight( 0x109C8, 9). +digit_weight( 0x10E68, 9). +digit_weight( 0x1105A, 9). +digit_weight( 0x1106F, 9). +digit_weight( 0x110F9, 9). +digit_weight( 0x1113F, 9). +digit_weight( 0x111D9, 9). +digit_weight( 0x111E9, 9). +digit_weight( 0x112F9, 9). +digit_weight( 0x114D9, 9). +digit_weight( 0x11659, 9). +digit_weight( 0x116C9, 9). +digit_weight( 0x11739, 9). +digit_weight( 0x118E9, 9). +digit_weight( 0x12407, 9). +digit_weight( 0x1240E, 9). +digit_weight( 0x12414, 9). +digit_weight( 0x1241D, 9). +digit_weight( 0x1242B, 9). +digit_weight( 0x12446, 0x12449, 9). +digit_weight( 0x1246E, 9). +digit_weight( 0x16A69, 9). +digit_weight( 0x16B59, 9). +digit_weight( 0x1D368, 9). +digit_weight( 0x1D7D7, 9). +digit_weight( 0x1D7E1, 9). +digit_weight( 0x1D7EB, 9). +digit_weight( 0x1D7F5, 9). +digit_weight( 0x1D7FF, 9). +digit_weight( 0x1E8CF, 9). +digit_weight( 0x1F10A, 9). +digit_weight( 0x2F890, 9). +digit_weight( 0x0BF0, 10). +digit_weight( 0x0D70, 10). +digit_weight( 0x1372, 10). +digit_weight( 0x2169, 10). +digit_weight( 0x2179, 10). +digit_weight( 0x2469, 10). +digit_weight( 0x247D, 10). +digit_weight( 0x2491, 10). +digit_weight( 0x24FE, 10). +digit_weight( 0x277F, 10). +digit_weight( 0x2789, 10). +digit_weight( 0x2793, 10). +digit_weight( 0x3038, 10). +digit_weight( 0x3229, 10). +digit_weight( 0x3248, 10). +digit_weight( 0x3289, 10). +digit_weight( 0x4EC0, 10). +digit_weight( 0x5341, 10). +digit_weight( 0x62FE, 10). +digit_weight( 0xF973, 10). +digit_weight( 0xF9FD, 10). +digit_weight( 0x10110, 10). +digit_weight( 0x10149, 10). +digit_weight( 0x10150, 10). +digit_weight( 0x10157, 10). +digit_weight( 0x10160, 0x10164, 10). +digit_weight( 0x102EA, 10). +digit_weight( 0x10322, 10). +digit_weight( 0x103D3, 10). +digit_weight( 0x1085B, 10). +digit_weight( 0x1087E, 10). +digit_weight( 0x108AD, 10). +digit_weight( 0x108FD, 10). +digit_weight( 0x10917, 10). +digit_weight( 0x109C9, 10). +digit_weight( 0x10A44, 10). +digit_weight( 0x10A9E, 10). +digit_weight( 0x10AED, 10). +digit_weight( 0x10B5C, 10). +digit_weight( 0x10B7C, 10). +digit_weight( 0x10BAD, 10). +digit_weight( 0x10CFC, 10). +digit_weight( 0x10E69, 10). +digit_weight( 0x1105B, 10). +digit_weight( 0x111EA, 10). +digit_weight( 0x1173A, 10). +digit_weight( 0x118EA, 10). +digit_weight( 0x16B5B, 10). +digit_weight( 0x1D369, 10). +digit_weight( 0x216A, 11). +digit_weight( 0x217A, 11). +digit_weight( 0x246A, 11). +digit_weight( 0x247E, 11). +digit_weight( 0x2492, 11). +digit_weight( 0x24EB, 11). +digit_weight( 0x216B, 12). +digit_weight( 0x217B, 12). +digit_weight( 0x246B, 12). +digit_weight( 0x247F, 12). +digit_weight( 0x2493, 12). +digit_weight( 0x24EC, 12). +digit_weight( 0x246C, 13). +digit_weight( 0x2480, 13). +digit_weight( 0x2494, 13). +digit_weight( 0x24ED, 13). +digit_weight( 0x246D, 14). +digit_weight( 0x2481, 14). +digit_weight( 0x2495, 14). +digit_weight( 0x24EE, 14). +digit_weight( 0x246E, 15). +digit_weight( 0x2482, 15). +digit_weight( 0x2496, 15). +digit_weight( 0x24EF, 15). +digit_weight( 0x09F9, 16). +digit_weight( 0x246F, 16). +digit_weight( 0x2483, 16). +digit_weight( 0x2497, 16). +digit_weight( 0x24F0, 16). +digit_weight( 0x16EE, 17). +digit_weight( 0x2470, 17). +digit_weight( 0x2484, 17). +digit_weight( 0x2498, 17). +digit_weight( 0x24F1, 17). +digit_weight( 0x16EF, 18). +digit_weight( 0x2471, 18). +digit_weight( 0x2485, 18). +digit_weight( 0x2499, 18). +digit_weight( 0x24F2, 18). +digit_weight( 0x16F0, 19). +digit_weight( 0x2472, 19). +digit_weight( 0x2486, 19). +digit_weight( 0x249A, 19). +digit_weight( 0x24F3, 19). +digit_weight( 0x1373, 20). +digit_weight( 0x2473, 20). +digit_weight( 0x2487, 20). +digit_weight( 0x249B, 20). +digit_weight( 0x24F4, 20). +digit_weight( 0x3039, 20). +digit_weight( 0x3249, 20). +digit_weight( 0x5344, 20). +digit_weight( 0x5EFF, 20). +digit_weight( 0x10111, 20). +digit_weight( 0x102EB, 20). +digit_weight( 0x103D4, 20). +digit_weight( 0x1085C, 20). +digit_weight( 0x1087F, 20). +digit_weight( 0x108AE, 20). +digit_weight( 0x108FE, 20). +digit_weight( 0x10918, 20). +digit_weight( 0x109CA, 20). +digit_weight( 0x10A45, 20). +digit_weight( 0x10A9F, 20). +digit_weight( 0x10AEE, 20). +digit_weight( 0x10B5D, 20). +digit_weight( 0x10B7D, 20). +digit_weight( 0x10BAE, 20). +digit_weight( 0x10E6A, 20). +digit_weight( 0x1105C, 20). +digit_weight( 0x111EB, 20). +digit_weight( 0x1173B, 20). +digit_weight( 0x118EB, 20). +digit_weight( 0x1D36A, 20). +digit_weight( 0x3251, 21). +digit_weight( 0x3252, 22). +digit_weight( 0x3253, 23). +digit_weight( 0x3254, 24). +digit_weight( 0x3255, 25). +digit_weight( 0x3256, 26). +digit_weight( 0x3257, 27). +digit_weight( 0x3258, 28). +digit_weight( 0x3259, 29). +digit_weight( 0x1374, 30). +digit_weight( 0x303A, 30). +digit_weight( 0x324A, 30). +digit_weight( 0x325A, 30). +digit_weight( 0x5345, 30). +digit_weight( 0x10112, 30). +digit_weight( 0x10165, 30). +digit_weight( 0x102EC, 30). +digit_weight( 0x109CB, 30). +digit_weight( 0x10E6B, 30). +digit_weight( 0x1105D, 30). +digit_weight( 0x111EC, 30). +digit_weight( 0x118EC, 30). +digit_weight( 0x1D36B, 30). +digit_weight( 0x20983, 30). +digit_weight( 0x325B, 31). +digit_weight( 0x325C, 32). +digit_weight( 0x325D, 33). +digit_weight( 0x325E, 34). +digit_weight( 0x325F, 35). +digit_weight( 0x32B1, 36). +digit_weight( 0x32B2, 37). +digit_weight( 0x32B3, 38). +digit_weight( 0x32B4, 39). +digit_weight( 0x1375, 40). +digit_weight( 0x324B, 40). +digit_weight( 0x32B5, 40). +digit_weight( 0x534C, 40). +digit_weight( 0x10113, 40). +digit_weight( 0x102ED, 40). +digit_weight( 0x109CC, 40). +digit_weight( 0x10E6C, 40). +digit_weight( 0x1105E, 40). +digit_weight( 0x111ED, 40). +digit_weight( 0x118ED, 40). +digit_weight( 0x12467, 40). +digit_weight( 0x1D36C, 40). +digit_weight( 0x2098C, 40). +digit_weight( 0x2099C, 40). +digit_weight( 0x32B6, 41). +digit_weight( 0x32B7, 42). +digit_weight( 0x32B8, 43). +digit_weight( 0x32B9, 44). +digit_weight( 0x32BA, 45). +digit_weight( 0x32BB, 46). +digit_weight( 0x32BC, 47). +digit_weight( 0x32BD, 48). +digit_weight( 0x32BE, 49). +digit_weight( 0x1376, 50). +digit_weight( 0x216C, 50). +digit_weight( 0x217C, 50). +digit_weight( 0x2186, 50). +digit_weight( 0x324C, 50). +digit_weight( 0x32BF, 50). +digit_weight( 0x10114, 50). +digit_weight( 0x10144, 50). +digit_weight( 0x1014A, 50). +digit_weight( 0x10151, 50). +digit_weight( 0x10166, 0x10169, 50). +digit_weight( 0x10174, 50). +digit_weight( 0x102EE, 50). +digit_weight( 0x10323, 50). +digit_weight( 0x109CD, 50). +digit_weight( 0x10A7E, 50). +digit_weight( 0x10CFD, 50). +digit_weight( 0x10E6D, 50). +digit_weight( 0x1105F, 50). +digit_weight( 0x111EE, 50). +digit_weight( 0x118EE, 50). +digit_weight( 0x12468, 50). +digit_weight( 0x1D36D, 50). +digit_weight( 0x1377, 60). +digit_weight( 0x324D, 60). +digit_weight( 0x10115, 60). +digit_weight( 0x102EF, 60). +digit_weight( 0x109CE, 60). +digit_weight( 0x10E6E, 60). +digit_weight( 0x11060, 60). +digit_weight( 0x111EF, 60). +digit_weight( 0x118EF, 60). +digit_weight( 0x1D36E, 60). +digit_weight( 0x1378, 70). +digit_weight( 0x324E, 70). +digit_weight( 0x10116, 70). +digit_weight( 0x102F0, 70). +digit_weight( 0x109CF, 70). +digit_weight( 0x10E6F, 70). +digit_weight( 0x11061, 70). +digit_weight( 0x111F0, 70). +digit_weight( 0x118F0, 70). +digit_weight( 0x1D36F, 70). +digit_weight( 0x1379, 80). +digit_weight( 0x324F, 80). +digit_weight( 0x10117, 80). +digit_weight( 0x102F1, 80). +digit_weight( 0x10E70, 80). +digit_weight( 0x11062, 80). +digit_weight( 0x111F1, 80). +digit_weight( 0x118F1, 80). +digit_weight( 0x1D370, 80). +digit_weight( 0x137A, 90). +digit_weight( 0x10118, 90). +digit_weight( 0x102F2, 90). +digit_weight( 0x10341, 90). +digit_weight( 0x10E71, 90). +digit_weight( 0x11063, 90). +digit_weight( 0x111F2, 90). +digit_weight( 0x118F2, 90). +digit_weight( 0x1D371, 90). +digit_weight( 0x0BF1, 100). +digit_weight( 0x0D71, 100). +digit_weight( 0x137B, 100). +digit_weight( 0x216D, 100). +digit_weight( 0x217D, 100). +digit_weight( 0x4F70, 100). +digit_weight( 0x767E, 100). +digit_weight( 0x964C, 100). +digit_weight( 0x10119, 100). +digit_weight( 0x1014B, 100). +digit_weight( 0x10152, 100). +digit_weight( 0x1016A, 100). +digit_weight( 0x102F3, 100). +digit_weight( 0x103D5, 100). +digit_weight( 0x1085D, 100). +digit_weight( 0x108AF, 100). +digit_weight( 0x108FF, 100). +digit_weight( 0x10919, 100). +digit_weight( 0x109D2, 100). +digit_weight( 0x10A46, 100). +digit_weight( 0x10AEF, 100). +digit_weight( 0x10B5E, 100). +digit_weight( 0x10B7E, 100). +digit_weight( 0x10BAF, 100). +digit_weight( 0x10CFE, 100). +digit_weight( 0x10E72, 100). +digit_weight( 0x11064, 100). +digit_weight( 0x111F3, 100). +digit_weight( 0x16B5C, 100). +digit_weight( 0x1011A, 200). +digit_weight( 0x102F4, 200). +digit_weight( 0x109D3, 200). +digit_weight( 0x10E73, 200). +digit_weight( 0x1011B, 300). +digit_weight( 0x1016B, 300). +digit_weight( 0x102F5, 300). +digit_weight( 0x109D4, 300). +digit_weight( 0x10E74, 300). +digit_weight( 0x1011C, 400). +digit_weight( 0x102F6, 400). +digit_weight( 0x109D5, 400). +digit_weight( 0x10E75, 400). +digit_weight( 0x216E, 500). +digit_weight( 0x217E, 500). +digit_weight( 0x1011D, 500). +digit_weight( 0x10145, 500). +digit_weight( 0x1014C, 500). +digit_weight( 0x10153, 500). +digit_weight( 0x1016C, 0x10170, 500). +digit_weight( 0x102F7, 500). +digit_weight( 0x109D6, 500). +digit_weight( 0x10E76, 500). +digit_weight( 0x1011E, 600). +digit_weight( 0x102F8, 600). +digit_weight( 0x109D7, 600). +digit_weight( 0x10E77, 600). +digit_weight( 0x1011F, 700). +digit_weight( 0x102F9, 700). +digit_weight( 0x109D8, 700). +digit_weight( 0x10E78, 700). +digit_weight( 0x10120, 800). +digit_weight( 0x102FA, 800). +digit_weight( 0x109D9, 800). +digit_weight( 0x10E79, 800). +digit_weight( 0x10121, 900). +digit_weight( 0x102FB, 900). +digit_weight( 0x1034A, 900). +digit_weight( 0x109DA, 900). +digit_weight( 0x10E7A, 900). +digit_weight( 0x0BF2, 1000). +digit_weight( 0x0D72, 1000). +digit_weight( 0x216F, 1000). +digit_weight( 0x217F, 0x2180, 1000). +digit_weight( 0x4EDF, 1000). +digit_weight( 0x5343, 1000). +digit_weight( 0x9621, 1000). +digit_weight( 0x10122, 1000). +digit_weight( 0x1014D, 1000). +digit_weight( 0x10154, 1000). +digit_weight( 0x10171, 1000). +digit_weight( 0x1085E, 1000). +digit_weight( 0x109DB, 1000). +digit_weight( 0x10A47, 1000). +digit_weight( 0x10B5F, 1000). +digit_weight( 0x10B7F, 1000). +digit_weight( 0x10CFF, 1000). +digit_weight( 0x11065, 1000). +digit_weight( 0x111F4, 1000). +digit_weight( 0x10123, 2000). +digit_weight( 0x109DC, 2000). +digit_weight( 0x10124, 3000). +digit_weight( 0x109DD, 3000). +digit_weight( 0x10125, 4000). +digit_weight( 0x109DE, 4000). +digit_weight( 0x2181, 5000). +digit_weight( 0x10126, 5000). +digit_weight( 0x10146, 5000). +digit_weight( 0x1014E, 5000). +digit_weight( 0x10172, 5000). +digit_weight( 0x109DF, 5000). +digit_weight( 0x10127, 6000). +digit_weight( 0x109E0, 6000). +digit_weight( 0x10128, 7000). +digit_weight( 0x109E1, 7000). +digit_weight( 0x10129, 8000). +digit_weight( 0x109E2, 8000). +digit_weight( 0x1012A, 9000). +digit_weight( 0x109E3, 9000). +digit_weight( 0x137C, 10000). +digit_weight( 0x2182, 10000). +digit_weight( 0x4E07, 10000). +digit_weight( 0x842C, 10000). +digit_weight( 0x1012B, 10000). +digit_weight( 0x10155, 10000). +digit_weight( 0x1085F, 10000). +digit_weight( 0x109E4, 10000). +digit_weight( 0x16B5D, 10000). +digit_weight( 0x1012C, 20000). +digit_weight( 0x109E5, 20000). +digit_weight( 0x1012D, 30000). +digit_weight( 0x109E6, 30000). +digit_weight( 0x1012E, 40000). +digit_weight( 0x109E7, 40000). +digit_weight( 0x2187, 50000). +digit_weight( 0x1012F, 50000). +digit_weight( 0x10147, 50000). +digit_weight( 0x10156, 50000). +digit_weight( 0x109E8, 50000). +digit_weight( 0x10130, 60000). +digit_weight( 0x109E9, 60000). +digit_weight( 0x10131, 70000). +digit_weight( 0x109EA, 70000). +digit_weight( 0x10132, 80000). +digit_weight( 0x109EB, 80000). +digit_weight( 0x10133, 90000). +digit_weight( 0x109EC, 90000). +digit_weight( 0x2188, 100000). +digit_weight( 0x109ED, 100000). +digit_weight( 0x109EE, 200000). +digit_weight( 0x12432, 216000). +digit_weight( 0x109EF, 300000). +digit_weight( 0x109F0, 400000). +digit_weight( 0x12433, 432000). +digit_weight( 0x109F1, 500000). +digit_weight( 0x109F2, 600000). +digit_weight( 0x109F3, 700000). +digit_weight( 0x109F4, 800000). +digit_weight( 0x109F5, 900000). +digit_weight( 0x16B5E, 1000000). +digit_weight( 0x4EBF, 100000000). +digit_weight( 0x5104, 100000000). +digit_weight( 0x16B5F, 100000000). +digit_weight( 0x16B60, 10000000000). +digit_weight( 0x5146, 1000000000000). +digit_weight( 0x16B61, 1000000000000). +/* brackets and matching characters, obtained from +http://www.unicode.org/Public/UCD/latest/ucd/BidiBrackets.txt -static Int -p_force_char_conversion( USES_REGS1 ) -{ - int i; +by running - /* don't actually enable it until someone tries to add a conversion */ - if (CharConversionTable2 == NULL) - return(TRUE); - for (i = 0; i < MaxStreams; i++) { - if (!(GLOBAL_Stream[i].status & Free_Stream_f)) - GLOBAL_Stream[i].stream_wgetc_for_read = ISOWGetc; - } - CharConversionTable = CharConversionTable2; - return(TRUE); -} + grep '[ \t]\#' BidiBrackets.txt | awk '{ print "brackets( 0x" $1 ", 0x"$2 ")." }' |sed 's/;//g' +*/ -static Int -p_disable_char_conversion( USES_REGS1 ) -{ - int i; - - for (i = 0; i < MaxStreams; i++) { - if (!(GLOBAL_Stream[i].status & Free_Stream_f)) - GLOBAL_Stream[i].stream_wgetc_for_read = GLOBAL_Stream[i].stream_wgetc; - } - CharConversionTable = NULL; - return(TRUE); -} - -static Int -char_conversion( USES_REGS1 ) -{ - Term t0 = Deref(ARG1), t1 = Deref(ARG2); - char *s0, *s1; - - if (IsVarTerm(t0)) { - Yap_Error(INSTANTIATION_ERROR, t0, "char_conversion/2"); - return (FALSE); - } - if (!IsAtomTerm(t0)) { - Yap_Error(REPRESENTATION_ERROR_CHARACTER, t0, "char_conversion/2"); - return (FALSE); - } - s0 = RepAtom(AtomOfTerm(t0))->StrOfAE; - if (s0[1] != '\0') { - Yap_Error(REPRESENTATION_ERROR_CHARACTER, t0, "char_conversion/2"); - return (FALSE); - } - if (IsVarTerm(t1)) { - Yap_Error(INSTANTIATION_ERROR, t1, "char_conversion/2"); - return (FALSE); - } - if (!IsAtomTerm(t1)) { - Yap_Error(REPRESENTATION_ERROR_CHARACTER, t1, "char_conversion/2"); - return (FALSE); - } - s1 = RepAtom(AtomOfTerm(t1))->StrOfAE; - if (s1[1] != '\0') { - Yap_Error(REPRESENTATION_ERROR_CHARACTER, t1, "char_conversion/2"); - return (FALSE); - } - /* check if we do have a table for converting characters */ - if (CharConversionTable2 == NULL) { - int i; - - /* don't create a table if we don't need to */ - if (s0[0] == s1[0]) - return(TRUE); - CharConversionTable2 = Yap_AllocCodeSpace(NUMBER_OF_CHARS*sizeof(char)); - while (CharConversionTable2 == NULL) { - if (!Yap_growheap(FALSE, NUMBER_OF_CHARS*sizeof(char), NULL)) { - Yap_Error(RESOURCE_ERROR_HEAP, TermNil, LOCAL_ErrorMessage); - return(FALSE); - } - } - if (truePrologFlag(CHAR_CONVERSION_FLAG)) { - if (p_force_char_conversion() == FALSE) - return(FALSE); - } - for (i = 0; i < NUMBER_OF_CHARS; i++) - CharConversionTable2[i] = i; - } - /* just add the new entry */ - CharConversionTable2[(int)s0[0]] = s1[0]; - /* done */ - return(TRUE); -} - -static Int -p_current_char_conversion( USES_REGS1 ) -{ - Term t0, t1; - char *s0, *s1; - - if (CharConversionTable == NULL) { - return(FALSE); - } - t0 = Deref(ARG1); - if (IsVarTerm(t0)) { - Yap_Error(INSTANTIATION_ERROR, t0, "current_char_conversion/2"); - return (FALSE); - } - if (!IsAtomTerm(t0)) { - Yap_Error(REPRESENTATION_ERROR_CHARACTER, t0, "current_char_conversion/2"); - return (FALSE); - } - s0 = RepAtom(AtomOfTerm(t0))->StrOfAE; - if (s0[1] != '\0') { - Yap_Error(REPRESENTATION_ERROR_CHARACTER, t0, "current_char_conversion/2"); - return (FALSE); - } - t1 = Deref(ARG2); - if (IsVarTerm(t1)) { - char out[2]; - if (CharConversionTable[(int)s0[0]] == '\0') return(FALSE); - out[0] = CharConversionTable[(int)s0[0]]; - out[1] = '\0'; - return(Yap_unify(ARG2,MkAtomTerm(Yap_LookupAtom(out)))); - } - if (!IsAtomTerm(t1)) { - Yap_Error(REPRESENTATION_ERROR_CHARACTER, t1, "current_char_conversion/2"); - return (FALSE); - } - s1 = RepAtom(AtomOfTerm(t1))->StrOfAE; - if (s1[1] != '\0') { - Yap_Error(REPRESENTATION_ERROR_CHARACTER, t1, "current_char_conversion/2"); - return (FALSE); - } else { - return (CharConversionTable[(int)s0[0]] == '\0' && - CharConversionTable[(int)s0[0]] == s1[0] ); - } -} - -static Int -p_all_char_conversions( USES_REGS1 ) -{ - Term out = TermNil; - int i; - - if (CharConversionTable == NULL) { - return(FALSE); - } - for (i = NUMBER_OF_CHARS; i > 0; ) { - i--; - if (CharConversionTable[i] != '\0') { - Term t1, t2; - char s[2]; - s[1] = '\0'; - s[0] = CharConversionTable[i]; - t1 = MkAtomTerm(Yap_LookupAtom(s)); - out = MkPairTerm(t1,out); - s[0] = i; - t2 = MkAtomTerm(Yap_LookupAtom(s)); - out = MkPairTerm(t2,out); - } - } - return(Yap_unify(ARG1,out)); -} - - -void -Yap_InitChtypes(void) -{ - Yap_InitCPred ("$change_type_of_char", 2, p_change_type_of_char, SafePredFlag|SyncPredFlag|HiddenPredFlag); - Yap_InitCPred ("$type_of_char", 2, p_type_of_char, SafePredFlag|SyncPredFlag|HiddenPredFlag); - Yap_InitCPred ("toupper", 2, toupper, SafePredFlag|HiddenPredFlag); - Yap_InitCPred ("tolower", 2, tolower, SafePredFlag|HiddenPredFlag); - Yap_InitCPred ("char_conversion", 2, char_conversion, SyncPredFlag); - Yap_InitCPred ("$current_char_conversion", 2, p_current_char_conversion, SyncPredFlag|HiddenPredFlag); - Yap_InitCPred ("$all_char_conversions", 1, p_all_char_conversions, SyncPredFlag|HiddenPredFlag); - Yap_InitCPred ("$force_char_conversion", 0, p_force_char_conversion, SyncPredFlag|HiddenPredFlag); - Yap_InitCPred ("$disable_char_conversion", 0, p_disable_char_conversion, SyncPredFlag|HiddenPredFlag); - - } +paren_paren( 0x0028, 0x0029). +paren_paren( 0x0029, 0x0028). +paren_paren( 0x005B, 0x005D). +paren_paren( 0x005D, 0x005B). +paren_paren( 0x007B, 0x007D). +paren_paren( 0x007D, 0x007B). +paren_paren( 0x0F3A, 0x0F3B). +paren_paren( 0x0F3B, 0x0F3A). +paren_paren( 0x0F3C, 0x0F3D). +paren_paren( 0x0F3D, 0x0F3C). +paren_paren( 0x169B, 0x169C). +paren_paren( 0x169C, 0x169B). +paren_paren( 0x2045, 0x2046). +paren_paren( 0x2046, 0x2045). +paren_paren( 0x207D, 0x207E). +paren_paren( 0x207E, 0x207D). +paren_paren( 0x208D, 0x208E). +paren_paren( 0x208E, 0x208D). +paren_paren( 0x2308, 0x2309). +paren_paren( 0x2309, 0x2308). +paren_paren( 0x230A, 0x230B). +paren_paren( 0x230B, 0x230A). +paren_paren( 0x2329, 0x232A). +paren_paren( 0x232A, 0x2329). +paren_paren( 0x2768, 0x2769). +paren_paren( 0x2769, 0x2768). +paren_paren( 0x276A, 0x276B). +paren_paren( 0x276B, 0x276A). +paren_paren( 0x276C, 0x276D). +paren_paren( 0x276D, 0x276C). +paren_paren( 0x276E, 0x276F). +paren_paren( 0x276F, 0x276E). +paren_paren( 0x2770, 0x2771). +paren_paren( 0x2771, 0x2770). +paren_paren( 0x2772, 0x2773). +paren_paren( 0x2773, 0x2772). +paren_paren( 0x2774, 0x2775). +paren_paren( 0x2775, 0x2774). +paren_paren( 0x27C5, 0x27C6). +paren_paren( 0x27C6, 0x27C5). +paren_paren( 0x27E6, 0x27E7). +paren_paren( 0x27E7, 0x27E6). +paren_paren( 0x27E8, 0x27E9). +paren_paren( 0x27E9, 0x27E8). +paren_paren( 0x27EA, 0x27EB). +paren_paren( 0x27EB, 0x27EA). +paren_paren( 0x27EC, 0x27ED). +paren_paren( 0x27ED, 0x27EC). +paren_paren( 0x27EE, 0x27EF). +paren_paren( 0x27EF, 0x27EE). +paren_paren( 0x2983, 0x2984). +paren_paren( 0x2984, 0x2983). +paren_paren( 0x2985, 0x2986). +paren_paren( 0x2986, 0x2985). +paren_paren( 0x2987, 0x2988). +paren_paren( 0x2988, 0x2987). +paren_paren( 0x2989, 0x298A). +paren_paren( 0x298A, 0x2989). +paren_paren( 0x298B, 0x298C). +paren_paren( 0x298C, 0x298B). +paren_paren( 0x298D, 0x2990). +paren_paren( 0x298E, 0x298F). +paren_paren( 0x298F, 0x298E). +paren_paren( 0x2990, 0x298D). +paren_paren( 0x2991, 0x2992). +paren_paren( 0x2992, 0x2991). +paren_paren( 0x2993, 0x2994). +paren_paren( 0x2994, 0x2993). +paren_paren( 0x2995, 0x2996). +paren_paren( 0x2996, 0x2995). +paren_paren( 0x2997, 0x2998). +paren_paren( 0x2998, 0x2997). +paren_paren( 0x29D8, 0x29D9). +paren_paren( 0x29D9, 0x29D8). +paren_paren( 0x29DA, 0x29DB). +paren_paren( 0x29DB, 0x29DA). +paren_paren( 0x29FC, 0x29FD). +paren_paren( 0x29FD, 0x29FC). +paren_paren( 0x2E22, 0x2E23). +paren_paren( 0x2E23, 0x2E22). +paren_paren( 0x2E24, 0x2E25). +paren_paren( 0x2E25, 0x2E24). +paren_paren( 0x2E26, 0x2E27). +paren_paren( 0x2E27, 0x2E26). +paren_paren( 0x2E28, 0x2E29). +paren_paren( 0x2E29, 0x2E28). +paren_paren( 0x3008, 0x3009). +paren_paren( 0x3009, 0x3008). +paren_paren( 0x300A, 0x300B). +paren_paren( 0x300B, 0x300A). +paren_paren( 0x300C, 0x300D). +paren_paren( 0x300D, 0x300C). +paren_paren( 0x300E, 0x300F). +paren_paren( 0x300F, 0x300E). +paren_paren( 0x3010, 0x3011). +paren_paren( 0x3011, 0x3010). +paren_paren( 0x3014, 0x3015). +paren_paren( 0x3015, 0x3014). +paren_paren( 0x3016, 0x3017). +paren_paren( 0x3017, 0x3016). +paren_paren( 0x3018, 0x3019). +paren_paren( 0x3019, 0x3018). +paren_paren( 0x301A, 0x301B). +paren_paren( 0x301B, 0x301A). +paren_paren( 0xFE59, 0xFE5A). +paren_paren( 0xFE5A, 0xFE59). +paren_paren( 0xFE5B, 0xFE5C). +paren_paren( 0xFE5C, 0xFE5B). +paren_paren( 0xFE5D, 0xFE5E). +paren_paren( 0xFE5E, 0xFE5D). +paren_paren( 0xFF08, 0xFF09). +paren_paren( 0xFF09, 0xFF08). +paren_paren( 0xFF3B, 0xFF3D). +paren_paren( 0xFF3D, 0xFF3B). +paren_paren( 0xFF5B, 0xFF5D). +paren_paren( 0xFF5D, 0xFF5B). +paren_paren( 0xFF5F, 0xFF60). +paren_paren( 0xFF60, 0xFF5F). +paren_paren( 0xFF62, 0xFF63). +paren_paren( 0xFF63, 0xFF62). diff --git a/os/encoding.h b/os/encoding.h index a52de596d..9364593f2 100644 --- a/os/encoding.h +++ b/os/encoding.h @@ -93,6 +93,7 @@ static inline const char *enc_name(encoding_t enc) case ENC_UTF16_LE: return "utf16_le"; case ENC_ISO_UTF32_BE: return "utf32_be"; case ENC_ISO_UTF32_LE: return "utf32_le"; + default: return "thanks for watching!!"; } } diff --git a/os/format.c b/os/format.c index 31dd2be20..f17085faa 100644 --- a/os/format.c +++ b/os/format.c @@ -276,7 +276,6 @@ doformat(volatile Term otail, volatile Term oargs, int sno USES_REGS) { char tmp1[TMP_STRING_SIZE], *tmpbase; int ch; - int column_boundary; Term mytargs[8], *targs; Int tnum, targ; const char *fstr = NULL, *fptr; @@ -320,7 +319,6 @@ doformat(volatile Term otail, volatile Term oargs, int sno USES_REGS) args = oargs; tail = otail; targ = 0; - column_boundary = 0; if (IsVarTerm(tail)) { Yap_Error(INSTANTIATION_ERROR,tail,"format/2"); return(FALSE); @@ -782,7 +780,6 @@ doformat(volatile Term otail, volatile Term oargs, int sno USES_REGS) while (repeats--) { f_putc(sno, (int) '\n'); } - column_boundary = 0; finfo.padders = 0; break; case 'N': @@ -790,14 +787,12 @@ doformat(volatile Term otail, volatile Term oargs, int sno USES_REGS) has_repeats = 1; if (GLOBAL_Stream[sno].linepos != 0) { f_putc(sno, '\n'); - column_boundary = 0; finfo.padders = 0; } if (repeats > 1) { Int i; for (i = 1; i < repeats; i++) f_putc(sno, '\n'); - column_boundary = 0; finfo.padders = 0; } break; diff --git a/os/open_memstream.c b/os/open_memstream.c index 14e3e7524..44c2c6aef 100644 --- a/os/open_memstream.c +++ b/os/open_memstream.c @@ -29,6 +29,8 @@ // #include "verify.h" +#if !HAVE_OPEN_MEMSTREAM + #if !HAVE_FUNOPEN # error Sorry, not ported to your platform yet #else @@ -192,3 +194,5 @@ open_memstream (char **buf, size_t *len) return f; } #endif /* HAVE_FUNOPEN */ + +#endif /* HAVE_OPEN_MEMSTREAM*/ diff --git a/os/readutil.c b/os/readutil.c index c107d06ee..08d0ee25b 100644 --- a/os/readutil.c +++ b/os/readutil.c @@ -156,14 +156,14 @@ read_stream_to_terms(USES_REGS1) { int sno = Yap_CheckStream (ARG1, Input_Stream_f, "read_line_to_codes/2"); Term t, hd; - yhandle_t tails, outs, news; + yhandle_t tails, news; if (sno < 0) return FALSE; t = AbsPair(HR); RESET_VARIABLE(HR); - outs = Yap_InitSlot( (CELL)(HR) ); + Yap_InitSlot( (CELL)(HR) ); tails = Yap_InitSlot( (CELL)(HR) ); news = Yap_InitSlot( (CELL)(HR) ); HR++; diff --git a/os/streams.c b/os/streams.c index d395984cb..8fb06371e 100644 --- a/os/streams.c +++ b/os/streams.c @@ -215,7 +215,7 @@ has_reposition(int sno, char *Yap_guessFileName(int f, int sno, char *nameb, size_t max) { #if __linux__ char path[256]; - if (snprintf(path, 255, "/proc/self/fd/~d", f) && readlink(path, nameb, max)) + if (snprintf(path, 255, "/proc/self/fd/%d", f) && readlink(path, nameb, max)) return nameb; #elif __APPLE__ if (fcntl(f, F_GETPATH, nameb) != -1) { @@ -720,7 +720,7 @@ static bool do_set_stream(int sno, GLOBAL_Stream[sno].status |= Eof_Error_Stream_f; GLOBAL_Stream[sno].status &= ~Reset_Eof_Stream_f; } else if (t2 == TermReset) { - GLOBAL_Stream[sno].status |= GLOBAL_Stream[sno].status &= + GLOBAL_Stream[sno].status &= ~Eof_Error_Stream_f; GLOBAL_Stream[sno].status |= Reset_Eof_Stream_f; } else if (t2 == TermEOfCode) { @@ -754,8 +754,7 @@ static bool do_set_stream(int sno, GLOBAL_Stream[sno].status |= RepError_Xml_f; GLOBAL_Stream[sno].status &= ~RepError_Prolog_f; } else if (t2 == TermError) { - GLOBAL_Stream[sno].status |= GLOBAL_Stream[sno].status &= - ~RepError_Xml_f; + GLOBAL_Stream[sno].status &= ~RepError_Xml_f; GLOBAL_Stream[sno].status |= RepError_Prolog_f; } else if (t2 == TermEOfCode) { GLOBAL_Stream[sno].status &= ~RepError_Xml_f; diff --git a/os/sysbits.c b/os/sysbits.c index 767a198a2..952c955f4 100644 --- a/os/sysbits.c +++ b/os/sysbits.c @@ -103,6 +103,9 @@ static char SccsId[] = "%W% %G%"; #if HAVE_LIBGEN_H #include #endif +#if HAVE_STDARG_H +#include +#endif #if HAVE_READLINE_READLINE_H #include #endif diff --git a/os/yapio.h b/os/yapio.h index 845ae4c0d..db359f34b 100644 --- a/os/yapio.h +++ b/os/yapio.h @@ -44,23 +44,6 @@ typedef struct AliasDescS { #define MAX_ISO_LATIN1 255 -/****************** character definition table **************************/ - -#define NUMBER_OF_CHARS 256 -extern char *Yap_chtype; - -#include "inline-only.h" -INLINE_ONLY EXTERN inline int chtype(Int); -int Yap_wide_chtype(Int); - -INLINE_ONLY EXTERN inline int -chtype(Int ch) -{ - if (ch < NUMBER_OF_CHARS) - return Yap_chtype[ch]; - return Yap_wide_chtype(ch); -} - /* parser stack, used to be AuxSp, now is ASP */ #define ParserAuxSp LOCAL_ScannerStack diff --git a/packages/CLPBN/horus/CMakeLists.txt b/packages/CLPBN/horus/CMakeLists.txt index 937a13e5c..ec95f50e6 100644 --- a/packages/CLPBN/horus/CMakeLists.txt +++ b/packages/CLPBN/horus/CMakeLists.txt @@ -1,7 +1,7 @@ option (HORUS "enable HORUS graphical model tookit" ON) -cmake_minimum_required(VERSION 3.1.0 FATAL_ERROR) +#cmake_minimum_required(VERSION 3.1.0 FATAL_ERROR) diff --git a/packages/ProbLog/CMakeLists.txt b/packages/ProbLog/CMakeLists.txt index 812eeb4c9..9ecb76440 100644 --- a/packages/ProbLog/CMakeLists.txt +++ b/packages/ProbLog/CMakeLists.txt @@ -1,5 +1,5 @@ set (PROGRAMS - Problog.yap + problog.yap problog_lbdd.yap problog_lfi.yap dtproblog.yap diff --git a/packages/bdd/cudd.c b/packages/bdd/cudd.c index a401bb2ff..4bbfb7d2b 100644 --- a/packages/bdd/cudd.c +++ b/packages/bdd/cudd.c @@ -41,17 +41,15 @@ CUDD will generate better/faster code. #include "cudd_config.h" #include "YapInterface.h" -#if HAVE_UTIL_H -#include -#endif #if HAVE_CUDD_UTIL_H #include -#endif -#if HAVE_CUDD_H -#include "cudd.h" +#elif HAVE_UTIL_H +#include #endif #if HAVE_CUDD_CUDD_H #include "cudd/cudd.h" +#elif HAVE_CUDD_H +#include "cudd.h" #endif static YAP_Functor FunctorDollarVar, diff --git a/packages/bdd/cudd_config.h.cmake b/packages/bdd/cudd_config.h.cmake index 1c6449c96..600579e6b 100644 --- a/packages/bdd/cudd_config.h.cmake +++ b/packages/bdd/cudd_config.h.cmake @@ -2,31 +2,31 @@ /* Define to 1 if you have the header file. */ #ifndef HAVE_CUDDINT_H -#cmakedefine HAVE_CUDDINT_H ${HAVE_CUDDINT_H} +#define HAVE_CUDDINT_H ${HAVE_CUDDINT_H} #endif /* Define to 1 if you have the header file. */ #ifndef HAVE_CUDD_CUDDINT_H -#cmakedefine HAVE_CUDD_CUDDINT_H ${HAVE_CUDD_CUDDINT_H} +#define HAVE_CUDD_CUDDINT_H ${HAVE_CUDD_CUDDINT_H} #endif /* Define to 1 if you have the header file. */ #ifndef HAVE_CUDD_CUDD_H -#cmakedefine HAVE_CUDD_CUDD_H ${HAVE_CUDD_CUDD_H} +#define HAVE_CUDD_CUDD_H ${HAVE_CUDD_CUDD_H} #endif /* Define to 1 if you have the header file. */ #ifndef HAVE_CUDD_H -#cmakedefine HAVE_CUDD_H ${HAVE_CUDD_H} +#define HAVE_CUDD_H ${HAVE_CUDD_H} #endif /* Define to 1 if you have the header file. */ #ifndef HAVE_CUDD_UTIL_H -#cmakedefine HAVE_CUDD_UTIL_H ${HAVE_CUDD_UTIL_H} +#define HAVE_CUDD_UTIL_H ${HAVE_CUDD_UTIL_H} #endif /* Define to 1 if you have the header file. */ #ifndef HAVE_UTIL_H -#cmakedefine HAVE_UTIL_H ${HAVE_UTIL_H} +#define HAVE_UTIL_H ${HAVE_UTIL_H} #endif diff --git a/packages/bdd/simplecudd/simplecudd.h b/packages/bdd/simplecudd/simplecudd.h index edf815647..64a3f8ea0 100644 --- a/packages/bdd/simplecudd/simplecudd.h +++ b/packages/bdd/simplecudd/simplecudd.h @@ -194,24 +194,24 @@ #include #include "config.h" #include "../cudd_config.h" -#if HAVE_UTIL_H -#include -#endif + #if HAVE_CUDD_UTIL_H #include -#endif -#if HAVE_CUDD_H -#include "cudd.h" +#elif HAVE_UTIL_H +#include #endif #if HAVE_CUDD_CUDD_H #include "cudd/cudd.h" +#elif HAVE_CUDD_H +#include "cudd.h" #endif -#if HAVE_CUDDINT_H -#include "cuddInt.h" -#endif + #if HAVE_CUDD_CUDDINT_H #include "cudd/cuddInt.h" +#elif HAVE_CUDDINT_H +#include "cuddInt.h" #endif + #include "general.h" #define IsHigh(manager, node) HIGH(manager) == node diff --git a/packages/bdd/simplecudd_lfi/simplecudd.h b/packages/bdd/simplecudd_lfi/simplecudd.h index fed8c17d5..38ae6b8ca 100644 --- a/packages/bdd/simplecudd_lfi/simplecudd.h +++ b/packages/bdd/simplecudd_lfi/simplecudd.h @@ -193,24 +193,23 @@ #include "pqueue.h" #include "config.h" #include "../cudd_config.h" -#if HAVE_UTIL_H -#include -#endif #if HAVE_CUDD_UTIL_H #include -#endif -#if HAVE_CUDD_H -#include "cudd.h" +#elif HAVE_UTIL_H +#include #endif #if HAVE_CUDD_CUDD_H #include "cudd/cudd.h" +#elif HAVE_CUDD_H +#include "cudd.h" #endif -#if HAVE_CUDDINT_H -#include "cuddInt.h" -#endif + #if HAVE_CUDD_CUDDINT_H #include "cudd/cuddInt.h" +#elif HAVE_CUDDINT_H +#include "cuddInt.h" #endif + #include "general.h" #define IsHigh(manager, node) HIGH(manager) == node diff --git a/packages/gecode/4.4.0/gecode-version.txt b/packages/gecode/4.4.0/gecode-version.txt new file mode 100644 index 000000000..fdc669880 --- /dev/null +++ b/packages/gecode/4.4.0/gecode-version.txt @@ -0,0 +1 @@ +4.4.0 diff --git a/packages/gecode/4.4.0/gecode_yap_auto_generated.yap b/packages/gecode/4.4.0/gecode_yap_auto_generated.yap new file mode 100644 index 000000000..8dec99fbf --- /dev/null +++ b/packages/gecode/4.4.0/gecode_yap_auto_generated.yap @@ -0,0 +1,3582 @@ +%% -*- 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 . +%%============================================================================= + +is_RestartMode_('RM_NONE'). +is_RestartMode_('RM_CONSTANT'). +is_RestartMode_('RM_LINEAR'). +is_RestartMode_('RM_LUBY'). +is_RestartMode_('RM_GEOMETRIC'). + +is_RestartMode_('RM_NONE','RM_NONE'). +is_RestartMode_('RM_CONSTANT','RM_CONSTANT'). +is_RestartMode_('RM_LINEAR','RM_LINEAR'). +is_RestartMode_('RM_LUBY','RM_LUBY'). +is_RestartMode_('RM_GEOMETRIC','RM_GEOMETRIC'). + +is_RestartMode(X,Y) :- nonvar(X), is_RestartMode_(X,Y). +is_RestartMode(X) :- is_RestartMode(X,_). + +is_FloatRelType_('FRT_EQ'). +is_FloatRelType_('FRT_NQ'). +is_FloatRelType_('FRT_LQ'). +is_FloatRelType_('FRT_LE'). +is_FloatRelType_('FRT_GQ'). +is_FloatRelType_('FRT_GR'). + +is_FloatRelType_('FRT_EQ','FRT_EQ'). +is_FloatRelType_('FRT_NQ','FRT_NQ'). +is_FloatRelType_('FRT_LQ','FRT_LQ'). +is_FloatRelType_('FRT_LE','FRT_LE'). +is_FloatRelType_('FRT_GQ','FRT_GQ'). +is_FloatRelType_('FRT_GR','FRT_GR'). + +is_FloatRelType(X,Y) :- nonvar(X), is_FloatRelType_(X,Y). +is_FloatRelType(X) :- is_FloatRelType(X,_). + +is_ReifyMode_('RM_EQV'). +is_ReifyMode_('RM_IMP'). +is_ReifyMode_('RM_PMI'). + +is_ReifyMode_('RM_EQV','RM_EQV'). +is_ReifyMode_('RM_IMP','RM_IMP'). +is_ReifyMode_('RM_PMI','RM_PMI'). + +is_ReifyMode(X,Y) :- nonvar(X), is_ReifyMode_(X,Y). +is_ReifyMode(X) :- is_ReifyMode(X,_). + +is_IntRelType_('IRT_EQ'). +is_IntRelType_('IRT_NQ'). +is_IntRelType_('IRT_LQ'). +is_IntRelType_('IRT_LE'). +is_IntRelType_('IRT_GQ'). +is_IntRelType_('IRT_GR'). + +is_IntRelType_('IRT_EQ','IRT_EQ'). +is_IntRelType_('IRT_NQ','IRT_NQ'). +is_IntRelType_('IRT_LQ','IRT_LQ'). +is_IntRelType_('IRT_LE','IRT_LE'). +is_IntRelType_('IRT_GQ','IRT_GQ'). +is_IntRelType_('IRT_GR','IRT_GR'). + +is_IntRelType(X,Y) :- nonvar(X), is_IntRelType_(X,Y). +is_IntRelType(X) :- is_IntRelType(X,_). + +is_BoolOpType_('BOT_AND'). +is_BoolOpType_('BOT_OR'). +is_BoolOpType_('BOT_IMP'). +is_BoolOpType_('BOT_EQV'). +is_BoolOpType_('BOT_XOR'). + +is_BoolOpType_('BOT_AND','BOT_AND'). +is_BoolOpType_('BOT_OR','BOT_OR'). +is_BoolOpType_('BOT_IMP','BOT_IMP'). +is_BoolOpType_('BOT_EQV','BOT_EQV'). +is_BoolOpType_('BOT_XOR','BOT_XOR'). + +is_BoolOpType(X,Y) :- nonvar(X), is_BoolOpType_(X,Y). +is_BoolOpType(X) :- is_BoolOpType(X,_). + +is_IntConLevel_('ICL_VAL'). +is_IntConLevel_('ICL_BND'). +is_IntConLevel_('ICL_DOM'). +is_IntConLevel_('ICL_DEF'). + +is_IntConLevel_('ICL_VAL','ICL_VAL'). +is_IntConLevel_('ICL_BND','ICL_BND'). +is_IntConLevel_('ICL_DOM','ICL_DOM'). +is_IntConLevel_('ICL_DEF','ICL_DEF'). + +is_IntConLevel(X,Y) :- nonvar(X), is_IntConLevel_(X,Y). +is_IntConLevel(X) :- is_IntConLevel(X,_). + +is_TaskType_('TT_FIXP'). +is_TaskType_('TT_FIXS'). +is_TaskType_('TT_FIXE'). + +is_TaskType_('TT_FIXP','TT_FIXP'). +is_TaskType_('TT_FIXS','TT_FIXS'). +is_TaskType_('TT_FIXE','TT_FIXE'). + +is_TaskType(X,Y) :- nonvar(X), is_TaskType_(X,Y). +is_TaskType(X) :- is_TaskType(X,_). + +is_ExtensionalPropKind_('EPK_DEF'). +is_ExtensionalPropKind_('EPK_SPEED'). +is_ExtensionalPropKind_('EPK_MEMORY'). + +is_ExtensionalPropKind_('EPK_DEF','EPK_DEF'). +is_ExtensionalPropKind_('EPK_SPEED','EPK_SPEED'). +is_ExtensionalPropKind_('EPK_MEMORY','EPK_MEMORY'). + +is_ExtensionalPropKind(X,Y) :- nonvar(X), is_ExtensionalPropKind_(X,Y). +is_ExtensionalPropKind(X) :- is_ExtensionalPropKind(X,_). + +is_SetRelType_('SRT_EQ'). +is_SetRelType_('SRT_NQ'). +is_SetRelType_('SRT_SUB'). +is_SetRelType_('SRT_SUP'). +is_SetRelType_('SRT_DISJ'). +is_SetRelType_('SRT_CMPL'). +is_SetRelType_('SRT_LQ'). +is_SetRelType_('SRT_LE'). +is_SetRelType_('SRT_GQ'). +is_SetRelType_('SRT_GR'). + +is_SetRelType_('SRT_EQ','SRT_EQ'). +is_SetRelType_('SRT_NQ','SRT_NQ'). +is_SetRelType_('SRT_SUB','SRT_SUB'). +is_SetRelType_('SRT_SUP','SRT_SUP'). +is_SetRelType_('SRT_DISJ','SRT_DISJ'). +is_SetRelType_('SRT_CMPL','SRT_CMPL'). +is_SetRelType_('SRT_LQ','SRT_LQ'). +is_SetRelType_('SRT_LE','SRT_LE'). +is_SetRelType_('SRT_GQ','SRT_GQ'). +is_SetRelType_('SRT_GR','SRT_GR'). + +is_SetRelType(X,Y) :- nonvar(X), is_SetRelType_(X,Y). +is_SetRelType(X) :- is_SetRelType(X,_). + +is_SetOpType_('SOT_UNION'). +is_SetOpType_('SOT_DUNION'). +is_SetOpType_('SOT_INTER'). +is_SetOpType_('SOT_MINUS'). + +is_SetOpType_('SOT_UNION','SOT_UNION'). +is_SetOpType_('SOT_DUNION','SOT_DUNION'). +is_SetOpType_('SOT_INTER','SOT_INTER'). +is_SetOpType_('SOT_MINUS','SOT_MINUS'). + +is_SetOpType(X,Y) :- nonvar(X), is_SetOpType_(X,Y). +is_SetOpType(X) :- is_SetOpType(X,_). + +unary(X0,X1,X2,X3,X4,X5) :- + (is_Space_or_Clause(X0,Y0) + -> (is_TaskTypeArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntArgs(X3,Y3) + -> (is_BoolVarArgs(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_unary_464(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))) + ; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4,X5),arg=3))) + ; (is_IntVarArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_BoolVarArgs(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_unary_460(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))) + ; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4,X5),arg=3))) + ; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4,X5),arg=2)))) + ; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4,X5),arg=1))). + +nvalues(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntRelType(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_nvalues_351(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_353(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))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntRelType(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_nvalues_347(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_349(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))) + ; throw(gecode_argument_error(nvalues(X0,X1,X2,X3,X4),arg=2)))) + ; throw(gecode_argument_error(nvalues(X0,X1,X2,X3,X4),arg=1))). + +max(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntVar(X3,Y3) + -> gecode_constraint_max_308(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_306(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_307(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_311(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)))))) + ; throw(gecode_argument_error(max(X0,X1,X2,X3),arg=1))). + +dom(X0,X1,X2,X3,X4,X5) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_int(X2,Y2) + -> (is_int(X3,Y3) + -> (is_Reify(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_dom_206(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4,X5),arg=4))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4,X5),arg=3))) + ; (is_SetVar(X1,Y1) + -> (is_SetRelType(X2,Y2) + -> (is_int(X3,Y3) + -> (is_int(X4,Y4) + -> (is_Reify(X5,Y5) + -> gecode_constraint_dom_215(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4,X5),arg=4))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4,X5),arg=3))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4,X5),arg=2)))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4,X5),arg=1))). + +argmin(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> gecode_constraint_argmin_56(Y0,Y1,Y2) + ; throw(gecode_argument_error(argmin(X0,X1,X2),arg=3))) + ; throw(gecode_argument_error(argmin(X0,X1,X2),arg=2))) + ; throw(gecode_argument_error(argmin(X0,X1,X2),arg=1))). + +convex(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_SetVar(X1,Y1) + -> (is_SetVar(X2,Y2) + -> gecode_constraint_convex_97(Y0,Y1,Y2) + ; throw(gecode_argument_error(convex(X0,X1,X2),arg=3))) + ; throw(gecode_argument_error(convex(X0,X1,X2),arg=2))) + ; throw(gecode_argument_error(convex(X0,X1,X2),arg=1))). + +nooverlap(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntArgs(X4,Y4) + -> gecode_constraint_nooverlap_335(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))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4),arg=2))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4),arg=1))). + +assign(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_FloatVar(X1,Y1) + -> (is_FloatAssign(X2,Y2) + -> gecode_constraint_assign_15(Y0,Y1,Y2) + ; throw(gecode_argument_error(assign(X0,X1,X2),arg=3))) + ; (is_FloatVarArgs(X1,Y1) + -> (is_FloatAssign(X2,Y2) + -> gecode_constraint_assign_6(Y0,Y1,Y2) + ; throw(gecode_argument_error(assign(X0,X1,X2),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntAssign(X2,Y2) + -> gecode_constraint_assign_3(Y0,Y1,Y2) + ; throw(gecode_argument_error(assign(X0,X1,X2),arg=3))) + ; (is_BoolVar(X1,Y1) + -> (is_IntAssign(X2,Y2) + -> gecode_constraint_assign_1(Y0,Y1,Y2) + ; throw(gecode_argument_error(assign(X0,X1,X2),arg=3))) + ; (is_IntVarArgs(X1,Y1) + -> (is_IntAssign(X2,Y2) + -> gecode_constraint_assign_9(Y0,Y1,Y2) + ; throw(gecode_argument_error(assign(X0,X1,X2),arg=3))) + ; (is_IntVar(X1,Y1) + -> (is_IntAssign(X2,Y2) + -> gecode_constraint_assign_17(Y0,Y1,Y2) + ; throw(gecode_argument_error(assign(X0,X1,X2),arg=3))) + ; (is_SetVarArgs(X1,Y1) + -> (is_SetAssign(X2,Y2) + -> gecode_constraint_assign_12(Y0,Y1,Y2) + ; throw(gecode_argument_error(assign(X0,X1,X2),arg=3))) + ; (is_SetVar(X1,Y1) + -> (is_SetAssign(X2,Y2) + -> gecode_constraint_assign_19(Y0,Y1,Y2) + ; throw(gecode_argument_error(assign(X0,X1,X2),arg=3))) + ; throw(gecode_argument_error(assign(X0,X1,X2),arg=2)))))))))) + ; throw(gecode_argument_error(assign(X0,X1,X2),arg=1))). + +element(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_int(X3,Y3) + -> gecode_constraint_element_226(Y0,Y1,Y2,Y3) + ; (is_IntVar(X3,Y3) + -> gecode_constraint_element_230(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(element(X0,X1,X2,X3),arg=4)))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_int(X3,Y3) + -> gecode_constraint_element_220(Y0,Y1,Y2,Y3) + ; (is_BoolVar(X3,Y3) + -> gecode_constraint_element_218(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(element(X0,X1,X2,X3),arg=4)))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3),arg=3))) + ; (is_IntSetArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_SetVar(X3,Y3) + -> gecode_constraint_element_225(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(element(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3),arg=3))) + ; (is_SetVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_SetVar(X3,Y3) + -> gecode_constraint_element_233(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(element(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3),arg=3))) + ; (is_IntArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_int(X3,Y3) + -> gecode_constraint_element_236(Y0,Y1,Y2,Y3) + ; (is_IntVar(X3,Y3) + -> gecode_constraint_element_242(Y0,Y1,Y2,Y3) + ; (is_BoolVar(X3,Y3) + -> gecode_constraint_element_234(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(element(X0,X1,X2,X3),arg=4))))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3),arg=3))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3),arg=2))))))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3),arg=1))). + +sequence(X0,X1) :- + (is_Space_or_Clause(X0,Y0) + -> (is_SetVarArgs(X1,Y1) + -> gecode_constraint_sequence_443(Y0,Y1) + ; throw(gecode_argument_error(sequence(X0,X1),arg=2))) + ; throw(gecode_argument_error(sequence(X0,X1),arg=1))). + +notMax(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_SetVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> gecode_constraint_notMax_341(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))). + +ite(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_BoolVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntVar(X3,Y3) + -> (is_IntVar(X4,Y4) + -> gecode_constraint_ite_262(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))) + ; throw(gecode_argument_error(ite(X0,X1,X2,X3,X4),arg=2))) + ; throw(gecode_argument_error(ite(X0,X1,X2,X3,X4),arg=1))). + +unary(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntArgs(X2,Y2) + -> gecode_constraint_unary_457(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))). + +nroot(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_int(X2,Y2) + -> (is_IntVar(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_nroot_345(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))) + ; throw(gecode_argument_error(nroot(X0,X1,X2,X3,X4),arg=2))) + ; throw(gecode_argument_error(nroot(X0,X1,X2,X3,X4),arg=1))). + +circuit(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_int(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntConLevel(X3,Y3) + -> gecode_constraint_circuit_91(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3),arg=3))) + ; (is_IntArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntVar(X3,Y3) + -> gecode_constraint_circuit_82(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3),arg=3))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3),arg=2)))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3),arg=1))). + +dom(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_int(X2,Y2) + -> (is_int(X3,Y3) + -> (is_Reify(X4,Y4) + -> gecode_constraint_dom_205(Y0,Y1,Y2,Y3,Y4) + ; (is_IntConLevel(X4,Y4) + -> gecode_constraint_dom_204(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=5)))) + ; (is_Reify(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_dom_208(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=4)))) + ; (is_IntSet(X2,Y2) + -> (is_Reify(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_dom_200(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=3)))) + ; (is_SetVarArgs(X1,Y1) + -> (is_SetRelType(X2,Y2) + -> (is_int(X3,Y3) + -> (is_int(X4,Y4) + -> gecode_constraint_dom_191(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=3))) + ; (is_IntVarArgs(X1,Y1) + -> (is_int(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_dom_187(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=3))) + ; (is_FloatVar(X1,Y1) + -> (is_FloatNum(X2,Y2) + -> (is_FloatNum(X3,Y3) + -> (is_Reify(X4,Y4) + -> gecode_constraint_dom_193(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=3))) + ; (is_SetVar(X1,Y1) + -> (is_SetRelType(X2,Y2) + -> (is_int(X3,Y3) + -> (is_int(X4,Y4) + -> gecode_constraint_dom_214(Y0,Y1,Y2,Y3,Y4) + ; (is_Reify(X4,Y4) + -> gecode_constraint_dom_216(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=5)))) + ; (is_IntSet(X3,Y3) + -> (is_Reify(X4,Y4) + -> gecode_constraint_dom_212(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=4)))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=3))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=2))))))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3,X4),arg=1))). + +channel(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntConLevel(X3,Y3) + -> gecode_constraint_channel_72(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_int(X3,Y3) + -> gecode_constraint_channel_68(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3),arg=3))) + ; (is_BoolVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntConLevel(X3,Y3) + -> gecode_constraint_channel_66(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3),arg=3))) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3),arg=2))))) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3),arg=1))). + +nooverlap(X0,X1,X2,X3,X4,X5,X6,X7) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVarArgs(X4,Y4) + -> (is_IntVarArgs(X5,Y5) + -> (is_IntVarArgs(X6,Y6) + -> (is_BoolVarArgs(X7,Y7) + -> gecode_constraint_nooverlap_337(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; (is_IntConLevel(X7,Y7) + -> gecode_constraint_nooverlap_340(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))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6,X7),arg=5))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6,X7),arg=4))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6,X7),arg=3))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6,X7),arg=2))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6,X7),arg=1))). + +element(X0,X1,X2,X3,X4,X5,X6) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntVar(X4,Y4) + -> (is_int(X5,Y5) + -> (is_IntVar(X6,Y6) + -> gecode_constraint_element_228(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=7))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=6))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=4))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntVar(X4,Y4) + -> (is_int(X5,Y5) + -> (is_BoolVar(X6,Y6) + -> gecode_constraint_element_222(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=7))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=6))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=4))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=3))) + ; (is_IntSetArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntVar(X4,Y4) + -> (is_int(X5,Y5) + -> (is_SetVar(X6,Y6) + -> gecode_constraint_element_224(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=7))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=6))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=4))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=3))) + ; (is_SetVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntVar(X4,Y4) + -> (is_int(X5,Y5) + -> (is_SetVar(X6,Y6) + -> gecode_constraint_element_232(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=7))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=6))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=4))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=3))) + ; (is_IntArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntVar(X4,Y4) + -> (is_int(X5,Y5) + -> (is_IntVar(X6,Y6) + -> gecode_constraint_element_240(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; (is_BoolVar(X6,Y6) + -> gecode_constraint_element_238(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=7)))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=6))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=4))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=3))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=2))))))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6),arg=1))). + +max(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_FloatVarArgs(X1,Y1) + -> (is_FloatVar(X2,Y2) + -> gecode_constraint_max_304(Y0,Y1,Y2) + ; throw(gecode_argument_error(max(X0,X1,X2),arg=3))) + ; (is_IntVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> gecode_constraint_max_305(Y0,Y1,Y2) + ; throw(gecode_argument_error(max(X0,X1,X2),arg=3))) + ; (is_SetVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> gecode_constraint_max_310(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))). + +unshare(X0,X1) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> gecode_constraint_unshare_469(Y0,Y1) + ; (is_BoolVarArgs(X1,Y1) + -> gecode_constraint_unshare_467(Y0,Y1) + ; throw(gecode_argument_error(unshare(X0,X1),arg=2)))) + ; throw(gecode_argument_error(unshare(X0,X1),arg=1))). + +path(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_int(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntVar(X3,Y3) + -> (is_IntVar(X4,Y4) + -> gecode_constraint_path_364(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))) + ; (is_IntVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntVar(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_path_363(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))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4),arg=2)))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4),arg=1))). + +branch(X0,X1,X2,X3,X4,X5,X6) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVarBranch(X2,Y2) + -> (is_IntValBranch(X3,Y3) + -> (is_Symmetries(X4,Y4) + -> (is_IntBranchFilter(X5,Y5) + -> (is_IntVarValPrint(X6,Y6) + -> gecode_constraint_branch_34(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5,X6),arg=7))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5,X6),arg=6))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5,X6),arg=5))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5,X6),arg=4))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5,X6),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntVarBranch(X2,Y2) + -> (is_IntValBranch(X3,Y3) + -> (is_Symmetries(X4,Y4) + -> (is_BoolBranchFilter(X5,Y5) + -> (is_BoolVarValPrint(X6,Y6) + -> gecode_constraint_branch_28(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5,X6),arg=7))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5,X6),arg=6))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5,X6),arg=5))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5,X6),arg=4))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5,X6),arg=3))) + ; (is_SetVarArgs(X1,Y1) + -> (is_SetVarBranch(X2,Y2) + -> (is_SetValBranch(X3,Y3) + -> (is_Symmetries(X4,Y4) + -> (is_SetBranchFilter(X5,Y5) + -> (is_SetVarValPrint(X6,Y6) + -> gecode_constraint_branch_40(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5,X6),arg=7))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5,X6),arg=6))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5,X6),arg=5))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5,X6),arg=4))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5,X6),arg=3))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5,X6),arg=2))))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5,X6),arg=1))). + +mult(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntVar(X3,Y3) + -> gecode_constraint_mult_331(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_330(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)))) + ; throw(gecode_argument_error(mult(X0,X1,X2,X3),arg=1))). + +clause(X0,X1,X2,X3,X4,X5) :- + (is_Space_or_Clause(X0,Y0) + -> (is_BoolOpType(X1,Y1) + -> (is_BoolVarArgs(X2,Y2) + -> (is_BoolVarArgs(X3,Y3) + -> (is_int(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_clause_95(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(clause(X0,X1,X2,X3,X4,X5),arg=6))) + ; (is_BoolVar(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_clause_93(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(clause(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(clause(X0,X1,X2,X3,X4,X5),arg=5)))) + ; throw(gecode_argument_error(clause(X0,X1,X2,X3,X4,X5),arg=4))) + ; throw(gecode_argument_error(clause(X0,X1,X2,X3,X4,X5),arg=3))) + ; throw(gecode_argument_error(clause(X0,X1,X2,X3,X4,X5),arg=2))) + ; throw(gecode_argument_error(clause(X0,X1,X2,X3,X4,X5),arg=1))). + +precede(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_int(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_precede_372(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))) + ; throw(gecode_argument_error(precede(X0,X1,X2,X3,X4),arg=2))) + ; throw(gecode_argument_error(precede(X0,X1,X2,X3,X4),arg=1))). + +argmax(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> gecode_constraint_argmax_53(Y0,Y1,Y2) + ; throw(gecode_argument_error(argmax(X0,X1,X2),arg=3))) + ; throw(gecode_argument_error(argmax(X0,X1,X2),arg=2))) + ; throw(gecode_argument_error(argmax(X0,X1,X2),arg=1))). + +distinct(X0,X1) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> gecode_constraint_distinct_166(Y0,Y1) + ; throw(gecode_argument_error(distinct(X0,X1),arg=2))) + ; throw(gecode_argument_error(distinct(X0,X1),arg=1))). + +member(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_Reify(X3,Y3) + -> gecode_constraint_member_318(Y0,Y1,Y2,Y3) + ; (is_IntConLevel(X3,Y3) + -> gecode_constraint_member_317(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_314(Y0,Y1,Y2,Y3) + ; (is_IntConLevel(X3,Y3) + -> gecode_constraint_member_313(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)))) + ; throw(gecode_argument_error(member(X0,X1,X2,X3),arg=1))). + +mod(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntVar(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_mod_329(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))) + ; throw(gecode_argument_error(mod(X0,X1,X2,X3,X4),arg=2))) + ; throw(gecode_argument_error(mod(X0,X1,X2,X3,X4),arg=1))). + +cardinality(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_SetVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> gecode_constraint_cardinality_63(Y0,Y1,Y2) + ; throw(gecode_argument_error(cardinality(X0,X1,X2),arg=3))) + ; throw(gecode_argument_error(cardinality(X0,X1,X2),arg=2))) + ; throw(gecode_argument_error(cardinality(X0,X1,X2),arg=1))). + +atmostOne(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_SetVarArgs(X1,Y1) + -> (is_int(X2,Y2) + -> gecode_constraint_atmostOne_59(Y0,Y1,Y2) + ; throw(gecode_argument_error(atmostOne(X0,X1,X2),arg=3))) + ; throw(gecode_argument_error(atmostOne(X0,X1,X2),arg=2))) + ; throw(gecode_argument_error(atmostOne(X0,X1,X2),arg=1))). + +channelSorted(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_SetVar(X2,Y2) + -> gecode_constraint_channelSorted_79(Y0,Y1,Y2) + ; throw(gecode_argument_error(channelSorted(X0,X1,X2),arg=3))) + ; 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_259(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_254(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_278(Y0,Y1,Y2,Y3) + ; (is_FloatNum(X3,Y3) + -> gecode_constraint_linear_276(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_264(Y0,Y1,Y2,Y3) + ; (is_IntVar(X3,Y3) + -> gecode_constraint_linear_268(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_296(Y0,Y1,Y2,Y3) + ; (is_IntVar(X3,Y3) + -> gecode_constraint_linear_300(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))))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3),arg=1))). + +circuit(X0,X1) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> gecode_constraint_circuit_88(Y0,Y1) + ; throw(gecode_argument_error(circuit(X0,X1),arg=2))) + ; throw(gecode_argument_error(circuit(X0,X1),arg=1))). + +rel(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_FloatVar(X1,Y1) + -> (is_FloatRelType(X2,Y2) + -> (is_FloatVal(X3,Y3) + -> (is_Reify(X4,Y4) + -> gecode_constraint_rel_412(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_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)))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=3))) + ; (is_SetOpType(X1,Y1) + -> (is_SetVarArgs(X2,Y2) + -> (is_IntSet(X3,Y3) + -> (is_SetVar(X4,Y4) + -> gecode_constraint_rel_428(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_426(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)))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntRelType(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_rel_398(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_394(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_392(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))) + ; (is_BoolVar(X1,Y1) + -> (is_IntRelType(X2,Y2) + -> (is_int(X3,Y3) + -> (is_Reify(X4,Y4) + -> gecode_constraint_rel_389(Y0,Y1,Y2,Y3,Y4) + ; (is_IntConLevel(X4,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_Reify(X4,Y4) + -> gecode_constraint_rel_385(Y0,Y1,Y2,Y3,Y4) + ; (is_IntConLevel(X4,Y4) + -> gecode_constraint_rel_384(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_381(Y0,Y1,Y2,Y3,Y4) + ; (is_BoolVar(X4,Y4) + -> gecode_constraint_rel_379(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)))) + ; (is_IntVarArgs(X1,Y1) + -> (is_IntRelType(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_rel_408(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_410(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_404(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))) + ; (is_IntVar(X1,Y1) + -> (is_IntRelType(X2,Y2) + -> (is_int(X3,Y3) + -> (is_Reify(X4,Y4) + -> gecode_constraint_rel_417(Y0,Y1,Y2,Y3,Y4) + ; (is_IntConLevel(X4,Y4) + -> gecode_constraint_rel_416(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_421(Y0,Y1,Y2,Y3,Y4) + ; (is_IntConLevel(X4,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)))) + ; (is_SetRelType(X2,Y2) + -> (is_SetVar(X3,Y3) + -> (is_Reify(X4,Y4) + -> gecode_constraint_rel_425(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)))) + ; (is_SetVar(X1,Y1) + -> (is_SetRelType(X2,Y2) + -> (is_IntVar(X3,Y3) + -> (is_Reify(X4,Y4) + -> gecode_constraint_rel_436(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_438(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))) + ; (is_BoolOpType(X1,Y1) + -> (is_BoolVarArgs(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_rel_378(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) + ; 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))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=2)))))))))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4),arg=1))). + +min(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntVar(X3,Y3) + -> gecode_constraint_min_324(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_322(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_323(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_327(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)))))) + ; throw(gecode_argument_error(min(X0,X1,X2,X3),arg=1))). + +cardinality(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_SetVarArgs(X1,Y1) + -> (is_int(X2,Y2) + -> (is_int(X3,Y3) + -> gecode_constraint_cardinality_62(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(cardinality(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(cardinality(X0,X1,X2,X3),arg=3))) + ; (is_SetVar(X1,Y1) + -> (is_int(X2,Y2) + -> (is_int(X3,Y3) + -> gecode_constraint_cardinality_64(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(cardinality(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(cardinality(X0,X1,X2,X3),arg=3))) + ; throw(gecode_argument_error(cardinality(X0,X1,X2,X3),arg=2)))) + ; throw(gecode_argument_error(cardinality(X0,X1,X2,X3),arg=1))). + +count(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntConLevel(X3,Y3) + -> gecode_constraint_count_115(Y0,Y1,Y2,Y3) + ; (is_IntArgs(X3,Y3) + -> gecode_constraint_count_112(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(count(X0,X1,X2,X3),arg=4)))) + ; (is_IntSet(X2,Y2) + -> (is_IntArgs(X3,Y3) + -> gecode_constraint_count_106(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(count(X0,X1,X2,X3),arg=4))) + ; (is_IntSetArgs(X2,Y2) + -> (is_IntConLevel(X3,Y3) + -> gecode_constraint_count_105(Y0,Y1,Y2,Y3) + ; (is_IntArgs(X3,Y3) + -> gecode_constraint_count_102(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(count(X0,X1,X2,X3),arg=4)))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3),arg=3))))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3),arg=2))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3),arg=1))). + +sqrt(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> gecode_constraint_sqrt_453(Y0,Y1,Y2) + ; throw(gecode_argument_error(sqrt(X0,X1,X2),arg=3))) + ; (is_FloatVar(X1,Y1) + -> (is_FloatVar(X2,Y2) + -> gecode_constraint_sqrt_452(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))). + +cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVarArgs(X4,Y4) + -> (is_IntVarArgs(X5,Y5) + -> (is_IntArgs(X6,Y6) + -> (is_bool(X7,Y7) + -> (is_IntConLevel(X8,Y8) + -> gecode_constraint_cumulatives_163(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7,Y8) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=9))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=8))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=7))) + ; (is_IntArgs(X5,Y5) + -> (is_IntArgs(X6,Y6) + -> (is_bool(X7,Y7) + -> (is_IntConLevel(X8,Y8) + -> gecode_constraint_cumulatives_161(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7,Y8) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=9))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=8))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=7))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=6)))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=5))) + ; (is_IntArgs(X3,Y3) + -> (is_IntVarArgs(X4,Y4) + -> (is_IntVarArgs(X5,Y5) + -> (is_IntArgs(X6,Y6) + -> (is_bool(X7,Y7) + -> (is_IntConLevel(X8,Y8) + -> gecode_constraint_cumulatives_159(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7,Y8) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=9))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=8))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=7))) + ; (is_IntArgs(X5,Y5) + -> (is_IntArgs(X6,Y6) + -> (is_bool(X7,Y7) + -> (is_IntConLevel(X8,Y8) + -> gecode_constraint_cumulatives_157(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7,Y8) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=9))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=8))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=7))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=6)))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=5))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=4)))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=3))) + ; (is_IntArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVarArgs(X4,Y4) + -> (is_IntVarArgs(X5,Y5) + -> (is_IntArgs(X6,Y6) + -> (is_bool(X7,Y7) + -> (is_IntConLevel(X8,Y8) + -> gecode_constraint_cumulatives_155(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7,Y8) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=9))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=8))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=7))) + ; (is_IntArgs(X5,Y5) + -> (is_IntArgs(X6,Y6) + -> (is_bool(X7,Y7) + -> (is_IntConLevel(X8,Y8) + -> gecode_constraint_cumulatives_153(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7,Y8) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=9))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=8))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=7))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=6)))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=5))) + ; (is_IntArgs(X3,Y3) + -> (is_IntVarArgs(X4,Y4) + -> (is_IntVarArgs(X5,Y5) + -> (is_IntArgs(X6,Y6) + -> (is_bool(X7,Y7) + -> (is_IntConLevel(X8,Y8) + -> gecode_constraint_cumulatives_151(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7,Y8) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=9))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=8))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=7))) + ; (is_IntArgs(X5,Y5) + -> (is_IntArgs(X6,Y6) + -> (is_bool(X7,Y7) + -> (is_IntConLevel(X8,Y8) + -> gecode_constraint_cumulatives_149(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7,Y8) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=9))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=8))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=7))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=6)))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=5))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=4)))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=3))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=2)))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=1))). + +nvalues(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntRelType(X2,Y2) + -> (is_int(X3,Y3) + -> gecode_constraint_nvalues_350(Y0,Y1,Y2,Y3) + ; (is_IntVar(X3,Y3) + -> gecode_constraint_nvalues_352(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_346(Y0,Y1,Y2,Y3) + ; (is_IntVar(X3,Y3) + -> gecode_constraint_nvalues_348(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)))) + ; throw(gecode_argument_error(nvalues(X0,X1,X2,X3),arg=1))). + +binpacking(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntArgs(X3,Y3) + -> gecode_constraint_binpacking_60(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(binpacking(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(binpacking(X0,X1,X2,X3),arg=3))) + ; throw(gecode_argument_error(binpacking(X0,X1,X2,X3),arg=2))) + ; throw(gecode_argument_error(binpacking(X0,X1,X2,X3),arg=1))). + +linear(X0,X1,X2,X3,X4,X5,X6) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntRelType(X3,Y3) + -> (is_int(X4,Y4) + -> (is_Reify(X5,Y5) + -> (is_IntConLevel(X6,Y6) + -> gecode_constraint_linear_291(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_295(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)))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5,X6),arg=4))) + ; (is_BoolVarArgs(X2,Y2) + -> (is_IntRelType(X3,Y3) + -> (is_int(X4,Y4) + -> (is_Reify(X5,Y5) + -> (is_IntConLevel(X6,Y6) + -> gecode_constraint_linear_283(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_287(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)))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5,X6),arg=4))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5,X6),arg=3)))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5,X6),arg=2))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5,X6),arg=1))). + +abs(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntConLevel(X3,Y3) + -> gecode_constraint_abs_52(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(abs(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(abs(X0,X1,X2,X3),arg=3))) + ; throw(gecode_argument_error(abs(X0,X1,X2,X3),arg=2))) + ; throw(gecode_argument_error(abs(X0,X1,X2,X3),arg=1))). + +convex(X0,X1) :- + (is_Space_or_Clause(X0,Y0) + -> (is_SetVar(X1,Y1) + -> gecode_constraint_convex_96(Y0,Y1) + ; throw(gecode_argument_error(convex(X0,X1),arg=2))) + ; throw(gecode_argument_error(convex(X0,X1),arg=1))). + +div(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntVar(X3,Y3) + -> gecode_constraint_div_169(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(div(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(div(X0,X1,X2,X3),arg=3))) + ; (is_FloatVar(X1,Y1) + -> (is_FloatVar(X2,Y2) + -> (is_FloatVar(X3,Y3) + -> gecode_constraint_div_168(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(div(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(div(X0,X1,X2,X3),arg=3))) + ; throw(gecode_argument_error(div(X0,X1,X2,X3),arg=2)))) + ; throw(gecode_argument_error(div(X0,X1,X2,X3),arg=1))). + +rel(X0,X1,X2,X3,X4,X5) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntRelType(X2,Y2) + -> (is_int(X3,Y3) + -> (is_Reify(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_rel_418(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_422(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)))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=3))) + ; (is_IntSet(X1,Y1) + -> (is_SetOpType(X2,Y2) + -> (is_SetVar(X3,Y3) + -> (is_SetRelType(X4,Y4) + -> (is_IntSet(X5,Y5) + -> gecode_constraint_rel_401(Y0,Y1,Y2,Y3,Y4,Y5) + ; (is_SetVar(X5,Y5) + -> gecode_constraint_rel_402(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))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=3))) + ; (is_BoolVar(X1,Y1) + -> (is_IntRelType(X2,Y2) + -> (is_int(X3,Y3) + -> (is_Reify(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_rel_390(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_386(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)))) + ; (is_BoolOpType(X2,Y2) + -> (is_BoolVar(X3,Y3) + -> (is_int(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_rel_382(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_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))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=3)))) + ; (is_SetVar(X1,Y1) + -> (is_SetOpType(X2,Y2) + -> (is_IntSet(X3,Y3) + -> (is_SetRelType(X4,Y4) + -> (is_IntSet(X5,Y5) + -> gecode_constraint_rel_431(Y0,Y1,Y2,Y3,Y4,Y5) + ; (is_SetVar(X5,Y5) + -> gecode_constraint_rel_432(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_433(Y0,Y1,Y2,Y3,Y4,Y5) + ; (is_SetVar(X5,Y5) + -> gecode_constraint_rel_434(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)))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=3))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=2)))))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3,X4,X5),arg=1))). + +weights(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntArgs(X1,Y1) + -> (is_IntArgs(X2,Y2) + -> (is_SetVar(X3,Y3) + -> (is_IntVar(X4,Y4) + -> gecode_constraint_weights_471(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))) + ; throw(gecode_argument_error(weights(X0,X1,X2,X3,X4),arg=2))) + ; throw(gecode_argument_error(weights(X0,X1,X2,X3,X4),arg=1))). + +max(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntVar(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_max_309(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))) + ; throw(gecode_argument_error(max(X0,X1,X2,X3,X4),arg=2))) + ; throw(gecode_argument_error(max(X0,X1,X2,X3,X4),arg=1))). + +path(X0,X1,X2,X3,X4,X5,X6,X7,X8) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntArgs(X1,Y1) + -> (is_int(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVar(X4,Y4) + -> (is_IntVar(X5,Y5) + -> (is_IntVarArgs(X6,Y6) + -> (is_IntVar(X7,Y7) + -> (is_IntConLevel(X8,Y8) + -> gecode_constraint_path_359(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))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=6))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=5))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=4))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=3))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=2))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=1))). + +unary(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_TaskTypeArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntArgs(X3,Y3) + -> gecode_constraint_unary_465(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_461(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_455(Y0,Y1,Y2,Y3) + ; (is_IntConLevel(X3,Y3) + -> gecode_constraint_unary_458(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)))) + ; throw(gecode_argument_error(unary(X0,X1,X2,X3),arg=1))). + +nroot(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_int(X2,Y2) + -> (is_IntVar(X3,Y3) + -> gecode_constraint_nroot_344(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_343(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)))) + ; throw(gecode_argument_error(nroot(X0,X1,X2,X3),arg=1))). + +sorted(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_sorted_446(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))) + ; throw(gecode_argument_error(sorted(X0,X1,X2,X3,X4),arg=2))) + ; throw(gecode_argument_error(sorted(X0,X1,X2,X3,X4),arg=1))). + +circuit(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntArgs(X1,Y1) + -> (is_int(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVar(X4,Y4) + -> gecode_constraint_circuit_86(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4),arg=4))) + ; (is_IntVarArgs(X2,Y2) + -> (is_IntVar(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_circuit_83(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4),arg=5))) + ; (is_IntVarArgs(X3,Y3) + -> (is_IntVar(X4,Y4) + -> gecode_constraint_circuit_80(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4),arg=4)))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4),arg=3)))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4),arg=2))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4),arg=1))). + +dom(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_FloatVar(X1,Y1) + -> (is_FloatVal(X2,Y2) + -> (is_Reify(X3,Y3) + -> gecode_constraint_dom_195(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3),arg=4))) + ; (is_FloatNum(X2,Y2) + -> (is_FloatNum(X3,Y3) + -> gecode_constraint_dom_192(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3),arg=3)))) + ; (is_FloatVarArgs(X1,Y1) + -> (is_FloatNum(X2,Y2) + -> (is_FloatNum(X3,Y3) + -> gecode_constraint_dom_178(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_BoolVarArgs(X2,Y2) + -> (is_IntConLevel(X3,Y3) + -> gecode_constraint_dom_176(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3),arg=3))) + ; (is_BoolVar(X1,Y1) + -> (is_BoolVar(X2,Y2) + -> (is_IntConLevel(X3,Y3) + -> gecode_constraint_dom_174(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3),arg=3))) + ; (is_IntVarArgs(X1,Y1) + -> (is_int(X2,Y2) + -> (is_int(X3,Y3) + -> gecode_constraint_dom_186(Y0,Y1,Y2,Y3) + ; (is_IntConLevel(X3,Y3) + -> gecode_constraint_dom_185(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3),arg=4)))) + ; (is_IntVarArgs(X2,Y2) + -> (is_IntConLevel(X3,Y3) + -> gecode_constraint_dom_183(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3),arg=4))) + ; (is_IntSet(X2,Y2) + -> (is_IntConLevel(X3,Y3) + -> gecode_constraint_dom_181(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3),arg=3))))) + ; (is_IntVar(X1,Y1) + -> (is_int(X2,Y2) + -> (is_int(X3,Y3) + -> gecode_constraint_dom_203(Y0,Y1,Y2,Y3) + ; (is_Reify(X3,Y3) + -> gecode_constraint_dom_207(Y0,Y1,Y2,Y3) + ; (is_IntConLevel(X3,Y3) + -> gecode_constraint_dom_202(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3),arg=4))))) + ; (is_IntVar(X2,Y2) + -> (is_IntConLevel(X3,Y3) + -> gecode_constraint_dom_210(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3),arg=4))) + ; (is_IntSet(X2,Y2) + -> (is_Reify(X3,Y3) + -> gecode_constraint_dom_199(Y0,Y1,Y2,Y3) + ; (is_IntConLevel(X3,Y3) + -> gecode_constraint_dom_198(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3),arg=4)))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3),arg=3))))) + ; (is_SetVarArgs(X1,Y1) + -> (is_SetRelType(X2,Y2) + -> (is_int(X3,Y3) + -> gecode_constraint_dom_190(Y0,Y1,Y2,Y3) + ; (is_IntSet(X3,Y3) + -> gecode_constraint_dom_189(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3),arg=4)))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3),arg=3))) + ; (is_SetVar(X1,Y1) + -> (is_SetRelType(X2,Y2) + -> (is_int(X3,Y3) + -> gecode_constraint_dom_213(Y0,Y1,Y2,Y3) + ; (is_IntSet(X3,Y3) + -> gecode_constraint_dom_211(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3),arg=4)))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3),arg=3))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3),arg=2)))))))))) + ; throw(gecode_argument_error(dom(X0,X1,X2,X3),arg=1))). + +abs(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> gecode_constraint_abs_51(Y0,Y1,Y2) + ; throw(gecode_argument_error(abs(X0,X1,X2),arg=3))) + ; (is_FloatVar(X1,Y1) + -> (is_FloatVar(X2,Y2) + -> gecode_constraint_abs_50(Y0,Y1,Y2) + ; throw(gecode_argument_error(abs(X0,X1,X2),arg=3))) + ; throw(gecode_argument_error(abs(X0,X1,X2),arg=2)))) + ; throw(gecode_argument_error(abs(X0,X1,X2),arg=1))). + +channel(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_int(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_int(X4,Y4) + -> gecode_constraint_channel_74(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3,X4),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_channel_69(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3,X4),arg=3))) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3,X4),arg=2)))) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3,X4),arg=1))). + +assign(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_FloatVarArgs(X1,Y1) + -> (is_FloatAssign(X2,Y2) + -> (is_FloatBranchFilter(X3,Y3) + -> (is_FloatVarValPrint(X4,Y4) + -> gecode_constraint_assign_8(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(assign(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(assign(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(assign(X0,X1,X2,X3,X4),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntAssign(X2,Y2) + -> (is_BoolBranchFilter(X3,Y3) + -> (is_BoolVarValPrint(X4,Y4) + -> gecode_constraint_assign_5(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(assign(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(assign(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(assign(X0,X1,X2,X3,X4),arg=3))) + ; (is_IntVarArgs(X1,Y1) + -> (is_IntAssign(X2,Y2) + -> (is_IntBranchFilter(X3,Y3) + -> (is_IntVarValPrint(X4,Y4) + -> gecode_constraint_assign_11(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(assign(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(assign(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(assign(X0,X1,X2,X3,X4),arg=3))) + ; (is_SetVarArgs(X1,Y1) + -> (is_SetAssign(X2,Y2) + -> (is_SetBranchFilter(X3,Y3) + -> (is_SetVarValPrint(X4,Y4) + -> gecode_constraint_assign_14(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(assign(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(assign(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(assign(X0,X1,X2,X3,X4),arg=3))) + ; throw(gecode_argument_error(assign(X0,X1,X2,X3,X4),arg=2)))))) + ; throw(gecode_argument_error(assign(X0,X1,X2,X3,X4),arg=1))). + +rel(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntRelType(X2,Y2) + -> gecode_constraint_rel_405(Y0,Y1,Y2) + ; throw(gecode_argument_error(rel(X0,X1,X2),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntRelType(X2,Y2) + -> gecode_constraint_rel_395(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))). + +path(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntVar(X3,Y3) + -> gecode_constraint_path_362(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))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3),arg=1))). + +branch(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_FloatVar(X1,Y1) + -> (is_FloatValBranch(X2,Y2) + -> (is_FloatVarValPrint(X3,Y3) + -> gecode_constraint_branch_45(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3),arg=3))) + ; (is_FloatVarArgs(X1,Y1) + -> (is_FloatVarBranch(X2,Y2) + -> (is_FloatValBranch(X3,Y3) + -> gecode_constraint_branch_29(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntVarBranch(X2,Y2) + -> (is_IntValBranch(X3,Y3) + -> gecode_constraint_branch_23(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3),arg=3))) + ; (is_BoolVar(X1,Y1) + -> (is_IntValBranch(X2,Y2) + -> (is_BoolVarValPrint(X3,Y3) + -> gecode_constraint_branch_22(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3),arg=3))) + ; (is_IntVarArgs(X1,Y1) + -> (is_IntVarBranch(X2,Y2) + -> (is_IntValBranch(X3,Y3) + -> gecode_constraint_branch_35(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3),arg=3))) + ; (is_IntVar(X1,Y1) + -> (is_IntValBranch(X2,Y2) + -> (is_IntVarValPrint(X3,Y3) + -> gecode_constraint_branch_47(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3),arg=3))) + ; (is_SetVarArgs(X1,Y1) + -> (is_SetVarBranch(X2,Y2) + -> (is_SetValBranch(X3,Y3) + -> gecode_constraint_branch_41(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3),arg=3))) + ; (is_SetVar(X1,Y1) + -> (is_SetValBranch(X2,Y2) + -> (is_SetVarValPrint(X3,Y3) + -> gecode_constraint_branch_49(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3),arg=3))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3),arg=2)))))))))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3),arg=1))). + +mult(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntVar(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_mult_332(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))) + ; throw(gecode_argument_error(mult(X0,X1,X2,X3,X4),arg=2))) + ; throw(gecode_argument_error(mult(X0,X1,X2,X3,X4),arg=1))). + +circuit(X0,X1,X2,X3,X4,X5) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntArgs(X1,Y1) + -> (is_int(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVar(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_circuit_87(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4,X5),arg=6))) + ; (is_IntVarArgs(X4,Y4) + -> (is_IntVar(X5,Y5) + -> gecode_constraint_circuit_84(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4,X5),arg=5)))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4,X5),arg=4))) + ; (is_IntVarArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVar(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_circuit_81(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4,X5),arg=4))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4,X5),arg=3)))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4,X5),arg=2))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4,X5),arg=1))). + +clause(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_BoolOpType(X1,Y1) + -> (is_BoolVarArgs(X2,Y2) + -> (is_BoolVarArgs(X3,Y3) + -> (is_int(X4,Y4) + -> gecode_constraint_clause_94(Y0,Y1,Y2,Y3,Y4) + ; (is_BoolVar(X4,Y4) + -> gecode_constraint_clause_92(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(clause(X0,X1,X2,X3,X4),arg=5)))) + ; throw(gecode_argument_error(clause(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(clause(X0,X1,X2,X3,X4),arg=3))) + ; throw(gecode_argument_error(clause(X0,X1,X2,X3,X4),arg=2))) + ; throw(gecode_argument_error(clause(X0,X1,X2,X3,X4),arg=1))). + +precede(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_SetVarArgs(X1,Y1) + -> (is_int(X2,Y2) + -> (is_int(X3,Y3) + -> gecode_constraint_precede_374(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_371(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_370(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)))) + ; throw(gecode_argument_error(precede(X0,X1,X2,X3),arg=1))). + +channel(X0,X1,X2,X3,X4,X5) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_int(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_int(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_channel_75(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3,X4,X5),arg=4))) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3,X4,X5),arg=3))) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3,X4,X5),arg=2))) + ; throw(gecode_argument_error(channel(X0,X1,X2,X3,X4,X5),arg=1))). + +cumulative(X0,X1,X2,X3,X4,X5,X6) :- + (is_Space_or_Clause(X0,Y0) + -> (is_int(X1,Y1) + -> (is_TaskTypeArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntArgs(X4,Y4) + -> (is_IntArgs(X5,Y5) + -> (is_BoolVarArgs(X6,Y6) + -> gecode_constraint_cumulative_132(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; (is_IntConLevel(X6,Y6) + -> gecode_constraint_cumulative_135(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=7)))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=6))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=5))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=4))) + ; (is_IntVarArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVarArgs(X4,Y4) + -> (is_IntArgs(X5,Y5) + -> (is_BoolVarArgs(X6,Y6) + -> gecode_constraint_cumulative_128(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; (is_IntConLevel(X6,Y6) + -> gecode_constraint_cumulative_131(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=7)))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=6))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=5))) + ; (is_IntArgs(X3,Y3) + -> (is_IntArgs(X4,Y4) + -> (is_BoolVarArgs(X5,Y5) + -> (is_IntConLevel(X6,Y6) + -> gecode_constraint_cumulative_125(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=7))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=6))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=5))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=4)))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=3)))) + ; (is_IntVar(X1,Y1) + -> (is_TaskTypeArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntArgs(X4,Y4) + -> (is_IntArgs(X5,Y5) + -> (is_BoolVarArgs(X6,Y6) + -> gecode_constraint_cumulative_144(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; (is_IntConLevel(X6,Y6) + -> gecode_constraint_cumulative_147(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=7)))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=6))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=5))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=4))) + ; (is_IntVarArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVarArgs(X4,Y4) + -> (is_IntArgs(X5,Y5) + -> (is_BoolVarArgs(X6,Y6) + -> gecode_constraint_cumulative_140(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; (is_IntConLevel(X6,Y6) + -> gecode_constraint_cumulative_143(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=7)))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=6))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=5))) + ; (is_IntArgs(X3,Y3) + -> (is_IntArgs(X4,Y4) + -> (is_BoolVarArgs(X5,Y5) + -> (is_IntConLevel(X6,Y6) + -> gecode_constraint_cumulative_137(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=7))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=6))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=5))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=4)))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=3)))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=2)))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6),arg=1))). + +distinct(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntConLevel(X2,Y2) + -> gecode_constraint_distinct_167(Y0,Y1,Y2) + ; throw(gecode_argument_error(distinct(X0,X1,X2),arg=3))) + ; (is_IntArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> gecode_constraint_distinct_164(Y0,Y1,Y2) + ; throw(gecode_argument_error(distinct(X0,X1,X2),arg=3))) + ; throw(gecode_argument_error(distinct(X0,X1,X2),arg=2)))) + ; throw(gecode_argument_error(distinct(X0,X1,X2),arg=1))). + +member(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_Reify(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_member_319(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))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_BoolVar(X2,Y2) + -> (is_Reify(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_member_315(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))) + ; throw(gecode_argument_error(member(X0,X1,X2,X3,X4),arg=2)))) + ; throw(gecode_argument_error(member(X0,X1,X2,X3,X4),arg=1))). + +mod(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntVar(X3,Y3) + -> gecode_constraint_mod_328(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))) + ; throw(gecode_argument_error(mod(X0,X1,X2,X3),arg=1))). + +sqr(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> gecode_constraint_sqr_450(Y0,Y1,Y2) + ; throw(gecode_argument_error(sqr(X0,X1,X2),arg=3))) + ; (is_FloatVar(X1,Y1) + -> (is_FloatVar(X2,Y2) + -> gecode_constraint_sqr_449(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))). + +sequence(X0,X1,X2,X3,X4,X5,X6) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntSet(X2,Y2) + -> (is_int(X3,Y3) + -> (is_int(X4,Y4) + -> (is_int(X5,Y5) + -> (is_IntConLevel(X6,Y6) + -> gecode_constraint_sequence_442(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))) + ; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5,X6),arg=4))) + ; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5,X6),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntSet(X2,Y2) + -> (is_int(X3,Y3) + -> (is_int(X4,Y4) + -> (is_int(X5,Y5) + -> (is_IntConLevel(X6,Y6) + -> gecode_constraint_sequence_440(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))) + ; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5,X6),arg=4))) + ; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5,X6),arg=3))) + ; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5,X6),arg=2)))) + ; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5,X6),arg=1))). + +path(X0,X1,X2,X3,X4,X5,X6) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntArgs(X1,Y1) + -> (is_int(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVar(X4,Y4) + -> (is_IntVar(X5,Y5) + -> (is_IntVar(X6,Y6) + -> gecode_constraint_path_360(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))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6),arg=4))) + ; (is_IntVarArgs(X2,Y2) + -> (is_IntVar(X3,Y3) + -> (is_IntVar(X4,Y4) + -> (is_IntVar(X5,Y5) + -> (is_IntConLevel(X6,Y6) + -> gecode_constraint_path_357(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_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))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6),arg=4))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6),arg=3)))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6),arg=2))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6),arg=1))). + +divmod(X0,X1,X2,X3,X4,X5) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntVar(X3,Y3) + -> (is_IntVar(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_divmod_172(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(divmod(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(divmod(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(divmod(X0,X1,X2,X3,X4,X5),arg=4))) + ; throw(gecode_argument_error(divmod(X0,X1,X2,X3,X4,X5),arg=3))) + ; throw(gecode_argument_error(divmod(X0,X1,X2,X3,X4,X5),arg=2))) + ; throw(gecode_argument_error(divmod(X0,X1,X2,X3,X4,X5),arg=1))). + +sorted(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> gecode_constraint_sorted_447(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_258(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_261(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_253(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_256(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) + -> (is_IntVarArgs(X2,Y2) + -> gecode_constraint_circuit_90(Y0,Y1,Y2) + ; throw(gecode_argument_error(circuit(X0,X1,X2),arg=3))) + ; (is_IntVarArgs(X1,Y1) + -> (is_IntConLevel(X2,Y2) + -> gecode_constraint_circuit_89(Y0,Y1,Y2) + ; throw(gecode_argument_error(circuit(X0,X1,X2),arg=3))) + ; throw(gecode_argument_error(circuit(X0,X1,X2),arg=2)))) + ; throw(gecode_argument_error(circuit(X0,X1,X2),arg=1))). + +argmin(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_bool(X3,Y3) + -> gecode_constraint_argmin_57(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(argmin(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(argmin(X0,X1,X2,X3),arg=3))) + ; throw(gecode_argument_error(argmin(X0,X1,X2,X3),arg=2))) + ; throw(gecode_argument_error(argmin(X0,X1,X2,X3),arg=1))). + +channel(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_FloatVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> gecode_constraint_channel_77(Y0,Y1,Y2) + ; throw(gecode_argument_error(channel(X0,X1,X2),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> gecode_constraint_channel_67(Y0,Y1,Y2) + ; (is_SetVar(X2,Y2) + -> gecode_constraint_channel_70(Y0,Y1,Y2) + ; throw(gecode_argument_error(channel(X0,X1,X2),arg=3)))) + ; (is_BoolVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> gecode_constraint_channel_65(Y0,Y1,Y2) + ; throw(gecode_argument_error(channel(X0,X1,X2),arg=3))) + ; (is_IntVarArgs(X1,Y1) + -> (is_SetVarArgs(X2,Y2) + -> gecode_constraint_channel_73(Y0,Y1,Y2) + ; (is_IntVarArgs(X2,Y2) + -> gecode_constraint_channel_71(Y0,Y1,Y2) + ; throw(gecode_argument_error(channel(X0,X1,X2),arg=3)))) + ; (is_IntVar(X1,Y1) + -> (is_FloatVar(X2,Y2) + -> gecode_constraint_channel_78(Y0,Y1,Y2) + ; throw(gecode_argument_error(channel(X0,X1,X2),arg=3))) + ; (is_SetVarArgs(X1,Y1) + -> (is_SetVarArgs(X2,Y2) + -> gecode_constraint_channel_76(Y0,Y1,Y2) + ; throw(gecode_argument_error(channel(X0,X1,X2),arg=3))) + ; throw(gecode_argument_error(channel(X0,X1,X2),arg=2)))))))) + ; throw(gecode_argument_error(channel(X0,X1,X2),arg=1))). + +count(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntArgs(X2,Y2) + -> (is_IntRelType(X3,Y3) + -> (is_int(X4,Y4) + -> gecode_constraint_count_98(Y0,Y1,Y2,Y3,Y4) + ; (is_IntVar(X4,Y4) + -> gecode_constraint_count_100(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4),arg=5)))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4),arg=4))) + ; (is_int(X2,Y2) + -> (is_IntRelType(X3,Y3) + -> (is_int(X4,Y4) + -> gecode_constraint_count_116(Y0,Y1,Y2,Y3,Y4) + ; (is_IntVar(X4,Y4) + -> gecode_constraint_count_118(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4),arg=5)))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4),arg=4))) + ; (is_IntSet(X2,Y2) + -> (is_IntRelType(X3,Y3) + -> (is_int(X4,Y4) + -> gecode_constraint_count_108(Y0,Y1,Y2,Y3,Y4) + ; (is_IntVar(X4,Y4) + -> gecode_constraint_count_110(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4),arg=5)))) + ; (is_IntArgs(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_count_107(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4),arg=4)))) + ; (is_IntSetArgs(X2,Y2) + -> (is_IntArgs(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_count_103(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4),arg=4))) + ; (is_IntVarArgs(X2,Y2) + -> (is_IntArgs(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_count_113(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4),arg=4))) + ; (is_IntVar(X2,Y2) + -> (is_IntRelType(X3,Y3) + -> (is_int(X4,Y4) + -> gecode_constraint_count_120(Y0,Y1,Y2,Y3,Y4) + ; (is_IntVar(X4,Y4) + -> gecode_constraint_count_122(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4),arg=5)))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4),arg=3)))))))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4),arg=2))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4),arg=1))). + +cumulatives(X0,X1,X2,X3,X4,X5,X6,X7) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVarArgs(X4,Y4) + -> (is_IntVarArgs(X5,Y5) + -> (is_IntArgs(X6,Y6) + -> (is_bool(X7,Y7) + -> gecode_constraint_cumulatives_162(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=8))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=7))) + ; (is_IntArgs(X5,Y5) + -> (is_IntArgs(X6,Y6) + -> (is_bool(X7,Y7) + -> gecode_constraint_cumulatives_160(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=8))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=7))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=6)))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=5))) + ; (is_IntArgs(X3,Y3) + -> (is_IntVarArgs(X4,Y4) + -> (is_IntVarArgs(X5,Y5) + -> (is_IntArgs(X6,Y6) + -> (is_bool(X7,Y7) + -> gecode_constraint_cumulatives_158(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=8))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=7))) + ; (is_IntArgs(X5,Y5) + -> (is_IntArgs(X6,Y6) + -> (is_bool(X7,Y7) + -> gecode_constraint_cumulatives_156(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=8))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=7))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=6)))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=5))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=4)))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=3))) + ; (is_IntArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVarArgs(X4,Y4) + -> (is_IntVarArgs(X5,Y5) + -> (is_IntArgs(X6,Y6) + -> (is_bool(X7,Y7) + -> gecode_constraint_cumulatives_154(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=8))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=7))) + ; (is_IntArgs(X5,Y5) + -> (is_IntArgs(X6,Y6) + -> (is_bool(X7,Y7) + -> gecode_constraint_cumulatives_152(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=8))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=7))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=6)))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=5))) + ; (is_IntArgs(X3,Y3) + -> (is_IntVarArgs(X4,Y4) + -> (is_IntVarArgs(X5,Y5) + -> (is_IntArgs(X6,Y6) + -> (is_bool(X7,Y7) + -> gecode_constraint_cumulatives_150(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=8))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=7))) + ; (is_IntArgs(X5,Y5) + -> (is_IntArgs(X6,Y6) + -> (is_bool(X7,Y7) + -> gecode_constraint_cumulatives_148(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=8))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=7))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=6)))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=5))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=4)))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=3))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=2)))) + ; throw(gecode_argument_error(cumulatives(X0,X1,X2,X3,X4,X5,X6,X7),arg=1))). + +binpacking(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntArgs(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_binpacking_61(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(binpacking(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(binpacking(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(binpacking(X0,X1,X2,X3,X4),arg=3))) + ; 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_257(Y0,Y1,Y2) + ; (is_DFA(X2,Y2) + -> gecode_constraint_extensional_260(Y0,Y1,Y2) + ; throw(gecode_argument_error(extensional(X0,X1,X2),arg=3)))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_TupleSet(X2,Y2) + -> gecode_constraint_extensional_252(Y0,Y1,Y2) + ; (is_DFA(X2,Y2) + -> gecode_constraint_extensional_255(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) + -> (is_IntRelType(X2,Y2) + -> (is_int(X3,Y3) + -> (is_Reify(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_linear_299(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_303(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)))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntRelType(X2,Y2) + -> (is_int(X3,Y3) + -> (is_Reify(X4,Y4) + -> (is_IntConLevel(X5,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))) + ; (is_IntVar(X3,Y3) + -> (is_Reify(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_linear_271(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)))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=3))) + ; (is_FloatValArgs(X1,Y1) + -> (is_FloatVarArgs(X2,Y2) + -> (is_FloatRelType(X3,Y3) + -> (is_FloatVar(X4,Y4) + -> (is_Reify(X5,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_FloatNum(X4,Y4) + -> (is_Reify(X5,Y5) + -> gecode_constraint_linear_273(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))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=3))) + ; (is_IntArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntRelType(X3,Y3) + -> (is_int(X4,Y4) + -> (is_Reify(X5,Y5) + -> gecode_constraint_linear_290(Y0,Y1,Y2,Y3,Y4,Y5) + ; (is_IntConLevel(X5,Y5) + -> gecode_constraint_linear_289(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_294(Y0,Y1,Y2,Y3,Y4,Y5) + ; (is_IntConLevel(X5,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)))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=4))) + ; (is_BoolVarArgs(X2,Y2) + -> (is_IntRelType(X3,Y3) + -> (is_int(X4,Y4) + -> (is_Reify(X5,Y5) + -> gecode_constraint_linear_282(Y0,Y1,Y2,Y3,Y4,Y5) + ; (is_IntConLevel(X5,Y5) + -> gecode_constraint_linear_281(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_286(Y0,Y1,Y2,Y3,Y4,Y5) + ; (is_IntConLevel(X5,Y5) + -> gecode_constraint_linear_285(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))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=3)))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=2)))))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4,X5),arg=1))). + +nooverlap(X0,X1,X2,X3,X4,X5,X6) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVarArgs(X4,Y4) + -> (is_IntVarArgs(X5,Y5) + -> (is_IntVarArgs(X6,Y6) + -> gecode_constraint_nooverlap_339(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))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6),arg=4))) + ; (is_IntArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntArgs(X4,Y4) + -> (is_BoolVarArgs(X5,Y5) + -> (is_IntConLevel(X6,Y6) + -> gecode_constraint_nooverlap_334(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))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6),arg=4))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6),arg=3)))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6),arg=2))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6),arg=1))). + +div(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntVar(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_div_170(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(div(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(div(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(div(X0,X1,X2,X3,X4),arg=3))) + ; throw(gecode_argument_error(div(X0,X1,X2,X3,X4),arg=2))) + ; throw(gecode_argument_error(div(X0,X1,X2,X3,X4),arg=1))). + +sqr(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntConLevel(X3,Y3) + -> gecode_constraint_sqr_451(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))) + ; throw(gecode_argument_error(sqr(X0,X1,X2,X3),arg=1))). + +path(X0,X1,X2,X3,X4,X5,X6,X7) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntArgs(X1,Y1) + -> (is_int(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVar(X4,Y4) + -> (is_IntVar(X5,Y5) + -> (is_IntVar(X6,Y6) + -> (is_IntConLevel(X7,Y7) + -> gecode_constraint_path_361(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_358(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))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7),arg=5))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7),arg=4))) + ; (is_IntVarArgs(X2,Y2) + -> (is_IntVar(X3,Y3) + -> (is_IntVar(X4,Y4) + -> (is_IntVarArgs(X5,Y5) + -> (is_IntVar(X6,Y6) + -> (is_IntConLevel(X7,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))) + ; 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))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7),arg=5))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7),arg=4))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7),arg=3)))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7),arg=2))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5,X6,X7),arg=1))). + +unary(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_TaskTypeArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntArgs(X3,Y3) + -> (is_BoolVarArgs(X4,Y4) + -> gecode_constraint_unary_463(Y0,Y1,Y2,Y3,Y4) + ; (is_IntConLevel(X4,Y4) + -> gecode_constraint_unary_466(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))) + ; (is_IntVarArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_BoolVarArgs(X4,Y4) + -> gecode_constraint_unary_459(Y0,Y1,Y2,Y3,Y4) + ; (is_IntConLevel(X4,Y4) + -> gecode_constraint_unary_462(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_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))) + ; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4),arg=3)))) + ; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4),arg=2)))) + ; throw(gecode_argument_error(unary(X0,X1,X2,X3,X4),arg=1))). + +sorted(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> gecode_constraint_sorted_445(Y0,Y1,Y2,Y3) + ; (is_IntConLevel(X3,Y3) + -> gecode_constraint_sorted_448(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))) + ; throw(gecode_argument_error(sorted(X0,X1,X2,X3),arg=1))). + +element(X0,X1,X2,X3,X4,X5,X6,X7) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntVar(X4,Y4) + -> (is_int(X5,Y5) + -> (is_IntVar(X6,Y6) + -> (is_IntConLevel(X7,Y7) + -> gecode_constraint_element_229(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=8))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=7))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=6))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=4))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntVar(X4,Y4) + -> (is_int(X5,Y5) + -> (is_BoolVar(X6,Y6) + -> (is_IntConLevel(X7,Y7) + -> gecode_constraint_element_223(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=8))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=7))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=6))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=4))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=3))) + ; (is_IntArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntVar(X4,Y4) + -> (is_int(X5,Y5) + -> (is_IntVar(X6,Y6) + -> (is_IntConLevel(X7,Y7) + -> gecode_constraint_element_241(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=8))) + ; (is_BoolVar(X6,Y6) + -> (is_IntConLevel(X7,Y7) + -> gecode_constraint_element_239(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=8))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=7)))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=6))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=4))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=3))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=2))))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5,X6,X7),arg=1))). + +assign(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_FloatVar(X1,Y1) + -> (is_FloatAssign(X2,Y2) + -> (is_FloatVarValPrint(X3,Y3) + -> gecode_constraint_assign_16(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(assign(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(assign(X0,X1,X2,X3),arg=3))) + ; (is_FloatVarArgs(X1,Y1) + -> (is_FloatAssign(X2,Y2) + -> (is_FloatBranchFilter(X3,Y3) + -> gecode_constraint_assign_7(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(assign(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(assign(X0,X1,X2,X3),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntAssign(X2,Y2) + -> (is_BoolBranchFilter(X3,Y3) + -> gecode_constraint_assign_4(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(assign(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(assign(X0,X1,X2,X3),arg=3))) + ; (is_BoolVar(X1,Y1) + -> (is_IntAssign(X2,Y2) + -> (is_BoolVarValPrint(X3,Y3) + -> gecode_constraint_assign_2(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(assign(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(assign(X0,X1,X2,X3),arg=3))) + ; (is_IntVarArgs(X1,Y1) + -> (is_IntAssign(X2,Y2) + -> (is_IntBranchFilter(X3,Y3) + -> gecode_constraint_assign_10(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(assign(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(assign(X0,X1,X2,X3),arg=3))) + ; (is_IntVar(X1,Y1) + -> (is_IntAssign(X2,Y2) + -> (is_IntVarValPrint(X3,Y3) + -> gecode_constraint_assign_18(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(assign(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(assign(X0,X1,X2,X3),arg=3))) + ; (is_SetVarArgs(X1,Y1) + -> (is_SetAssign(X2,Y2) + -> (is_SetBranchFilter(X3,Y3) + -> gecode_constraint_assign_13(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(assign(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(assign(X0,X1,X2,X3),arg=3))) + ; (is_SetVar(X1,Y1) + -> (is_SetAssign(X2,Y2) + -> (is_SetVarValPrint(X3,Y3) + -> gecode_constraint_assign_20(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(assign(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(assign(X0,X1,X2,X3),arg=3))) + ; throw(gecode_argument_error(assign(X0,X1,X2,X3),arg=2)))))))))) + ; throw(gecode_argument_error(assign(X0,X1,X2,X3),arg=1))). + +element(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_element_227(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=5))) + ; (is_IntVar(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_element_231(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=4)))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_element_221(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=5))) + ; (is_BoolVar(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_element_219(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=4)))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=3))) + ; (is_SetOpType(X1,Y1) + -> (is_SetVarArgs(X2,Y2) + -> (is_SetVar(X3,Y3) + -> (is_SetVar(X4,Y4) + -> gecode_constraint_element_250(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=4))) + ; (is_IntVarArgs(X2,Y2) + -> (is_SetVar(X3,Y3) + -> (is_SetVar(X4,Y4) + -> gecode_constraint_element_248(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=4))) + ; (is_IntSetArgs(X2,Y2) + -> (is_SetVar(X3,Y3) + -> (is_SetVar(X4,Y4) + -> gecode_constraint_element_246(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=4))) + ; (is_IntArgs(X2,Y2) + -> (is_SetVar(X3,Y3) + -> (is_SetVar(X4,Y4) + -> gecode_constraint_element_244(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=3)))))) + ; (is_IntArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_int(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_element_237(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=5))) + ; (is_IntVar(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_element_243(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=5))) + ; (is_BoolVar(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_element_235(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=4))))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=3))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=2)))))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4),arg=1))). + +sequence(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_SetVarArgs(X1,Y1) + -> (is_SetVar(X2,Y2) + -> gecode_constraint_sequence_444(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))). + +branch(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_FloatVarArgs(X1,Y1) + -> (is_FloatVarBranch(X2,Y2) + -> (is_FloatValBranch(X3,Y3) + -> (is_FloatBranchFilter(X4,Y4) + -> gecode_constraint_branch_30(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntVarBranch(X2,Y2) + -> (is_IntValBranch(X3,Y3) + -> (is_Symmetries(X4,Y4) + -> gecode_constraint_branch_26(Y0,Y1,Y2,Y3,Y4) + ; (is_BoolBranchFilter(X4,Y4) + -> gecode_constraint_branch_24(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4),arg=5)))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4),arg=3))) + ; (is_IntVarArgs(X1,Y1) + -> (is_IntVarBranch(X2,Y2) + -> (is_IntValBranch(X3,Y3) + -> (is_Symmetries(X4,Y4) + -> gecode_constraint_branch_32(Y0,Y1,Y2,Y3,Y4) + ; (is_IntBranchFilter(X4,Y4) + -> gecode_constraint_branch_36(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4),arg=5)))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4),arg=3))) + ; (is_SetVarArgs(X1,Y1) + -> (is_SetVarBranch(X2,Y2) + -> (is_SetValBranch(X3,Y3) + -> (is_SetBranchFilter(X4,Y4) + -> gecode_constraint_branch_42(Y0,Y1,Y2,Y3,Y4) + ; (is_Symmetries(X4,Y4) + -> gecode_constraint_branch_38(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4),arg=5)))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4),arg=3))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4),arg=2)))))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4),arg=1))). + +circuit(X0,X1,X2,X3,X4,X5,X6) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntArgs(X1,Y1) + -> (is_int(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVarArgs(X4,Y4) + -> (is_IntVar(X5,Y5) + -> (is_IntConLevel(X6,Y6) + -> gecode_constraint_circuit_85(Y0,Y1,Y2,Y3,Y4,Y5,Y6) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4,X5,X6),arg=7))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4,X5,X6),arg=6))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4,X5,X6),arg=5))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4,X5,X6),arg=4))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4,X5,X6),arg=3))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4,X5,X6),arg=2))) + ; throw(gecode_argument_error(circuit(X0,X1,X2,X3,X4,X5,X6),arg=1))). + +pow(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_int(X2,Y2) + -> (is_IntVar(X3,Y3) + -> gecode_constraint_pow_367(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_366(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)))) + ; throw(gecode_argument_error(pow(X0,X1,X2,X3),arg=1))). + +precede(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_SetVarArgs(X1,Y1) + -> (is_IntArgs(X2,Y2) + -> gecode_constraint_precede_373(Y0,Y1,Y2) + ; throw(gecode_argument_error(precede(X0,X1,X2),arg=3))) + ; (is_IntVarArgs(X1,Y1) + -> (is_IntArgs(X2,Y2) + -> gecode_constraint_precede_369(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))). + +argmax(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_bool(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_argmax_55(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(argmax(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(argmax(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(argmax(X0,X1,X2,X3,X4),arg=3))) + ; throw(gecode_argument_error(argmax(X0,X1,X2,X3,X4),arg=2))) + ; throw(gecode_argument_error(argmax(X0,X1,X2,X3,X4),arg=1))). + +cumulative(X0,X1,X2,X3,X4,X5) :- + (is_Space_or_Clause(X0,Y0) + -> (is_int(X1,Y1) + -> (is_TaskTypeArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntArgs(X4,Y4) + -> (is_IntArgs(X5,Y5) + -> gecode_constraint_cumulative_134(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=4))) + ; (is_IntVarArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVarArgs(X4,Y4) + -> (is_IntArgs(X5,Y5) + -> gecode_constraint_cumulative_130(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=5))) + ; (is_IntArgs(X3,Y3) + -> (is_IntArgs(X4,Y4) + -> (is_BoolVarArgs(X5,Y5) + -> gecode_constraint_cumulative_124(Y0,Y1,Y2,Y3,Y4,Y5) + ; (is_IntConLevel(X5,Y5) + -> gecode_constraint_cumulative_127(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=6)))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=4)))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=3)))) + ; (is_IntVar(X1,Y1) + -> (is_TaskTypeArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntArgs(X4,Y4) + -> (is_IntArgs(X5,Y5) + -> gecode_constraint_cumulative_146(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=4))) + ; (is_IntVarArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVarArgs(X4,Y4) + -> (is_IntArgs(X5,Y5) + -> gecode_constraint_cumulative_142(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=5))) + ; (is_IntArgs(X3,Y3) + -> (is_IntArgs(X4,Y4) + -> (is_BoolVarArgs(X5,Y5) + -> gecode_constraint_cumulative_136(Y0,Y1,Y2,Y3,Y4,Y5) + ; (is_IntConLevel(X5,Y5) + -> gecode_constraint_cumulative_139(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=6)))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=4)))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=3)))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=2)))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5),arg=1))). + +distinct(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntConLevel(X3,Y3) + -> gecode_constraint_distinct_165(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(distinct(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(distinct(X0,X1,X2,X3),arg=3))) + ; throw(gecode_argument_error(distinct(X0,X1,X2,X3),arg=2))) + ; throw(gecode_argument_error(distinct(X0,X1,X2,X3),arg=1))). + +min(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_FloatVarArgs(X1,Y1) + -> (is_FloatVar(X2,Y2) + -> gecode_constraint_min_320(Y0,Y1,Y2) + ; throw(gecode_argument_error(min(X0,X1,X2),arg=3))) + ; (is_IntVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> gecode_constraint_min_321(Y0,Y1,Y2) + ; throw(gecode_argument_error(min(X0,X1,X2),arg=3))) + ; (is_SetVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> gecode_constraint_min_326(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))). + +sqrt(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntConLevel(X3,Y3) + -> gecode_constraint_sqrt_454(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))) + ; throw(gecode_argument_error(sqrt(X0,X1,X2,X3),arg=1))). + +sequence(X0,X1,X2,X3,X4,X5) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntSet(X2,Y2) + -> (is_int(X3,Y3) + -> (is_int(X4,Y4) + -> (is_int(X5,Y5) + -> gecode_constraint_sequence_441(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))) + ; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntSet(X2,Y2) + -> (is_int(X3,Y3) + -> (is_int(X4,Y4) + -> (is_int(X5,Y5) + -> gecode_constraint_sequence_439(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))) + ; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5),arg=3))) + ; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5),arg=2)))) + ; throw(gecode_argument_error(sequence(X0,X1,X2,X3,X4,X5),arg=1))). + +unshare(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntConLevel(X2,Y2) + -> gecode_constraint_unshare_470(Y0,Y1,Y2) + ; throw(gecode_argument_error(unshare(X0,X1,X2),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntConLevel(X2,Y2) + -> gecode_constraint_unshare_468(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))). + +path(X0,X1,X2,X3,X4,X5) :- + (is_Space_or_Clause(X0,Y0) + -> (is_int(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntVar(X3,Y3) + -> (is_IntVar(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_path_365(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))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5),arg=3))) + ; (is_IntArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntVar(X3,Y3) + -> (is_IntVar(X4,Y4) + -> (is_IntVar(X5,Y5) + -> gecode_constraint_path_356(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))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5),arg=3))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5),arg=2)))) + ; throw(gecode_argument_error(path(X0,X1,X2,X3,X4,X5),arg=1))). + +divmod(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntVar(X3,Y3) + -> (is_IntVar(X4,Y4) + -> gecode_constraint_divmod_171(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(divmod(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(divmod(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(divmod(X0,X1,X2,X3,X4),arg=3))) + ; throw(gecode_argument_error(divmod(X0,X1,X2,X3,X4),arg=2))) + ; throw(gecode_argument_error(divmod(X0,X1,X2,X3,X4),arg=1))). + +branch(X0,X1,X2,X3,X4,X5) :- + (is_Space_or_Clause(X0,Y0) + -> (is_FloatVarArgs(X1,Y1) + -> (is_FloatVarBranch(X2,Y2) + -> (is_FloatValBranch(X3,Y3) + -> (is_FloatBranchFilter(X4,Y4) + -> (is_FloatVarValPrint(X5,Y5) + -> gecode_constraint_branch_31(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=4))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_IntVarBranch(X2,Y2) + -> (is_IntValBranch(X3,Y3) + -> (is_Symmetries(X4,Y4) + -> (is_BoolBranchFilter(X5,Y5) + -> gecode_constraint_branch_27(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=6))) + ; (is_BoolBranchFilter(X4,Y4) + -> (is_BoolVarValPrint(X5,Y5) + -> gecode_constraint_branch_25(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=5)))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=4))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=3))) + ; (is_IntVarArgs(X1,Y1) + -> (is_IntVarBranch(X2,Y2) + -> (is_IntValBranch(X3,Y3) + -> (is_Symmetries(X4,Y4) + -> (is_IntBranchFilter(X5,Y5) + -> gecode_constraint_branch_33(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=6))) + ; (is_IntBranchFilter(X4,Y4) + -> (is_IntVarValPrint(X5,Y5) + -> gecode_constraint_branch_37(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=5)))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=4))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=3))) + ; (is_SetVarArgs(X1,Y1) + -> (is_SetVarBranch(X2,Y2) + -> (is_SetValBranch(X3,Y3) + -> (is_SetBranchFilter(X4,Y4) + -> (is_SetVarValPrint(X5,Y5) + -> gecode_constraint_branch_43(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=6))) + ; (is_Symmetries(X4,Y4) + -> (is_SetBranchFilter(X5,Y5) + -> gecode_constraint_branch_39(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=5)))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=4))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=3))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=2)))))) + ; throw(gecode_argument_error(branch(X0,X1,X2,X3,X4,X5),arg=1))). + +nooverlap(X0,X1,X2,X3,X4,X5,X6,X7,X8) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVarArgs(X4,Y4) + -> (is_IntVarArgs(X5,Y5) + -> (is_IntVarArgs(X6,Y6) + -> (is_BoolVarArgs(X7,Y7) + -> (is_IntConLevel(X8,Y8) + -> gecode_constraint_nooverlap_338(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))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=6))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=5))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=4))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=3))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=2))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5,X6,X7,X8),arg=1))). + +argmin(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_bool(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_argmin_58(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(argmin(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(argmin(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(argmin(X0,X1,X2,X3,X4),arg=3))) + ; throw(gecode_argument_error(argmin(X0,X1,X2,X3,X4),arg=2))) + ; throw(gecode_argument_error(argmin(X0,X1,X2,X3,X4),arg=1))). + +cumulative(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_int(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntArgs(X3,Y3) + -> (is_IntArgs(X4,Y4) + -> gecode_constraint_cumulative_126(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4),arg=3))) + ; (is_IntVar(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> (is_IntArgs(X3,Y3) + -> (is_IntArgs(X4,Y4) + -> gecode_constraint_cumulative_138(Y0,Y1,Y2,Y3,Y4) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4),arg=5))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4),arg=4))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4),arg=3))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4),arg=2)))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4),arg=1))). + +member(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> gecode_constraint_member_316(Y0,Y1,Y2) + ; throw(gecode_argument_error(member(X0,X1,X2),arg=3))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_BoolVar(X2,Y2) + -> gecode_constraint_member_312(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))). + +count(X0,X1,X2,X3,X4,X5) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_int(X2,Y2) + -> (is_IntRelType(X3,Y3) + -> (is_int(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_count_117(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=6))) + ; (is_IntVar(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_count_119(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=5)))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=4))) + ; (is_IntVar(X2,Y2) + -> (is_IntRelType(X3,Y3) + -> (is_int(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_count_121(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=6))) + ; (is_IntVar(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_count_123(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=5)))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=4))) + ; (is_IntSet(X2,Y2) + -> (is_IntRelType(X3,Y3) + -> (is_int(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_count_109(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=6))) + ; (is_IntVar(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_count_111(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=5)))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=4))) + ; (is_IntArgs(X2,Y2) + -> (is_IntRelType(X3,Y3) + -> (is_int(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_count_99(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=6))) + ; (is_IntVar(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_count_101(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=5)))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=4))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=3)))))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=2))) + ; throw(gecode_argument_error(count(X0,X1,X2,X3,X4,X5),arg=1))). + +pow(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_int(X2,Y2) + -> (is_IntVar(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_pow_368(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))) + ; throw(gecode_argument_error(pow(X0,X1,X2,X3,X4),arg=2))) + ; throw(gecode_argument_error(pow(X0,X1,X2,X3,X4),arg=1))). + +notMin(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_SetVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> gecode_constraint_notMin_342(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))). + +cumulative(X0,X1,X2,X3,X4,X5,X6,X7) :- + (is_Space_or_Clause(X0,Y0) + -> (is_int(X1,Y1) + -> (is_TaskTypeArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntArgs(X4,Y4) + -> (is_IntArgs(X5,Y5) + -> (is_BoolVarArgs(X6,Y6) + -> (is_IntConLevel(X7,Y7) + -> gecode_constraint_cumulative_133(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=8))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=7))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=6))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=5))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=4))) + ; (is_IntVarArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVarArgs(X4,Y4) + -> (is_IntArgs(X5,Y5) + -> (is_BoolVarArgs(X6,Y6) + -> (is_IntConLevel(X7,Y7) + -> gecode_constraint_cumulative_129(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=8))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=7))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=6))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=5))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=4))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=3)))) + ; (is_IntVar(X1,Y1) + -> (is_TaskTypeArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntArgs(X4,Y4) + -> (is_IntArgs(X5,Y5) + -> (is_BoolVarArgs(X6,Y6) + -> (is_IntConLevel(X7,Y7) + -> gecode_constraint_cumulative_145(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=8))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=7))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=6))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=5))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=4))) + ; (is_IntVarArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntVarArgs(X4,Y4) + -> (is_IntArgs(X5,Y5) + -> (is_BoolVarArgs(X6,Y6) + -> (is_IntConLevel(X7,Y7) + -> gecode_constraint_cumulative_141(Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=8))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=7))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=6))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=5))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=4))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=3)))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=2)))) + ; throw(gecode_argument_error(cumulative(X0,X1,X2,X3,X4,X5,X6,X7),arg=1))). + +branch(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntValBranch(X2,Y2) + -> gecode_constraint_branch_46(Y0,Y1,Y2) + ; throw(gecode_argument_error(branch(X0,X1,X2),arg=3))) + ; (is_BoolVar(X1,Y1) + -> (is_IntValBranch(X2,Y2) + -> gecode_constraint_branch_21(Y0,Y1,Y2) + ; throw(gecode_argument_error(branch(X0,X1,X2),arg=3))) + ; (is_FloatVar(X1,Y1) + -> (is_FloatValBranch(X2,Y2) + -> gecode_constraint_branch_44(Y0,Y1,Y2) + ; throw(gecode_argument_error(branch(X0,X1,X2),arg=3))) + ; (is_SetVar(X1,Y1) + -> (is_SetValBranch(X2,Y2) + -> gecode_constraint_branch_48(Y0,Y1,Y2) + ; throw(gecode_argument_error(branch(X0,X1,X2),arg=3))) + ; throw(gecode_argument_error(branch(X0,X1,X2),arg=2)))))) + ; throw(gecode_argument_error(branch(X0,X1,X2),arg=1))). + +dom(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_FloatVar(X1,Y1) + -> (is_FloatVal(X2,Y2) + -> gecode_constraint_dom_194(Y0,Y1,Y2) + ; (is_FloatVar(X2,Y2) + -> gecode_constraint_dom_196(Y0,Y1,Y2) + ; throw(gecode_argument_error(dom(X0,X1,X2),arg=3)))) + ; (is_FloatVarArgs(X1,Y1) + -> (is_FloatVarArgs(X2,Y2) + -> gecode_constraint_dom_177(Y0,Y1,Y2) + ; (is_FloatVal(X2,Y2) + -> gecode_constraint_dom_179(Y0,Y1,Y2) + ; throw(gecode_argument_error(dom(X0,X1,X2),arg=3)))) + ; (is_BoolVarArgs(X1,Y1) + -> (is_BoolVarArgs(X2,Y2) + -> gecode_constraint_dom_175(Y0,Y1,Y2) + ; throw(gecode_argument_error(dom(X0,X1,X2),arg=3))) + ; (is_BoolVar(X1,Y1) + -> (is_BoolVar(X2,Y2) + -> gecode_constraint_dom_173(Y0,Y1,Y2) + ; throw(gecode_argument_error(dom(X0,X1,X2),arg=3))) + ; (is_IntVarArgs(X1,Y1) + -> (is_int(X2,Y2) + -> gecode_constraint_dom_184(Y0,Y1,Y2) + ; (is_IntVarArgs(X2,Y2) + -> gecode_constraint_dom_182(Y0,Y1,Y2) + ; (is_IntSet(X2,Y2) + -> gecode_constraint_dom_180(Y0,Y1,Y2) + ; throw(gecode_argument_error(dom(X0,X1,X2),arg=3))))) + ; (is_IntVar(X1,Y1) + -> (is_int(X2,Y2) + -> gecode_constraint_dom_201(Y0,Y1,Y2) + ; (is_IntVar(X2,Y2) + -> gecode_constraint_dom_209(Y0,Y1,Y2) + ; (is_IntSet(X2,Y2) + -> gecode_constraint_dom_197(Y0,Y1,Y2) + ; throw(gecode_argument_error(dom(X0,X1,X2),arg=3))))) + ; (is_SetVarArgs(X1,Y1) + -> (is_SetVarArgs(X2,Y2) + -> gecode_constraint_dom_188(Y0,Y1,Y2) + ; throw(gecode_argument_error(dom(X0,X1,X2),arg=3))) + ; (is_SetVar(X1,Y1) + -> (is_SetVar(X2,Y2) + -> gecode_constraint_dom_217(Y0,Y1,Y2) + ; throw(gecode_argument_error(dom(X0,X1,X2),arg=3))) + ; throw(gecode_argument_error(dom(X0,X1,X2),arg=2)))))))))) + ; throw(gecode_argument_error(dom(X0,X1,X2),arg=1))). + +linear(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntRelType(X2,Y2) + -> (is_int(X3,Y3) + -> (is_Reify(X4,Y4) + -> gecode_constraint_linear_298(Y0,Y1,Y2,Y3,Y4) + ; (is_IntConLevel(X4,Y4) + -> gecode_constraint_linear_297(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_302(Y0,Y1,Y2,Y3,Y4) + ; (is_IntConLevel(X4,Y4) + -> gecode_constraint_linear_301(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_FloatVarArgs(X1,Y1) + -> (is_FloatRelType(X2,Y2) + -> (is_FloatVar(X3,Y3) + -> (is_Reify(X4,Y4) + -> gecode_constraint_linear_279(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_277(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_Reify(X4,Y4) + -> gecode_constraint_linear_266(Y0,Y1,Y2,Y3,Y4) + ; (is_IntConLevel(X4,Y4) + -> gecode_constraint_linear_265(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_270(Y0,Y1,Y2,Y3,Y4) + ; (is_IntConLevel(X4,Y4) + -> gecode_constraint_linear_269(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_274(Y0,Y1,Y2,Y3,Y4) + ; (is_FloatNum(X4,Y4) + -> gecode_constraint_linear_272(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_288(Y0,Y1,Y2,Y3,Y4) + ; (is_IntVar(X4,Y4) + -> gecode_constraint_linear_292(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_280(Y0,Y1,Y2,Y3,Y4) + ; (is_IntVar(X4,Y4) + -> gecode_constraint_linear_284(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)))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=2))))))) + ; throw(gecode_argument_error(linear(X0,X1,X2,X3,X4),arg=1))). + +nooverlap(X0,X1,X2,X3,X4,X5) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntArgs(X2,Y2) + -> (is_IntVarArgs(X3,Y3) + -> (is_IntArgs(X4,Y4) + -> (is_BoolVarArgs(X5,Y5) + -> gecode_constraint_nooverlap_333(Y0,Y1,Y2,Y3,Y4,Y5) + ; (is_IntConLevel(X5,Y5) + -> gecode_constraint_nooverlap_336(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))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5),arg=3))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5),arg=2))) + ; throw(gecode_argument_error(nooverlap(X0,X1,X2,X3,X4,X5),arg=1))). + +element(X0,X1,X2,X3,X4,X5) :- + (is_Space_or_Clause(X0,Y0) + -> (is_SetOpType(X1,Y1) + -> (is_SetVarArgs(X2,Y2) + -> (is_SetVar(X3,Y3) + -> (is_SetVar(X4,Y4) + -> (is_IntSet(X5,Y5) + -> gecode_constraint_element_251(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5),arg=4))) + ; (is_IntVarArgs(X2,Y2) + -> (is_SetVar(X3,Y3) + -> (is_SetVar(X4,Y4) + -> (is_IntSet(X5,Y5) + -> gecode_constraint_element_249(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5),arg=4))) + ; (is_IntSetArgs(X2,Y2) + -> (is_SetVar(X3,Y3) + -> (is_SetVar(X4,Y4) + -> (is_IntSet(X5,Y5) + -> gecode_constraint_element_247(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5),arg=4))) + ; (is_IntArgs(X2,Y2) + -> (is_SetVar(X3,Y3) + -> (is_SetVar(X4,Y4) + -> (is_IntSet(X5,Y5) + -> gecode_constraint_element_245(Y0,Y1,Y2,Y3,Y4,Y5) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5),arg=6))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5),arg=5))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5),arg=4))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5),arg=3)))))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5),arg=2))) + ; throw(gecode_argument_error(element(X0,X1,X2,X3,X4,X5),arg=1))). + +rel(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_FloatVar(X1,Y1) + -> (is_FloatRelType(X2,Y2) + -> (is_FloatVal(X3,Y3) + -> gecode_constraint_rel_411(Y0,Y1,Y2,Y3) + ; (is_FloatVar(X3,Y3) + -> gecode_constraint_rel_413(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_429(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_427(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_399(Y0,Y1,Y2,Y3) + ; (is_FloatVar(X3,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_BoolVarArgs(X1,Y1) + -> (is_IntRelType(X2,Y2) + -> (is_int(X3,Y3) + -> gecode_constraint_rel_397(Y0,Y1,Y2,Y3) + ; (is_BoolVarArgs(X3,Y3) + -> gecode_constraint_rel_393(Y0,Y1,Y2,Y3) + ; (is_BoolVar(X3,Y3) + -> gecode_constraint_rel_391(Y0,Y1,Y2,Y3) + ; (is_IntConLevel(X3,Y3) + -> gecode_constraint_rel_396(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_387(Y0,Y1,Y2,Y3) + ; (is_BoolVar(X3,Y3) + -> gecode_constraint_rel_383(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_407(Y0,Y1,Y2,Y3) + ; (is_IntVar(X3,Y3) + -> gecode_constraint_rel_409(Y0,Y1,Y2,Y3) + ; (is_IntVarArgs(X3,Y3) + -> gecode_constraint_rel_403(Y0,Y1,Y2,Y3) + ; (is_IntConLevel(X3,Y3) + -> gecode_constraint_rel_406(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_415(Y0,Y1,Y2,Y3) + ; (is_IntVar(X3,Y3) + -> gecode_constraint_rel_419(Y0,Y1,Y2,Y3) + ; (is_SetVar(X3,Y3) + -> gecode_constraint_rel_423(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_424(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_430(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_435(Y0,Y1,Y2,Y3) + ; (is_SetVar(X3,Y3) + -> gecode_constraint_rel_437(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_377(Y0,Y1,Y2,Y3) + ; (is_BoolVar(X3,Y3) + -> gecode_constraint_rel_375(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))))))))))) + ; throw(gecode_argument_error(rel(X0,X1,X2,X3),arg=1))). + +min(X0,X1,X2,X3,X4) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntVar(X3,Y3) + -> (is_IntConLevel(X4,Y4) + -> gecode_constraint_min_325(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))) + ; throw(gecode_argument_error(min(X0,X1,X2,X3,X4),arg=2))) + ; throw(gecode_argument_error(min(X0,X1,X2,X3,X4),arg=1))). + +count(X0,X1,X2) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVarArgs(X2,Y2) + -> gecode_constraint_count_114(Y0,Y1,Y2) + ; (is_IntSetArgs(X2,Y2) + -> gecode_constraint_count_104(Y0,Y1,Y2) + ; throw(gecode_argument_error(count(X0,X1,X2),arg=3)))) + ; throw(gecode_argument_error(count(X0,X1,X2),arg=2))) + ; throw(gecode_argument_error(count(X0,X1,X2),arg=1))). + +argmax(X0,X1,X2,X3) :- + (is_Space_or_Clause(X0,Y0) + -> (is_IntVarArgs(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_bool(X3,Y3) + -> gecode_constraint_argmax_54(Y0,Y1,Y2,Y3) + ; throw(gecode_argument_error(argmax(X0,X1,X2,X3),arg=4))) + ; throw(gecode_argument_error(argmax(X0,X1,X2,X3),arg=3))) + ; throw(gecode_argument_error(argmax(X0,X1,X2,X3),arg=2))) + ; throw(gecode_argument_error(argmax(X0,X1,X2,X3),arg=1))). + +ite(X0,X1,X2,X3,X4,X5) :- + (is_Space_or_Clause(X0,Y0) + -> (is_BoolVar(X1,Y1) + -> (is_IntVar(X2,Y2) + -> (is_IntVar(X3,Y3) + -> (is_IntVar(X4,Y4) + -> (is_IntConLevel(X5,Y5) + -> gecode_constraint_ite_263(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))) + ; throw(gecode_argument_error(ite(X0,X1,X2,X3,X4,X5),arg=3))) + ; throw(gecode_argument_error(ite(X0,X1,X2,X3,X4,X5),arg=2))) + ; throw(gecode_argument_error(ite(X0,X1,X2,X3,X4,X5),arg=1))). + diff --git a/packages/gecode/4.4.0/gecode_yap_cc_forward_auto_generated.icc b/packages/gecode/4.4.0/gecode_yap_cc_forward_auto_generated.icc new file mode 100644 index 000000000..cb696e86a --- /dev/null +++ b/packages/gecode/4.4.0/gecode_yap_cc_forward_auto_generated.icc @@ -0,0 +1,28 @@ +// -*- c++ -*- +//============================================================================= +// 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 . +//============================================================================= + +static RestartMode gecode_RestartMode_from_term(YAP_Term); +static FloatRelType gecode_FloatRelType_from_term(YAP_Term); +static ReifyMode gecode_ReifyMode_from_term(YAP_Term); +static IntRelType gecode_IntRelType_from_term(YAP_Term); +static BoolOpType gecode_BoolOpType_from_term(YAP_Term); +static IntConLevel gecode_IntConLevel_from_term(YAP_Term); +static TaskType gecode_TaskType_from_term(YAP_Term); +static ExtensionalPropKind gecode_ExtensionalPropKind_from_term(YAP_Term); +static SetRelType gecode_SetRelType_from_term(YAP_Term); +static SetOpType gecode_SetOpType_from_term(YAP_Term); diff --git a/packages/gecode/4.4.0/gecode_yap_cc_impl_auto_generated.icc b/packages/gecode/4.4.0/gecode_yap_cc_impl_auto_generated.icc new file mode 100644 index 000000000..e9c93177c --- /dev/null +++ b/packages/gecode/4.4.0/gecode_yap_cc_impl_auto_generated.icc @@ -0,0 +1,5292 @@ +// -*- c++ -*- +//============================================================================= +// 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 . +//============================================================================= + +static YAP_Term gecode_RM_NONE; +static YAP_Term gecode_RM_CONSTANT; +static YAP_Term gecode_RM_LINEAR; +static YAP_Term gecode_RM_LUBY; +static YAP_Term gecode_RM_GEOMETRIC; + +static RestartMode gecode_RestartMode_from_term(YAP_Term X) +{ + if (X==gecode_RM_NONE) return RM_NONE; + if (X==gecode_RM_CONSTANT) return RM_CONSTANT; + if (X==gecode_RM_LINEAR) return RM_LINEAR; + if (X==gecode_RM_LUBY) return RM_LUBY; + if (X==gecode_RM_GEOMETRIC) return RM_GEOMETRIC; + cerr << "this should never happen" << endl; exit(1); +} + +static YAP_Term gecode_FRT_EQ; +static YAP_Term gecode_FRT_NQ; +static YAP_Term gecode_FRT_LQ; +static YAP_Term gecode_FRT_LE; +static YAP_Term gecode_FRT_GQ; +static YAP_Term gecode_FRT_GR; + +static FloatRelType gecode_FloatRelType_from_term(YAP_Term X) +{ + if (X==gecode_FRT_EQ) return FRT_EQ; + if (X==gecode_FRT_NQ) return FRT_NQ; + if (X==gecode_FRT_LQ) return FRT_LQ; + if (X==gecode_FRT_LE) return FRT_LE; + if (X==gecode_FRT_GQ) return FRT_GQ; + if (X==gecode_FRT_GR) return FRT_GR; + cerr << "this should never happen" << endl; exit(1); +} + +static YAP_Term gecode_RM_EQV; +static YAP_Term gecode_RM_IMP; +static YAP_Term gecode_RM_PMI; + +static ReifyMode gecode_ReifyMode_from_term(YAP_Term X) +{ + if (X==gecode_RM_EQV) return RM_EQV; + if (X==gecode_RM_IMP) return RM_IMP; + if (X==gecode_RM_PMI) return RM_PMI; + cerr << "this should never happen" << endl; exit(1); +} + +static YAP_Term gecode_IRT_EQ; +static YAP_Term gecode_IRT_NQ; +static YAP_Term gecode_IRT_LQ; +static YAP_Term gecode_IRT_LE; +static YAP_Term gecode_IRT_GQ; +static YAP_Term gecode_IRT_GR; + +static IntRelType gecode_IntRelType_from_term(YAP_Term X) +{ + if (X==gecode_IRT_EQ) return IRT_EQ; + if (X==gecode_IRT_NQ) return IRT_NQ; + if (X==gecode_IRT_LQ) return IRT_LQ; + if (X==gecode_IRT_LE) return IRT_LE; + if (X==gecode_IRT_GQ) return IRT_GQ; + if (X==gecode_IRT_GR) return IRT_GR; + cerr << "this should never happen" << endl; exit(1); +} + +static YAP_Term gecode_BOT_AND; +static YAP_Term gecode_BOT_OR; +static YAP_Term gecode_BOT_IMP; +static YAP_Term gecode_BOT_EQV; +static YAP_Term gecode_BOT_XOR; + +static BoolOpType gecode_BoolOpType_from_term(YAP_Term X) +{ + if (X==gecode_BOT_AND) return BOT_AND; + if (X==gecode_BOT_OR) return BOT_OR; + if (X==gecode_BOT_IMP) return BOT_IMP; + if (X==gecode_BOT_EQV) return BOT_EQV; + if (X==gecode_BOT_XOR) return BOT_XOR; + cerr << "this should never happen" << endl; exit(1); +} + +static YAP_Term gecode_ICL_VAL; +static YAP_Term gecode_ICL_BND; +static YAP_Term gecode_ICL_DOM; +static YAP_Term gecode_ICL_DEF; + +static IntConLevel gecode_IntConLevel_from_term(YAP_Term X) +{ + if (X==gecode_ICL_VAL) return ICL_VAL; + if (X==gecode_ICL_BND) return ICL_BND; + if (X==gecode_ICL_DOM) return ICL_DOM; + if (X==gecode_ICL_DEF) return ICL_DEF; + cerr << "this should never happen" << endl; exit(1); +} + +static YAP_Term gecode_TT_FIXP; +static YAP_Term gecode_TT_FIXS; +static YAP_Term gecode_TT_FIXE; + +static TaskType gecode_TaskType_from_term(YAP_Term X) +{ + if (X==gecode_TT_FIXP) return TT_FIXP; + if (X==gecode_TT_FIXS) return TT_FIXS; + if (X==gecode_TT_FIXE) return TT_FIXE; + cerr << "this should never happen" << endl; exit(1); +} + +static YAP_Term gecode_EPK_DEF; +static YAP_Term gecode_EPK_SPEED; +static YAP_Term gecode_EPK_MEMORY; + +static ExtensionalPropKind gecode_ExtensionalPropKind_from_term(YAP_Term X) +{ + if (X==gecode_EPK_DEF) return EPK_DEF; + if (X==gecode_EPK_SPEED) return EPK_SPEED; + if (X==gecode_EPK_MEMORY) return EPK_MEMORY; + cerr << "this should never happen" << endl; exit(1); +} + +static YAP_Term gecode_SRT_EQ; +static YAP_Term gecode_SRT_NQ; +static YAP_Term gecode_SRT_SUB; +static YAP_Term gecode_SRT_SUP; +static YAP_Term gecode_SRT_DISJ; +static YAP_Term gecode_SRT_CMPL; +static YAP_Term gecode_SRT_LQ; +static YAP_Term gecode_SRT_LE; +static YAP_Term gecode_SRT_GQ; +static YAP_Term gecode_SRT_GR; + +static SetRelType gecode_SetRelType_from_term(YAP_Term X) +{ + if (X==gecode_SRT_EQ) return SRT_EQ; + if (X==gecode_SRT_NQ) return SRT_NQ; + if (X==gecode_SRT_SUB) return SRT_SUB; + if (X==gecode_SRT_SUP) return SRT_SUP; + if (X==gecode_SRT_DISJ) return SRT_DISJ; + if (X==gecode_SRT_CMPL) return SRT_CMPL; + if (X==gecode_SRT_LQ) return SRT_LQ; + if (X==gecode_SRT_LE) return SRT_LE; + if (X==gecode_SRT_GQ) return SRT_GQ; + if (X==gecode_SRT_GR) return SRT_GR; + cerr << "this should never happen" << endl; exit(1); +} + +static YAP_Term gecode_SOT_UNION; +static YAP_Term gecode_SOT_DUNION; +static YAP_Term gecode_SOT_INTER; +static YAP_Term gecode_SOT_MINUS; + +static SetOpType gecode_SetOpType_from_term(YAP_Term X) +{ + if (X==gecode_SOT_UNION) return SOT_UNION; + if (X==gecode_SOT_DUNION) return SOT_DUNION; + if (X==gecode_SOT_INTER) return SOT_INTER; + if (X==gecode_SOT_MINUS) return SOT_MINUS; + cerr << "this should never happen" << endl; exit(1); +} + +static YAP_Bool gecode_constraint_unary_464(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); + BoolVarArgs X5 = gecode_BoolVarArgs_from_term(space,YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + unary(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_unary_460(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); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + unary(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_nvalues_351(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); + nvalues(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_nvalues_353(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); + nvalues(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_nvalues_347(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); + int X4 = gecode_int_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + nvalues(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_nvalues_349(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); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + nvalues(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_max_308(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + max(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_max_306(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + max(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_max_307(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVar X2 = gecode_FloatVar_from_term(space,YAP_ARG2); + FloatVar X3 = gecode_FloatVar_from_term(space,YAP_ARG3); + FloatVar X4 = gecode_FloatVar_from_term(space,YAP_ARG4); + max(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_max_311(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + Reify X4 = gecode_Reify_from_term(YAP_ARG4); + max(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_206(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + Reify X5 = gecode_Reify_from_term(YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + dom(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_215(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + SetRelType X3 = gecode_SetRelType_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + Reify X6 = gecode_Reify_from_term(YAP_ARG6); + dom(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_argmin_56(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + argmin(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_convex_97(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + SetVar X3 = gecode_SetVar_from_term(space,YAP_ARG3); + convex(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_nooverlap_335(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntArgs X3 = gecode_IntArgs_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + nooverlap(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_assign_15(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVar X2 = gecode_FloatVar_from_term(space,YAP_ARG2); + FloatAssign X3 = gecode_FloatAssign_from_term(YAP_ARG3); + assign(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_assign_6(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVarArgs X2 = gecode_FloatVarArgs_from_term(space,YAP_ARG2); + FloatAssign X3 = gecode_FloatAssign_from_term(YAP_ARG3); + assign(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_assign_3(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntAssign X3 = gecode_IntAssign_from_term(YAP_ARG3); + assign(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_assign_1(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2); + IntAssign X3 = gecode_IntAssign_from_term(YAP_ARG3); + assign(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_assign_9(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntAssign X3 = gecode_IntAssign_from_term(YAP_ARG3); + assign(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_assign_17(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntAssign X3 = gecode_IntAssign_from_term(YAP_ARG3); + assign(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_assign_12(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVarArgs X2 = gecode_SetVarArgs_from_term(space,YAP_ARG2); + SetAssign X3 = gecode_SetAssign_from_term(YAP_ARG3); + assign(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_assign_19(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + SetAssign X3 = gecode_SetAssign_from_term(YAP_ARG3); + assign(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_element_226(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + element(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_element_230(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + element(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_element_220(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + element(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_element_218(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + element(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_element_225(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntSetArgs X2 = gecode_IntSetArgs_from_term(YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + element(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_element_233(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVarArgs X2 = gecode_SetVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + element(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_element_236(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + element(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_element_242(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + element(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_element_234(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + element(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_sequence_443(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVarArgs X2 = gecode_SetVarArgs_from_term(space,YAP_ARG2); + sequence(*space,X2); + return TRUE; +} + +static YAP_Bool gecode_constraint_notMax_341(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + notMax(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_ite_262(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + ite(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_unary_457(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntArgs X3 = gecode_IntArgs_from_term(YAP_ARG3); + unary(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_nroot_345(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + nroot(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_circuit_91(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + int X2 = gecode_int_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + circuit(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_circuit_82(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); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + circuit(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_205(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + Reify X5 = gecode_Reify_from_term(YAP_ARG5); + dom(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_204(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + dom(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_208(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + Reify X4 = gecode_Reify_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + dom(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_200(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntSet X3 = gecode_IntSet_from_term(YAP_ARG3); + Reify X4 = gecode_Reify_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + dom(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_191(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVarArgs X2 = gecode_SetVarArgs_from_term(space,YAP_ARG2); + SetRelType X3 = gecode_SetRelType_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + dom(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_187(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + dom(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_193(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVar X2 = gecode_FloatVar_from_term(space,YAP_ARG2); + FloatNum X3 = gecode_FloatNum_from_term(YAP_ARG3); + FloatNum X4 = gecode_FloatNum_from_term(YAP_ARG4); + Reify X5 = gecode_Reify_from_term(YAP_ARG5); + dom(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_214(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + SetRelType X3 = gecode_SetRelType_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + dom(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_216(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + SetRelType X3 = gecode_SetRelType_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + Reify X5 = gecode_Reify_from_term(YAP_ARG5); + dom(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_212(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + SetRelType X3 = gecode_SetRelType_from_term(YAP_ARG3); + IntSet X4 = gecode_IntSet_from_term(YAP_ARG4); + Reify X5 = gecode_Reify_from_term(YAP_ARG5); + dom(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_channel_72(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); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + channel(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_channel_68(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + channel(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_channel_66(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + channel(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_nooverlap_337(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); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntVarArgs X6 = gecode_IntVarArgs_from_term(space,YAP_ARG6); + IntVarArgs X7 = gecode_IntVarArgs_from_term(space,YAP_ARG7); + BoolVarArgs X8 = gecode_BoolVarArgs_from_term(space,YAP_ARG8); + nooverlap(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static YAP_Bool gecode_constraint_nooverlap_340(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); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntVarArgs X6 = gecode_IntVarArgs_from_term(space,YAP_ARG6); + IntVarArgs X7 = gecode_IntVarArgs_from_term(space,YAP_ARG7); + IntConLevel X8 = gecode_IntConLevel_from_term(YAP_ARG8); + nooverlap(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static YAP_Bool gecode_constraint_element_228(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + int X6 = gecode_int_from_term(YAP_ARG6); + IntVar X7 = gecode_IntVar_from_term(space,YAP_ARG7); + element(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static YAP_Bool gecode_constraint_element_222(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + int X6 = gecode_int_from_term(YAP_ARG6); + BoolVar X7 = gecode_BoolVar_from_term(space,YAP_ARG7); + element(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static YAP_Bool gecode_constraint_element_224(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntSetArgs X2 = gecode_IntSetArgs_from_term(YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + int X6 = gecode_int_from_term(YAP_ARG6); + SetVar X7 = gecode_SetVar_from_term(space,YAP_ARG7); + element(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static YAP_Bool gecode_constraint_element_232(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVarArgs X2 = gecode_SetVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + int X6 = gecode_int_from_term(YAP_ARG6); + SetVar X7 = gecode_SetVar_from_term(space,YAP_ARG7); + element(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static YAP_Bool gecode_constraint_element_240(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + int X6 = gecode_int_from_term(YAP_ARG6); + IntVar X7 = gecode_IntVar_from_term(space,YAP_ARG7); + element(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static YAP_Bool gecode_constraint_element_238(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + int X6 = gecode_int_from_term(YAP_ARG6); + BoolVar X7 = gecode_BoolVar_from_term(space,YAP_ARG7); + element(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static YAP_Bool gecode_constraint_max_304(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVarArgs X2 = gecode_FloatVarArgs_from_term(space,YAP_ARG2); + FloatVar X3 = gecode_FloatVar_from_term(space,YAP_ARG3); + max(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_max_305(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + max(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_max_310(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + max(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_unshare_469(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + unshare(*space,X2); + return TRUE; +} + +static YAP_Bool gecode_constraint_unshare_467(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + unshare(*space,X2); + return TRUE; +} + +static YAP_Bool gecode_constraint_path_364(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + int X2 = gecode_int_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + path(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_path_363(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + path(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_branch_34(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVarBranch X3 = gecode_IntVarBranch_from_term(YAP_ARG3); + IntValBranch X4 = gecode_IntValBranch_from_term(YAP_ARG4); + Symmetries X5 = gecode_Symmetries_from_term(YAP_ARG5); + IntBranchFilter X6 = gecode_IntBranchFilter_from_term(YAP_ARG6); + IntVarValPrint X7 = gecode_IntVarValPrint_from_term(YAP_ARG7); + branch(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static YAP_Bool gecode_constraint_branch_28(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntVarBranch X3 = gecode_IntVarBranch_from_term(YAP_ARG3); + IntValBranch X4 = gecode_IntValBranch_from_term(YAP_ARG4); + Symmetries X5 = gecode_Symmetries_from_term(YAP_ARG5); + BoolBranchFilter X6 = gecode_BoolBranchFilter_from_term(YAP_ARG6); + BoolVarValPrint X7 = gecode_BoolVarValPrint_from_term(YAP_ARG7); + branch(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static YAP_Bool gecode_constraint_branch_40(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVarArgs X2 = gecode_SetVarArgs_from_term(space,YAP_ARG2); + SetVarBranch X3 = gecode_SetVarBranch_from_term(YAP_ARG3); + SetValBranch X4 = gecode_SetValBranch_from_term(YAP_ARG4); + Symmetries X5 = gecode_Symmetries_from_term(YAP_ARG5); + SetBranchFilter X6 = gecode_SetBranchFilter_from_term(YAP_ARG6); + SetVarValPrint X7 = gecode_SetVarValPrint_from_term(YAP_ARG7); + branch(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static YAP_Bool gecode_constraint_mult_331(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + mult(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_mult_330(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVar X2 = gecode_FloatVar_from_term(space,YAP_ARG2); + FloatVar X3 = gecode_FloatVar_from_term(space,YAP_ARG3); + FloatVar X4 = gecode_FloatVar_from_term(space,YAP_ARG4); + mult(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_clause_95(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolOpType X2 = gecode_BoolOpType_from_term(YAP_ARG2); + BoolVarArgs X3 = gecode_BoolVarArgs_from_term(space,YAP_ARG3); + BoolVarArgs X4 = gecode_BoolVarArgs_from_term(space,YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + clause(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_clause_93(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolOpType X2 = gecode_BoolOpType_from_term(YAP_ARG2); + BoolVarArgs X3 = gecode_BoolVarArgs_from_term(space,YAP_ARG3); + BoolVarArgs X4 = gecode_BoolVarArgs_from_term(space,YAP_ARG4); + BoolVar X5 = gecode_BoolVar_from_term(space,YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + clause(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_precede_372(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + precede(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_argmax_53(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + argmax(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_distinct_166(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + distinct(*space,X2); + return TRUE; +} + +static YAP_Bool gecode_constraint_member_318(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + Reify X4 = gecode_Reify_from_term(YAP_ARG4); + member(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_member_317(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + member(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_member_314(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + BoolVar X3 = gecode_BoolVar_from_term(space,YAP_ARG3); + Reify X4 = gecode_Reify_from_term(YAP_ARG4); + member(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_member_313(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + BoolVar X3 = gecode_BoolVar_from_term(space,YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + member(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_mod_329(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + mod(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_cardinality_63(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + cardinality(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_atmostOne_59(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVarArgs X2 = gecode_SetVarArgs_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + atmostOne(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_channelSorted_79(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + SetVar X3 = gecode_SetVar_from_term(space,YAP_ARG3); + channelSorted(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_extensional_259(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 YAP_Bool gecode_constraint_extensional_254(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 YAP_Bool gecode_constraint_linear_278(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVarArgs X2 = gecode_FloatVarArgs_from_term(space,YAP_ARG2); + FloatRelType X3 = gecode_FloatRelType_from_term(YAP_ARG3); + FloatVar X4 = gecode_FloatVar_from_term(space,YAP_ARG4); + linear(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_linear_276(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVarArgs X2 = gecode_FloatVarArgs_from_term(space,YAP_ARG2); + FloatRelType X3 = gecode_FloatRelType_from_term(YAP_ARG3); + FloatNum X4 = gecode_FloatNum_from_term(YAP_ARG4); + linear(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_linear_264(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); + int X4 = gecode_int_from_term(YAP_ARG4); + linear(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_linear_268(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); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + linear(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool 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); + int X4 = gecode_int_from_term(YAP_ARG4); + linear(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_linear_300(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); + linear(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_circuit_88(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + circuit(*space,X2); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_412(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVar X2 = gecode_FloatVar_from_term(space,YAP_ARG2); + FloatRelType X3 = gecode_FloatRelType_from_term(YAP_ARG3); + FloatVal X4 = gecode_FloatVal_from_term(YAP_ARG4); + Reify X5 = gecode_Reify_from_term(YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_414(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVar X2 = gecode_FloatVar_from_term(space,YAP_ARG2); + FloatRelType X3 = gecode_FloatRelType_from_term(YAP_ARG3); + FloatVar X4 = gecode_FloatVar_from_term(space,YAP_ARG4); + Reify X5 = gecode_Reify_from_term(YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_428(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetOpType X2 = gecode_SetOpType_from_term(YAP_ARG2); + SetVarArgs X3 = gecode_SetVarArgs_from_term(space,YAP_ARG3); + IntSet X4 = gecode_IntSet_from_term(YAP_ARG4); + SetVar X5 = gecode_SetVar_from_term(space,YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_426(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetOpType X2 = gecode_SetOpType_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntSet X4 = gecode_IntSet_from_term(YAP_ARG4); + SetVar X5 = gecode_SetVar_from_term(space,YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_398(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); + int X4 = gecode_int_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_394(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); + BoolVarArgs X4 = gecode_BoolVarArgs_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_392(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); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_389(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); + Reify X5 = gecode_Reify_from_term(YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_388(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); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_385(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); + Reify X5 = gecode_Reify_from_term(YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_384(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); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_381(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2); + BoolOpType X3 = gecode_BoolOpType_from_term(YAP_ARG3); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_379(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2); + BoolOpType X3 = gecode_BoolOpType_from_term(YAP_ARG3); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + BoolVar X5 = gecode_BoolVar_from_term(space,YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_408(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); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_410(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); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_404(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); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_417(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); + Reify X5 = gecode_Reify_from_term(YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_416(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); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_421(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); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + Reify X5 = gecode_Reify_from_term(YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_420(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); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_425(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + SetRelType X3 = gecode_SetRelType_from_term(YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + Reify X5 = gecode_Reify_from_term(YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_436(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + SetRelType X3 = gecode_SetRelType_from_term(YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + Reify X5 = gecode_Reify_from_term(YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_438(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + SetRelType X3 = gecode_SetRelType_from_term(YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + Reify X5 = gecode_Reify_from_term(YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_378(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolOpType X2 = gecode_BoolOpType_from_term(YAP_ARG2); + BoolVarArgs X3 = gecode_BoolVarArgs_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_376(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolOpType X2 = gecode_BoolOpType_from_term(YAP_ARG2); + BoolVarArgs X3 = gecode_BoolVarArgs_from_term(space,YAP_ARG3); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + rel(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_min_324(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + min(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_min_322(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + min(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_min_323(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVar X2 = gecode_FloatVar_from_term(space,YAP_ARG2); + FloatVar X3 = gecode_FloatVar_from_term(space,YAP_ARG3); + FloatVar X4 = gecode_FloatVar_from_term(space,YAP_ARG4); + min(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_min_327(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + Reify X4 = gecode_Reify_from_term(YAP_ARG4); + min(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_cardinality_62(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVarArgs X2 = gecode_SetVarArgs_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + cardinality(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_cardinality_64(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + cardinality(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_count_115(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); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + count(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_count_112(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); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + count(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_count_106(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntSet X3 = gecode_IntSet_from_term(YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + count(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_count_105(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntSetArgs X3 = gecode_IntSetArgs_from_term(YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + count(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_count_102(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntSetArgs X3 = gecode_IntSetArgs_from_term(YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + count(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_sqrt_453(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + sqrt(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_sqrt_452(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVar X2 = gecode_FloatVar_from_term(space,YAP_ARG2); + FloatVar X3 = gecode_FloatVar_from_term(space,YAP_ARG3); + sqrt(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulatives_163(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); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntVarArgs X6 = gecode_IntVarArgs_from_term(space,YAP_ARG6); + IntArgs X7 = gecode_IntArgs_from_term(YAP_ARG7); + bool X8 = gecode_bool_from_term(YAP_ARG8); + IntConLevel X9 = gecode_IntConLevel_from_term(YAP_ARG9); + cumulatives(*space,X2,X3,X4,X5,X6,X7,X8,X9); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulatives_161(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); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + IntArgs X7 = gecode_IntArgs_from_term(YAP_ARG7); + bool X8 = gecode_bool_from_term(YAP_ARG8); + IntConLevel X9 = gecode_IntConLevel_from_term(YAP_ARG9); + cumulatives(*space,X2,X3,X4,X5,X6,X7,X8,X9); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulatives_159(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); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntVarArgs X6 = gecode_IntVarArgs_from_term(space,YAP_ARG6); + IntArgs X7 = gecode_IntArgs_from_term(YAP_ARG7); + bool X8 = gecode_bool_from_term(YAP_ARG8); + IntConLevel X9 = gecode_IntConLevel_from_term(YAP_ARG9); + cumulatives(*space,X2,X3,X4,X5,X6,X7,X8,X9); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulatives_157(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); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + IntArgs X7 = gecode_IntArgs_from_term(YAP_ARG7); + bool X8 = gecode_bool_from_term(YAP_ARG8); + IntConLevel X9 = gecode_IntConLevel_from_term(YAP_ARG9); + cumulatives(*space,X2,X3,X4,X5,X6,X7,X8,X9); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulatives_155(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); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntVarArgs X6 = gecode_IntVarArgs_from_term(space,YAP_ARG6); + IntArgs X7 = gecode_IntArgs_from_term(YAP_ARG7); + bool X8 = gecode_bool_from_term(YAP_ARG8); + IntConLevel X9 = gecode_IntConLevel_from_term(YAP_ARG9); + cumulatives(*space,X2,X3,X4,X5,X6,X7,X8,X9); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulatives_153(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); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + IntArgs X7 = gecode_IntArgs_from_term(YAP_ARG7); + bool X8 = gecode_bool_from_term(YAP_ARG8); + IntConLevel X9 = gecode_IntConLevel_from_term(YAP_ARG9); + cumulatives(*space,X2,X3,X4,X5,X6,X7,X8,X9); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulatives_151(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); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntVarArgs X6 = gecode_IntVarArgs_from_term(space,YAP_ARG6); + IntArgs X7 = gecode_IntArgs_from_term(YAP_ARG7); + bool X8 = gecode_bool_from_term(YAP_ARG8); + IntConLevel X9 = gecode_IntConLevel_from_term(YAP_ARG9); + cumulatives(*space,X2,X3,X4,X5,X6,X7,X8,X9); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulatives_149(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); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + IntArgs X7 = gecode_IntArgs_from_term(YAP_ARG7); + bool X8 = gecode_bool_from_term(YAP_ARG8); + IntConLevel X9 = gecode_IntConLevel_from_term(YAP_ARG9); + cumulatives(*space,X2,X3,X4,X5,X6,X7,X8,X9); + return TRUE; +} + +static YAP_Bool gecode_constraint_nvalues_350(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); + nvalues(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_nvalues_352(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); + nvalues(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_nvalues_346(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); + int X4 = gecode_int_from_term(YAP_ARG4); + nvalues(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_nvalues_348(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); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + nvalues(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_binpacking_60(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); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + binpacking(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_linear_291(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); + Reify X6 = gecode_Reify_from_term(YAP_ARG6); + IntConLevel X7 = gecode_IntConLevel_from_term(YAP_ARG7); + linear(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static YAP_Bool gecode_constraint_linear_295(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); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + Reify X6 = gecode_Reify_from_term(YAP_ARG6); + IntConLevel X7 = gecode_IntConLevel_from_term(YAP_ARG7); + linear(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static YAP_Bool gecode_constraint_linear_283(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + BoolVarArgs X3 = gecode_BoolVarArgs_from_term(space,YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + Reify X6 = gecode_Reify_from_term(YAP_ARG6); + IntConLevel X7 = gecode_IntConLevel_from_term(YAP_ARG7); + linear(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static YAP_Bool gecode_constraint_linear_287(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + BoolVarArgs X3 = gecode_BoolVarArgs_from_term(space,YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + Reify X6 = gecode_Reify_from_term(YAP_ARG6); + IntConLevel X7 = gecode_IntConLevel_from_term(YAP_ARG7); + linear(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static YAP_Bool gecode_constraint_abs_52(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + abs(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_convex_96(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + convex(*space,X2); + return TRUE; +} + +static YAP_Bool gecode_constraint_div_169(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + div(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_div_168(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVar X2 = gecode_FloatVar_from_term(space,YAP_ARG2); + FloatVar X3 = gecode_FloatVar_from_term(space,YAP_ARG3); + FloatVar X4 = gecode_FloatVar_from_term(space,YAP_ARG4); + div(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_418(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); + Reify X5 = gecode_Reify_from_term(YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + rel(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_422(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); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + Reify X5 = gecode_Reify_from_term(YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + rel(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_401(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntSet X2 = gecode_IntSet_from_term(YAP_ARG2); + SetOpType X3 = gecode_SetOpType_from_term(YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + SetRelType X5 = gecode_SetRelType_from_term(YAP_ARG5); + IntSet X6 = gecode_IntSet_from_term(YAP_ARG6); + rel(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_402(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntSet X2 = gecode_IntSet_from_term(YAP_ARG2); + SetOpType X3 = gecode_SetOpType_from_term(YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + SetRelType X5 = gecode_SetRelType_from_term(YAP_ARG5); + SetVar X6 = gecode_SetVar_from_term(space,YAP_ARG6); + rel(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_390(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); + Reify X5 = gecode_Reify_from_term(YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + rel(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_386(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); + Reify X5 = gecode_Reify_from_term(YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + rel(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_382(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2); + BoolOpType X3 = gecode_BoolOpType_from_term(YAP_ARG3); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + rel(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_380(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2); + BoolOpType X3 = gecode_BoolOpType_from_term(YAP_ARG3); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + BoolVar X5 = gecode_BoolVar_from_term(space,YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + rel(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_431(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + SetOpType X3 = gecode_SetOpType_from_term(YAP_ARG3); + IntSet X4 = gecode_IntSet_from_term(YAP_ARG4); + SetRelType X5 = gecode_SetRelType_from_term(YAP_ARG5); + IntSet X6 = gecode_IntSet_from_term(YAP_ARG6); + rel(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_432(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + SetOpType X3 = gecode_SetOpType_from_term(YAP_ARG3); + IntSet X4 = gecode_IntSet_from_term(YAP_ARG4); + SetRelType X5 = gecode_SetRelType_from_term(YAP_ARG5); + SetVar X6 = gecode_SetVar_from_term(space,YAP_ARG6); + rel(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_433(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + SetOpType X3 = gecode_SetOpType_from_term(YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + SetRelType X5 = gecode_SetRelType_from_term(YAP_ARG5); + IntSet X6 = gecode_IntSet_from_term(YAP_ARG6); + rel(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_434(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + SetOpType X3 = gecode_SetOpType_from_term(YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + SetRelType X5 = gecode_SetRelType_from_term(YAP_ARG5); + SetVar X6 = gecode_SetVar_from_term(space,YAP_ARG6); + rel(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_weights_471(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntArgs X3 = gecode_IntArgs_from_term(YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + weights(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_max_309(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + max(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_path_359(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + IntVar X6 = gecode_IntVar_from_term(space,YAP_ARG6); + IntVarArgs X7 = gecode_IntVarArgs_from_term(space,YAP_ARG7); + IntVar X8 = gecode_IntVar_from_term(space,YAP_ARG8); + IntConLevel X9 = gecode_IntConLevel_from_term(YAP_ARG9); + path(*space,X2,X3,X4,X5,X6,X7,X8,X9); + return TRUE; +} + +static YAP_Bool gecode_constraint_unary_465(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); + unary(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_unary_461(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); + unary(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_unary_455(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntArgs X3 = gecode_IntArgs_from_term(YAP_ARG3); + BoolVarArgs X4 = gecode_BoolVarArgs_from_term(space,YAP_ARG4); + unary(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_unary_458(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntArgs X3 = gecode_IntArgs_from_term(YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + unary(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_nroot_344(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + nroot(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_nroot_343(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVar X2 = gecode_FloatVar_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + FloatVar X4 = gecode_FloatVar_from_term(space,YAP_ARG4); + nroot(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_sorted_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); + sorted(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_circuit_86(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + circuit(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_circuit_83(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); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + circuit(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_circuit_80(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); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + circuit(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_195(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVar X2 = gecode_FloatVar_from_term(space,YAP_ARG2); + FloatVal X3 = gecode_FloatVal_from_term(YAP_ARG3); + Reify X4 = gecode_Reify_from_term(YAP_ARG4); + dom(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_192(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVar X2 = gecode_FloatVar_from_term(space,YAP_ARG2); + FloatNum X3 = gecode_FloatNum_from_term(YAP_ARG3); + FloatNum X4 = gecode_FloatNum_from_term(YAP_ARG4); + dom(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_178(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVarArgs X2 = gecode_FloatVarArgs_from_term(space,YAP_ARG2); + FloatNum X3 = gecode_FloatNum_from_term(YAP_ARG3); + FloatNum X4 = gecode_FloatNum_from_term(YAP_ARG4); + dom(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_176(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + BoolVarArgs X3 = gecode_BoolVarArgs_from_term(space,YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + dom(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_174(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2); + BoolVar X3 = gecode_BoolVar_from_term(space,YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + dom(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_186(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + dom(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_185(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + dom(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_183(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); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + dom(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_181(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntSet X3 = gecode_IntSet_from_term(YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + dom(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_203(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + dom(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_207(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + Reify X4 = gecode_Reify_from_term(YAP_ARG4); + dom(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_202(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + dom(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_210(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + dom(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_199(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntSet X3 = gecode_IntSet_from_term(YAP_ARG3); + Reify X4 = gecode_Reify_from_term(YAP_ARG4); + dom(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_198(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntSet X3 = gecode_IntSet_from_term(YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + dom(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_190(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVarArgs X2 = gecode_SetVarArgs_from_term(space,YAP_ARG2); + SetRelType X3 = gecode_SetRelType_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + dom(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_189(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVarArgs X2 = gecode_SetVarArgs_from_term(space,YAP_ARG2); + SetRelType X3 = gecode_SetRelType_from_term(YAP_ARG3); + IntSet X4 = gecode_IntSet_from_term(YAP_ARG4); + dom(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_213(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + SetRelType X3 = gecode_SetRelType_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + dom(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_211(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + SetRelType X3 = gecode_SetRelType_from_term(YAP_ARG3); + IntSet X4 = gecode_IntSet_from_term(YAP_ARG4); + dom(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_abs_51(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + abs(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_abs_50(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVar X2 = gecode_FloatVar_from_term(space,YAP_ARG2); + FloatVar X3 = gecode_FloatVar_from_term(space,YAP_ARG3); + abs(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_channel_74(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + channel(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_channel_69(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + channel(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_assign_8(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVarArgs X2 = gecode_FloatVarArgs_from_term(space,YAP_ARG2); + FloatAssign X3 = gecode_FloatAssign_from_term(YAP_ARG3); + FloatBranchFilter X4 = gecode_FloatBranchFilter_from_term(YAP_ARG4); + FloatVarValPrint X5 = gecode_FloatVarValPrint_from_term(YAP_ARG5); + assign(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_assign_5(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntAssign X3 = gecode_IntAssign_from_term(YAP_ARG3); + BoolBranchFilter X4 = gecode_BoolBranchFilter_from_term(YAP_ARG4); + BoolVarValPrint X5 = gecode_BoolVarValPrint_from_term(YAP_ARG5); + assign(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_assign_11(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntAssign X3 = gecode_IntAssign_from_term(YAP_ARG3); + IntBranchFilter X4 = gecode_IntBranchFilter_from_term(YAP_ARG4); + IntVarValPrint X5 = gecode_IntVarValPrint_from_term(YAP_ARG5); + assign(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_assign_14(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVarArgs X2 = gecode_SetVarArgs_from_term(space,YAP_ARG2); + SetAssign X3 = gecode_SetAssign_from_term(YAP_ARG3); + SetBranchFilter X4 = gecode_SetBranchFilter_from_term(YAP_ARG4); + SetVarValPrint X5 = gecode_SetVarValPrint_from_term(YAP_ARG5); + assign(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_405(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); + rel(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_395(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); + rel(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_path_362(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + path(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_branch_45(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVar X2 = gecode_FloatVar_from_term(space,YAP_ARG2); + FloatValBranch X3 = gecode_FloatValBranch_from_term(YAP_ARG3); + FloatVarValPrint X4 = gecode_FloatVarValPrint_from_term(YAP_ARG4); + branch(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_branch_29(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVarArgs X2 = gecode_FloatVarArgs_from_term(space,YAP_ARG2); + FloatVarBranch X3 = gecode_FloatVarBranch_from_term(YAP_ARG3); + FloatValBranch X4 = gecode_FloatValBranch_from_term(YAP_ARG4); + branch(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_branch_23(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntVarBranch X3 = gecode_IntVarBranch_from_term(YAP_ARG3); + IntValBranch X4 = gecode_IntValBranch_from_term(YAP_ARG4); + branch(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_branch_22(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2); + IntValBranch X3 = gecode_IntValBranch_from_term(YAP_ARG3); + BoolVarValPrint X4 = gecode_BoolVarValPrint_from_term(YAP_ARG4); + branch(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_branch_35(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVarBranch X3 = gecode_IntVarBranch_from_term(YAP_ARG3); + IntValBranch X4 = gecode_IntValBranch_from_term(YAP_ARG4); + branch(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_branch_47(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntValBranch X3 = gecode_IntValBranch_from_term(YAP_ARG3); + IntVarValPrint X4 = gecode_IntVarValPrint_from_term(YAP_ARG4); + branch(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_branch_41(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVarArgs X2 = gecode_SetVarArgs_from_term(space,YAP_ARG2); + SetVarBranch X3 = gecode_SetVarBranch_from_term(YAP_ARG3); + SetValBranch X4 = gecode_SetValBranch_from_term(YAP_ARG4); + branch(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_branch_49(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + SetValBranch X3 = gecode_SetValBranch_from_term(YAP_ARG3); + SetVarValPrint X4 = gecode_SetVarValPrint_from_term(YAP_ARG4); + branch(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_mult_332(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + mult(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_circuit_87(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + circuit(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_circuit_84(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntVar X6 = gecode_IntVar_from_term(space,YAP_ARG6); + circuit(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_circuit_81(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); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + circuit(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_clause_94(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolOpType X2 = gecode_BoolOpType_from_term(YAP_ARG2); + BoolVarArgs X3 = gecode_BoolVarArgs_from_term(space,YAP_ARG3); + BoolVarArgs X4 = gecode_BoolVarArgs_from_term(space,YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + clause(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_clause_92(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolOpType X2 = gecode_BoolOpType_from_term(YAP_ARG2); + BoolVarArgs X3 = gecode_BoolVarArgs_from_term(space,YAP_ARG3); + BoolVarArgs X4 = gecode_BoolVarArgs_from_term(space,YAP_ARG4); + BoolVar X5 = gecode_BoolVar_from_term(space,YAP_ARG5); + clause(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_precede_374(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVarArgs X2 = gecode_SetVarArgs_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + precede(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_precede_371(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + precede(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_precede_370(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntArgs X3 = gecode_IntArgs_from_term(YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + precede(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_channel_75(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + channel(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulative_132(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + int X2 = gecode_int_from_term(YAP_ARG2); + TaskTypeArgs X3 = gecode_TaskTypeArgs_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + BoolVarArgs X7 = gecode_BoolVarArgs_from_term(space,YAP_ARG7); + cumulative(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulative_135(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + int X2 = gecode_int_from_term(YAP_ARG2); + TaskTypeArgs X3 = gecode_TaskTypeArgs_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + IntConLevel X7 = gecode_IntConLevel_from_term(YAP_ARG7); + cumulative(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulative_128(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + int X2 = gecode_int_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + BoolVarArgs X7 = gecode_BoolVarArgs_from_term(space,YAP_ARG7); + cumulative(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulative_131(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + int X2 = gecode_int_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + IntConLevel X7 = gecode_IntConLevel_from_term(YAP_ARG7); + cumulative(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulative_125(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + int X2 = gecode_int_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + BoolVarArgs X6 = gecode_BoolVarArgs_from_term(space,YAP_ARG6); + IntConLevel X7 = gecode_IntConLevel_from_term(YAP_ARG7); + cumulative(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulative_144(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + TaskTypeArgs X3 = gecode_TaskTypeArgs_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + BoolVarArgs X7 = gecode_BoolVarArgs_from_term(space,YAP_ARG7); + cumulative(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulative_147(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + TaskTypeArgs X3 = gecode_TaskTypeArgs_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + IntConLevel X7 = gecode_IntConLevel_from_term(YAP_ARG7); + cumulative(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulative_140(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + BoolVarArgs X7 = gecode_BoolVarArgs_from_term(space,YAP_ARG7); + cumulative(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulative_143(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + IntConLevel X7 = gecode_IntConLevel_from_term(YAP_ARG7); + cumulative(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulative_137(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + BoolVarArgs X6 = gecode_BoolVarArgs_from_term(space,YAP_ARG6); + IntConLevel X7 = gecode_IntConLevel_from_term(YAP_ARG7); + cumulative(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static YAP_Bool gecode_constraint_distinct_167(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntConLevel X3 = gecode_IntConLevel_from_term(YAP_ARG3); + distinct(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_distinct_164(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); + distinct(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_member_319(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + Reify X4 = gecode_Reify_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + member(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_member_315(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + BoolVar X3 = gecode_BoolVar_from_term(space,YAP_ARG3); + Reify X4 = gecode_Reify_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + member(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_mod_328(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + mod(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_sqr_450(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + sqr(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_sqr_449(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVar X2 = gecode_FloatVar_from_term(space,YAP_ARG2); + FloatVar X3 = gecode_FloatVar_from_term(space,YAP_ARG3); + sqr(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_sequence_442(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntSet X3 = gecode_IntSet_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + int X6 = gecode_int_from_term(YAP_ARG6); + IntConLevel X7 = gecode_IntConLevel_from_term(YAP_ARG7); + sequence(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static YAP_Bool gecode_constraint_sequence_440(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntSet X3 = gecode_IntSet_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + int X6 = gecode_int_from_term(YAP_ARG6); + IntConLevel X7 = gecode_IntConLevel_from_term(YAP_ARG7); + sequence(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static YAP_Bool gecode_constraint_path_360(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + IntVar X6 = gecode_IntVar_from_term(space,YAP_ARG6); + IntVar X7 = gecode_IntVar_from_term(space,YAP_ARG7); + path(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static YAP_Bool gecode_constraint_path_357(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); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + IntVar X6 = gecode_IntVar_from_term(space,YAP_ARG6); + IntConLevel X7 = gecode_IntConLevel_from_term(YAP_ARG7); + path(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static YAP_Bool gecode_constraint_path_354(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); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + IntVarArgs X6 = gecode_IntVarArgs_from_term(space,YAP_ARG6); + IntVar X7 = gecode_IntVar_from_term(space,YAP_ARG7); + path(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static YAP_Bool gecode_constraint_divmod_172(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + divmod(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_sorted_447(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); + sorted(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_extensional_258(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 YAP_Bool gecode_constraint_extensional_261(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 YAP_Bool gecode_constraint_extensional_253(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 YAP_Bool gecode_constraint_extensional_256(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 YAP_Bool gecode_constraint_circuit_90(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + int X2 = gecode_int_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + circuit(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_circuit_89(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntConLevel X3 = gecode_IntConLevel_from_term(YAP_ARG3); + circuit(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_argmin_57(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + bool X4 = gecode_bool_from_term(YAP_ARG4); + argmin(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_channel_77(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVar X2 = gecode_FloatVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + channel(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_channel_67(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + channel(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_channel_70(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + SetVar X3 = gecode_SetVar_from_term(space,YAP_ARG3); + channel(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_channel_65(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + channel(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_channel_73(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + SetVarArgs X3 = gecode_SetVarArgs_from_term(space,YAP_ARG3); + channel(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_channel_71(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); + channel(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_channel_78(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + FloatVar X3 = gecode_FloatVar_from_term(space,YAP_ARG3); + channel(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_channel_76(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVarArgs X2 = gecode_SetVarArgs_from_term(space,YAP_ARG2); + SetVarArgs X3 = gecode_SetVarArgs_from_term(space,YAP_ARG3); + channel(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_count_98(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntArgs X3 = gecode_IntArgs_from_term(YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + count(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_count_100(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntArgs X3 = gecode_IntArgs_from_term(YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + count(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_count_116(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + count(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_count_118(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + count(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_count_108(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntSet X3 = gecode_IntSet_from_term(YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + count(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_count_110(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntSet X3 = gecode_IntSet_from_term(YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + count(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_count_107(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntSet X3 = gecode_IntSet_from_term(YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + count(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_count_103(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntSetArgs X3 = gecode_IntSetArgs_from_term(YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + count(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_count_113(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); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + count(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_count_120(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + count(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_count_122(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + count(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulatives_162(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); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntVarArgs X6 = gecode_IntVarArgs_from_term(space,YAP_ARG6); + IntArgs X7 = gecode_IntArgs_from_term(YAP_ARG7); + bool X8 = gecode_bool_from_term(YAP_ARG8); + cumulatives(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulatives_160(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); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + IntArgs X7 = gecode_IntArgs_from_term(YAP_ARG7); + bool X8 = gecode_bool_from_term(YAP_ARG8); + cumulatives(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulatives_158(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); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntVarArgs X6 = gecode_IntVarArgs_from_term(space,YAP_ARG6); + IntArgs X7 = gecode_IntArgs_from_term(YAP_ARG7); + bool X8 = gecode_bool_from_term(YAP_ARG8); + cumulatives(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulatives_156(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); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + IntArgs X7 = gecode_IntArgs_from_term(YAP_ARG7); + bool X8 = gecode_bool_from_term(YAP_ARG8); + cumulatives(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulatives_154(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); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntVarArgs X6 = gecode_IntVarArgs_from_term(space,YAP_ARG6); + IntArgs X7 = gecode_IntArgs_from_term(YAP_ARG7); + bool X8 = gecode_bool_from_term(YAP_ARG8); + cumulatives(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulatives_152(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); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + IntArgs X7 = gecode_IntArgs_from_term(YAP_ARG7); + bool X8 = gecode_bool_from_term(YAP_ARG8); + cumulatives(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulatives_150(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); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntVarArgs X6 = gecode_IntVarArgs_from_term(space,YAP_ARG6); + IntArgs X7 = gecode_IntArgs_from_term(YAP_ARG7); + bool X8 = gecode_bool_from_term(YAP_ARG8); + cumulatives(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulatives_148(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); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + IntArgs X7 = gecode_IntArgs_from_term(YAP_ARG7); + bool X8 = gecode_bool_from_term(YAP_ARG8); + cumulatives(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static YAP_Bool gecode_constraint_binpacking_61(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); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + binpacking(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_extensional_257(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 YAP_Bool gecode_constraint_extensional_260(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 YAP_Bool gecode_constraint_extensional_252(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 YAP_Bool gecode_constraint_extensional_255(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 YAP_Bool gecode_constraint_linear_299(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); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + linear(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_linear_303(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); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + linear(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_linear_267(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); + int X4 = gecode_int_from_term(YAP_ARG4); + Reify X5 = gecode_Reify_from_term(YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + linear(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_linear_271(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); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + Reify X5 = gecode_Reify_from_term(YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + linear(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_linear_275(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatValArgs X2 = gecode_FloatValArgs_from_term(YAP_ARG2); + FloatVarArgs X3 = gecode_FloatVarArgs_from_term(space,YAP_ARG3); + FloatRelType X4 = gecode_FloatRelType_from_term(YAP_ARG4); + FloatVar X5 = gecode_FloatVar_from_term(space,YAP_ARG5); + Reify X6 = gecode_Reify_from_term(YAP_ARG6); + linear(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_linear_273(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatValArgs X2 = gecode_FloatValArgs_from_term(YAP_ARG2); + FloatVarArgs X3 = gecode_FloatVarArgs_from_term(space,YAP_ARG3); + FloatRelType X4 = gecode_FloatRelType_from_term(YAP_ARG4); + FloatNum X5 = gecode_FloatNum_from_term(YAP_ARG5); + Reify X6 = gecode_Reify_from_term(YAP_ARG6); + linear(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_linear_290(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); + Reify X6 = gecode_Reify_from_term(YAP_ARG6); + linear(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_linear_289(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); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + linear(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_linear_294(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); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + Reify X6 = gecode_Reify_from_term(YAP_ARG6); + linear(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_linear_293(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); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + linear(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_linear_282(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + BoolVarArgs X3 = gecode_BoolVarArgs_from_term(space,YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + Reify X6 = gecode_Reify_from_term(YAP_ARG6); + linear(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_linear_281(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + BoolVarArgs X3 = gecode_BoolVarArgs_from_term(space,YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + linear(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_linear_286(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + BoolVarArgs X3 = gecode_BoolVarArgs_from_term(space,YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + Reify X6 = gecode_Reify_from_term(YAP_ARG6); + linear(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_linear_285(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + BoolVarArgs X3 = gecode_BoolVarArgs_from_term(space,YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + linear(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_nooverlap_339(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); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntVarArgs X6 = gecode_IntVarArgs_from_term(space,YAP_ARG6); + IntVarArgs X7 = gecode_IntVarArgs_from_term(space,YAP_ARG7); + nooverlap(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static YAP_Bool gecode_constraint_nooverlap_334(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntArgs X3 = gecode_IntArgs_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + BoolVarArgs X6 = gecode_BoolVarArgs_from_term(space,YAP_ARG6); + IntConLevel X7 = gecode_IntConLevel_from_term(YAP_ARG7); + nooverlap(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static YAP_Bool gecode_constraint_div_170(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + div(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_sqr_451(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + sqr(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_path_361(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + IntVar X6 = gecode_IntVar_from_term(space,YAP_ARG6); + IntVar X7 = gecode_IntVar_from_term(space,YAP_ARG7); + IntConLevel X8 = gecode_IntConLevel_from_term(YAP_ARG8); + path(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static YAP_Bool gecode_constraint_path_358(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + IntVar X6 = gecode_IntVar_from_term(space,YAP_ARG6); + IntVarArgs X7 = gecode_IntVarArgs_from_term(space,YAP_ARG7); + IntVar X8 = gecode_IntVar_from_term(space,YAP_ARG8); + path(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static YAP_Bool gecode_constraint_path_355(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); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + IntVarArgs X6 = gecode_IntVarArgs_from_term(space,YAP_ARG6); + IntVar X7 = gecode_IntVar_from_term(space,YAP_ARG7); + IntConLevel X8 = gecode_IntConLevel_from_term(YAP_ARG8); + path(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static YAP_Bool gecode_constraint_unary_463(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); + BoolVarArgs X5 = gecode_BoolVarArgs_from_term(space,YAP_ARG5); + unary(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_unary_466(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 YAP_Bool gecode_constraint_unary_459(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 YAP_Bool gecode_constraint_unary_462(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 YAP_Bool gecode_constraint_unary_456(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntArgs X3 = gecode_IntArgs_from_term(YAP_ARG3); + BoolVarArgs X4 = gecode_BoolVarArgs_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + unary(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_sorted_445(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); + sorted(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_sorted_448(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); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + sorted(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_element_229(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + int X6 = gecode_int_from_term(YAP_ARG6); + IntVar X7 = gecode_IntVar_from_term(space,YAP_ARG7); + IntConLevel X8 = gecode_IntConLevel_from_term(YAP_ARG8); + element(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static YAP_Bool gecode_constraint_element_223(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + int X6 = gecode_int_from_term(YAP_ARG6); + BoolVar X7 = gecode_BoolVar_from_term(space,YAP_ARG7); + IntConLevel X8 = gecode_IntConLevel_from_term(YAP_ARG8); + element(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static YAP_Bool gecode_constraint_element_241(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + int X6 = gecode_int_from_term(YAP_ARG6); + IntVar X7 = gecode_IntVar_from_term(space,YAP_ARG7); + IntConLevel X8 = gecode_IntConLevel_from_term(YAP_ARG8); + element(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static YAP_Bool gecode_constraint_element_239(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + int X6 = gecode_int_from_term(YAP_ARG6); + BoolVar X7 = gecode_BoolVar_from_term(space,YAP_ARG7); + IntConLevel X8 = gecode_IntConLevel_from_term(YAP_ARG8); + element(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static YAP_Bool gecode_constraint_assign_16(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVar X2 = gecode_FloatVar_from_term(space,YAP_ARG2); + FloatAssign X3 = gecode_FloatAssign_from_term(YAP_ARG3); + FloatVarValPrint X4 = gecode_FloatVarValPrint_from_term(YAP_ARG4); + assign(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_assign_7(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVarArgs X2 = gecode_FloatVarArgs_from_term(space,YAP_ARG2); + FloatAssign X3 = gecode_FloatAssign_from_term(YAP_ARG3); + FloatBranchFilter X4 = gecode_FloatBranchFilter_from_term(YAP_ARG4); + assign(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_assign_4(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntAssign X3 = gecode_IntAssign_from_term(YAP_ARG3); + BoolBranchFilter X4 = gecode_BoolBranchFilter_from_term(YAP_ARG4); + assign(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_assign_2(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2); + IntAssign X3 = gecode_IntAssign_from_term(YAP_ARG3); + BoolVarValPrint X4 = gecode_BoolVarValPrint_from_term(YAP_ARG4); + assign(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_assign_10(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntAssign X3 = gecode_IntAssign_from_term(YAP_ARG3); + IntBranchFilter X4 = gecode_IntBranchFilter_from_term(YAP_ARG4); + assign(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_assign_18(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntAssign X3 = gecode_IntAssign_from_term(YAP_ARG3); + IntVarValPrint X4 = gecode_IntVarValPrint_from_term(YAP_ARG4); + assign(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_assign_13(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVarArgs X2 = gecode_SetVarArgs_from_term(space,YAP_ARG2); + SetAssign X3 = gecode_SetAssign_from_term(YAP_ARG3); + SetBranchFilter X4 = gecode_SetBranchFilter_from_term(YAP_ARG4); + assign(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_assign_20(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + SetAssign X3 = gecode_SetAssign_from_term(YAP_ARG3); + SetVarValPrint X4 = gecode_SetVarValPrint_from_term(YAP_ARG4); + assign(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_element_227(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + element(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_element_231(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + element(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_element_221(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + element(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_element_219(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + element(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_element_250(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetOpType X2 = gecode_SetOpType_from_term(YAP_ARG2); + SetVarArgs X3 = gecode_SetVarArgs_from_term(space,YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + SetVar X5 = gecode_SetVar_from_term(space,YAP_ARG5); + element(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_element_248(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetOpType X2 = gecode_SetOpType_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + SetVar X5 = gecode_SetVar_from_term(space,YAP_ARG5); + element(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_element_246(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetOpType X2 = gecode_SetOpType_from_term(YAP_ARG2); + IntSetArgs X3 = gecode_IntSetArgs_from_term(YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + SetVar X5 = gecode_SetVar_from_term(space,YAP_ARG5); + element(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_element_244(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetOpType X2 = gecode_SetOpType_from_term(YAP_ARG2); + IntArgs X3 = gecode_IntArgs_from_term(YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + SetVar X5 = gecode_SetVar_from_term(space,YAP_ARG5); + element(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_element_237(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + element(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_element_243(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + element(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_element_235(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + element(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_sequence_444(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVarArgs X2 = gecode_SetVarArgs_from_term(space,YAP_ARG2); + SetVar X3 = gecode_SetVar_from_term(space,YAP_ARG3); + sequence(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_branch_30(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVarArgs X2 = gecode_FloatVarArgs_from_term(space,YAP_ARG2); + FloatVarBranch X3 = gecode_FloatVarBranch_from_term(YAP_ARG3); + FloatValBranch X4 = gecode_FloatValBranch_from_term(YAP_ARG4); + FloatBranchFilter X5 = gecode_FloatBranchFilter_from_term(YAP_ARG5); + branch(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_branch_26(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntVarBranch X3 = gecode_IntVarBranch_from_term(YAP_ARG3); + IntValBranch X4 = gecode_IntValBranch_from_term(YAP_ARG4); + Symmetries X5 = gecode_Symmetries_from_term(YAP_ARG5); + branch(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_branch_24(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntVarBranch X3 = gecode_IntVarBranch_from_term(YAP_ARG3); + IntValBranch X4 = gecode_IntValBranch_from_term(YAP_ARG4); + BoolBranchFilter X5 = gecode_BoolBranchFilter_from_term(YAP_ARG5); + branch(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_branch_32(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVarBranch X3 = gecode_IntVarBranch_from_term(YAP_ARG3); + IntValBranch X4 = gecode_IntValBranch_from_term(YAP_ARG4); + Symmetries X5 = gecode_Symmetries_from_term(YAP_ARG5); + branch(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_branch_36(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVarBranch X3 = gecode_IntVarBranch_from_term(YAP_ARG3); + IntValBranch X4 = gecode_IntValBranch_from_term(YAP_ARG4); + IntBranchFilter X5 = gecode_IntBranchFilter_from_term(YAP_ARG5); + branch(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_branch_42(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVarArgs X2 = gecode_SetVarArgs_from_term(space,YAP_ARG2); + SetVarBranch X3 = gecode_SetVarBranch_from_term(YAP_ARG3); + SetValBranch X4 = gecode_SetValBranch_from_term(YAP_ARG4); + SetBranchFilter X5 = gecode_SetBranchFilter_from_term(YAP_ARG5); + branch(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_branch_38(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVarArgs X2 = gecode_SetVarArgs_from_term(space,YAP_ARG2); + SetVarBranch X3 = gecode_SetVarBranch_from_term(YAP_ARG3); + SetValBranch X4 = gecode_SetValBranch_from_term(YAP_ARG4); + Symmetries X5 = gecode_Symmetries_from_term(YAP_ARG5); + branch(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_circuit_85(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntVar X6 = gecode_IntVar_from_term(space,YAP_ARG6); + IntConLevel X7 = gecode_IntConLevel_from_term(YAP_ARG7); + circuit(*space,X2,X3,X4,X5,X6,X7); + return TRUE; +} + +static YAP_Bool gecode_constraint_pow_367(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + pow(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_pow_366(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVar X2 = gecode_FloatVar_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + FloatVar X4 = gecode_FloatVar_from_term(space,YAP_ARG4); + pow(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_precede_373(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVarArgs X2 = gecode_SetVarArgs_from_term(space,YAP_ARG2); + IntArgs X3 = gecode_IntArgs_from_term(YAP_ARG3); + precede(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_precede_369(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntArgs X3 = gecode_IntArgs_from_term(YAP_ARG3); + precede(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_argmax_55(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + bool X4 = gecode_bool_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + argmax(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulative_134(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + int X2 = gecode_int_from_term(YAP_ARG2); + TaskTypeArgs X3 = gecode_TaskTypeArgs_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + cumulative(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulative_130(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + int X2 = gecode_int_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + cumulative(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulative_124(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + int X2 = gecode_int_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + BoolVarArgs X6 = gecode_BoolVarArgs_from_term(space,YAP_ARG6); + cumulative(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulative_127(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + int X2 = gecode_int_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + cumulative(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulative_146(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + TaskTypeArgs X3 = gecode_TaskTypeArgs_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + cumulative(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulative_142(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + cumulative(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulative_136(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + BoolVarArgs X6 = gecode_BoolVarArgs_from_term(space,YAP_ARG6); + cumulative(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulative_139(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + cumulative(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_distinct_165(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); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + distinct(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_min_320(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVarArgs X2 = gecode_FloatVarArgs_from_term(space,YAP_ARG2); + FloatVar X3 = gecode_FloatVar_from_term(space,YAP_ARG3); + min(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_min_321(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + min(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_min_326(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + min(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_sqrt_454(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntConLevel X4 = gecode_IntConLevel_from_term(YAP_ARG4); + sqrt(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_sequence_441(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntSet X3 = gecode_IntSet_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + int X6 = gecode_int_from_term(YAP_ARG6); + sequence(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_sequence_439(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntSet X3 = gecode_IntSet_from_term(YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + int X6 = gecode_int_from_term(YAP_ARG6); + sequence(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_unshare_470(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntConLevel X3 = gecode_IntConLevel_from_term(YAP_ARG3); + unshare(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_unshare_468(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntConLevel X3 = gecode_IntConLevel_from_term(YAP_ARG3); + unshare(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_path_365(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + int X2 = gecode_int_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + path(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_path_356(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); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + IntVar X6 = gecode_IntVar_from_term(space,YAP_ARG6); + path(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_divmod_171(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + divmod(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_branch_31(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVarArgs X2 = gecode_FloatVarArgs_from_term(space,YAP_ARG2); + FloatVarBranch X3 = gecode_FloatVarBranch_from_term(YAP_ARG3); + FloatValBranch X4 = gecode_FloatValBranch_from_term(YAP_ARG4); + FloatBranchFilter X5 = gecode_FloatBranchFilter_from_term(YAP_ARG5); + FloatVarValPrint X6 = gecode_FloatVarValPrint_from_term(YAP_ARG6); + branch(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_branch_27(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntVarBranch X3 = gecode_IntVarBranch_from_term(YAP_ARG3); + IntValBranch X4 = gecode_IntValBranch_from_term(YAP_ARG4); + Symmetries X5 = gecode_Symmetries_from_term(YAP_ARG5); + BoolBranchFilter X6 = gecode_BoolBranchFilter_from_term(YAP_ARG6); + branch(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_branch_25(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + IntVarBranch X3 = gecode_IntVarBranch_from_term(YAP_ARG3); + IntValBranch X4 = gecode_IntValBranch_from_term(YAP_ARG4); + BoolBranchFilter X5 = gecode_BoolBranchFilter_from_term(YAP_ARG5); + BoolVarValPrint X6 = gecode_BoolVarValPrint_from_term(YAP_ARG6); + branch(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_branch_33(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVarBranch X3 = gecode_IntVarBranch_from_term(YAP_ARG3); + IntValBranch X4 = gecode_IntValBranch_from_term(YAP_ARG4); + Symmetries X5 = gecode_Symmetries_from_term(YAP_ARG5); + IntBranchFilter X6 = gecode_IntBranchFilter_from_term(YAP_ARG6); + branch(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_branch_37(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVarBranch X3 = gecode_IntVarBranch_from_term(YAP_ARG3); + IntValBranch X4 = gecode_IntValBranch_from_term(YAP_ARG4); + IntBranchFilter X5 = gecode_IntBranchFilter_from_term(YAP_ARG5); + IntVarValPrint X6 = gecode_IntVarValPrint_from_term(YAP_ARG6); + branch(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_branch_43(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVarArgs X2 = gecode_SetVarArgs_from_term(space,YAP_ARG2); + SetVarBranch X3 = gecode_SetVarBranch_from_term(YAP_ARG3); + SetValBranch X4 = gecode_SetValBranch_from_term(YAP_ARG4); + SetBranchFilter X5 = gecode_SetBranchFilter_from_term(YAP_ARG5); + SetVarValPrint X6 = gecode_SetVarValPrint_from_term(YAP_ARG6); + branch(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_branch_39(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVarArgs X2 = gecode_SetVarArgs_from_term(space,YAP_ARG2); + SetVarBranch X3 = gecode_SetVarBranch_from_term(YAP_ARG3); + SetValBranch X4 = gecode_SetValBranch_from_term(YAP_ARG4); + Symmetries X5 = gecode_Symmetries_from_term(YAP_ARG5); + SetBranchFilter X6 = gecode_SetBranchFilter_from_term(YAP_ARG6); + branch(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_nooverlap_338(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); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntVarArgs X6 = gecode_IntVarArgs_from_term(space,YAP_ARG6); + IntVarArgs X7 = gecode_IntVarArgs_from_term(space,YAP_ARG7); + BoolVarArgs X8 = gecode_BoolVarArgs_from_term(space,YAP_ARG8); + IntConLevel X9 = gecode_IntConLevel_from_term(YAP_ARG9); + nooverlap(*space,X2,X3,X4,X5,X6,X7,X8,X9); + return TRUE; +} + +static YAP_Bool gecode_constraint_argmin_58(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + bool X4 = gecode_bool_from_term(YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + argmin(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulative_126(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + int X2 = gecode_int_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + cumulative(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulative_138(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntArgs X4 = gecode_IntArgs_from_term(YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + cumulative(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_member_316(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + member(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_member_312(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + BoolVar X3 = gecode_BoolVar_from_term(space,YAP_ARG3); + member(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_count_117(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + count(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_count_119(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + count(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_count_121(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + count(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_count_123(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + count(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_count_109(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntSet X3 = gecode_IntSet_from_term(YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + count(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_count_111(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntSet X3 = gecode_IntSet_from_term(YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + count(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_count_99(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntArgs X3 = gecode_IntArgs_from_term(YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + int X5 = gecode_int_from_term(YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + count(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_count_101(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntArgs X3 = gecode_IntArgs_from_term(YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + count(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_pow_368(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + pow(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_notMin_342(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + notMin(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulative_133(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + int X2 = gecode_int_from_term(YAP_ARG2); + TaskTypeArgs X3 = gecode_TaskTypeArgs_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + BoolVarArgs X7 = gecode_BoolVarArgs_from_term(space,YAP_ARG7); + IntConLevel X8 = gecode_IntConLevel_from_term(YAP_ARG8); + cumulative(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulative_129(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + int X2 = gecode_int_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + BoolVarArgs X7 = gecode_BoolVarArgs_from_term(space,YAP_ARG7); + IntConLevel X8 = gecode_IntConLevel_from_term(YAP_ARG8); + cumulative(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulative_145(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + TaskTypeArgs X3 = gecode_TaskTypeArgs_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + BoolVarArgs X7 = gecode_BoolVarArgs_from_term(space,YAP_ARG7); + IntConLevel X8 = gecode_IntConLevel_from_term(YAP_ARG8); + cumulative(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static YAP_Bool gecode_constraint_cumulative_141(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntVarArgs X5 = gecode_IntVarArgs_from_term(space,YAP_ARG5); + IntArgs X6 = gecode_IntArgs_from_term(YAP_ARG6); + BoolVarArgs X7 = gecode_BoolVarArgs_from_term(space,YAP_ARG7); + IntConLevel X8 = gecode_IntConLevel_from_term(YAP_ARG8); + cumulative(*space,X2,X3,X4,X5,X6,X7,X8); + return TRUE; +} + +static YAP_Bool gecode_constraint_branch_46(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntValBranch X3 = gecode_IntValBranch_from_term(YAP_ARG3); + branch(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_branch_21(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2); + IntValBranch X3 = gecode_IntValBranch_from_term(YAP_ARG3); + branch(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_branch_44(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVar X2 = gecode_FloatVar_from_term(space,YAP_ARG2); + FloatValBranch X3 = gecode_FloatValBranch_from_term(YAP_ARG3); + branch(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_branch_48(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + SetValBranch X3 = gecode_SetValBranch_from_term(YAP_ARG3); + branch(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_194(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVar X2 = gecode_FloatVar_from_term(space,YAP_ARG2); + FloatVal X3 = gecode_FloatVal_from_term(YAP_ARG3); + dom(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_196(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVar X2 = gecode_FloatVar_from_term(space,YAP_ARG2); + FloatVar X3 = gecode_FloatVar_from_term(space,YAP_ARG3); + dom(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_177(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVarArgs X2 = gecode_FloatVarArgs_from_term(space,YAP_ARG2); + FloatVarArgs X3 = gecode_FloatVarArgs_from_term(space,YAP_ARG3); + dom(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_179(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVarArgs X2 = gecode_FloatVarArgs_from_term(space,YAP_ARG2); + FloatVal X3 = gecode_FloatVal_from_term(YAP_ARG3); + dom(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_175(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVarArgs X2 = gecode_BoolVarArgs_from_term(space,YAP_ARG2); + BoolVarArgs X3 = gecode_BoolVarArgs_from_term(space,YAP_ARG3); + dom(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_173(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2); + BoolVar X3 = gecode_BoolVar_from_term(space,YAP_ARG3); + dom(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_184(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + dom(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_182(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); + dom(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_180(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntSet X3 = gecode_IntSet_from_term(YAP_ARG3); + dom(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_201(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + int X3 = gecode_int_from_term(YAP_ARG3); + dom(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_209(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + dom(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_197(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntSet X3 = gecode_IntSet_from_term(YAP_ARG3); + dom(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_188(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVarArgs X2 = gecode_SetVarArgs_from_term(space,YAP_ARG2); + SetVarArgs X3 = gecode_SetVarArgs_from_term(space,YAP_ARG3); + dom(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_dom_217(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + SetVar X3 = gecode_SetVar_from_term(space,YAP_ARG3); + dom(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_linear_298(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 YAP_Bool gecode_constraint_linear_297(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 YAP_Bool gecode_constraint_linear_302(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 YAP_Bool gecode_constraint_linear_301(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 YAP_Bool gecode_constraint_linear_279(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVarArgs X2 = gecode_FloatVarArgs_from_term(space,YAP_ARG2); + FloatRelType X3 = gecode_FloatRelType_from_term(YAP_ARG3); + FloatVar X4 = gecode_FloatVar_from_term(space,YAP_ARG4); + Reify X5 = gecode_Reify_from_term(YAP_ARG5); + linear(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_linear_277(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVarArgs X2 = gecode_FloatVarArgs_from_term(space,YAP_ARG2); + FloatRelType X3 = gecode_FloatRelType_from_term(YAP_ARG3); + FloatNum X4 = gecode_FloatNum_from_term(YAP_ARG4); + Reify X5 = gecode_Reify_from_term(YAP_ARG5); + linear(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_linear_266(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); + 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 YAP_Bool gecode_constraint_linear_265(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); + 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 YAP_Bool gecode_constraint_linear_270(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); + 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 YAP_Bool gecode_constraint_linear_269(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); + 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 YAP_Bool gecode_constraint_linear_274(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatValArgs X2 = gecode_FloatValArgs_from_term(YAP_ARG2); + FloatVarArgs X3 = gecode_FloatVarArgs_from_term(space,YAP_ARG3); + FloatRelType X4 = gecode_FloatRelType_from_term(YAP_ARG4); + FloatVar X5 = gecode_FloatVar_from_term(space,YAP_ARG5); + linear(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_linear_272(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatValArgs X2 = gecode_FloatValArgs_from_term(YAP_ARG2); + FloatVarArgs X3 = gecode_FloatVarArgs_from_term(space,YAP_ARG3); + FloatRelType X4 = gecode_FloatRelType_from_term(YAP_ARG4); + FloatNum X5 = gecode_FloatNum_from_term(YAP_ARG5); + linear(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_linear_288(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 YAP_Bool gecode_constraint_linear_292(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); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + linear(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_linear_280(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + BoolVarArgs X3 = gecode_BoolVarArgs_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 YAP_Bool gecode_constraint_linear_284(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntArgs X2 = gecode_IntArgs_from_term(YAP_ARG2); + BoolVarArgs X3 = gecode_BoolVarArgs_from_term(space,YAP_ARG3); + IntRelType X4 = gecode_IntRelType_from_term(YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + linear(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_nooverlap_333(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntArgs X3 = gecode_IntArgs_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + BoolVarArgs X6 = gecode_BoolVarArgs_from_term(space,YAP_ARG6); + nooverlap(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_nooverlap_336(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntArgs X3 = gecode_IntArgs_from_term(YAP_ARG3); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + IntArgs X5 = gecode_IntArgs_from_term(YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + nooverlap(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_element_251(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetOpType X2 = gecode_SetOpType_from_term(YAP_ARG2); + SetVarArgs X3 = gecode_SetVarArgs_from_term(space,YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + SetVar X5 = gecode_SetVar_from_term(space,YAP_ARG5); + IntSet X6 = gecode_IntSet_from_term(YAP_ARG6); + element(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_element_249(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetOpType X2 = gecode_SetOpType_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + SetVar X5 = gecode_SetVar_from_term(space,YAP_ARG5); + IntSet X6 = gecode_IntSet_from_term(YAP_ARG6); + element(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_element_247(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetOpType X2 = gecode_SetOpType_from_term(YAP_ARG2); + IntSetArgs X3 = gecode_IntSetArgs_from_term(YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + SetVar X5 = gecode_SetVar_from_term(space,YAP_ARG5); + IntSet X6 = gecode_IntSet_from_term(YAP_ARG6); + element(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_element_245(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetOpType X2 = gecode_SetOpType_from_term(YAP_ARG2); + IntArgs X3 = gecode_IntArgs_from_term(YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + SetVar X5 = gecode_SetVar_from_term(space,YAP_ARG5); + IntSet X6 = gecode_IntSet_from_term(YAP_ARG6); + element(*space,X2,X3,X4,X5,X6); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_411(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVar X2 = gecode_FloatVar_from_term(space,YAP_ARG2); + FloatRelType X3 = gecode_FloatRelType_from_term(YAP_ARG3); + FloatVal X4 = gecode_FloatVal_from_term(YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_413(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVar X2 = gecode_FloatVar_from_term(space,YAP_ARG2); + FloatRelType X3 = gecode_FloatRelType_from_term(YAP_ARG3); + FloatVar X4 = gecode_FloatVar_from_term(space,YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_429(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetOpType X2 = gecode_SetOpType_from_term(YAP_ARG2); + SetVarArgs X3 = gecode_SetVarArgs_from_term(space,YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_427(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetOpType X2 = gecode_SetOpType_from_term(YAP_ARG2); + IntVarArgs X3 = gecode_IntVarArgs_from_term(space,YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_399(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVarArgs X2 = gecode_FloatVarArgs_from_term(space,YAP_ARG2); + FloatRelType X3 = gecode_FloatRelType_from_term(YAP_ARG3); + FloatVal X4 = gecode_FloatVal_from_term(YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_400(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + FloatVarArgs X2 = gecode_FloatVarArgs_from_term(space,YAP_ARG2); + FloatRelType X3 = gecode_FloatRelType_from_term(YAP_ARG3); + FloatVar X4 = gecode_FloatVar_from_term(space,YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_397(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); + int X4 = gecode_int_from_term(YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_393(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); + BoolVarArgs X4 = gecode_BoolVarArgs_from_term(space,YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_391(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); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_396(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 YAP_Bool gecode_constraint_rel_387(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 YAP_Bool gecode_constraint_rel_383(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 YAP_Bool gecode_constraint_rel_407(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 YAP_Bool gecode_constraint_rel_409(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 YAP_Bool 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); + IntVarArgs X4 = gecode_IntVarArgs_from_term(space,YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_406(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 YAP_Bool gecode_constraint_rel_415(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 YAP_Bool gecode_constraint_rel_419(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); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_423(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); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_424(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + SetRelType X3 = gecode_SetRelType_from_term(YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_430(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_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 YAP_Bool gecode_constraint_rel_435(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + SetRelType X3 = gecode_SetRelType_from_term(YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_437(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + SetVar X2 = gecode_SetVar_from_term(space,YAP_ARG2); + SetRelType X3 = gecode_SetRelType_from_term(YAP_ARG3); + SetVar X4 = gecode_SetVar_from_term(space,YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_377(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolOpType X2 = gecode_BoolOpType_from_term(YAP_ARG2); + BoolVarArgs X3 = gecode_BoolVarArgs_from_term(space,YAP_ARG3); + int X4 = gecode_int_from_term(YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_rel_375(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolOpType X2 = gecode_BoolOpType_from_term(YAP_ARG2); + BoolVarArgs X3 = gecode_BoolVarArgs_from_term(space,YAP_ARG3); + BoolVar X4 = gecode_BoolVar_from_term(space,YAP_ARG4); + rel(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_min_325(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVar X2 = gecode_IntVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntConLevel X5 = gecode_IntConLevel_from_term(YAP_ARG5); + min(*space,X2,X3,X4,X5); + return TRUE; +} + +static YAP_Bool gecode_constraint_count_114(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); + count(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_count_104(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntSetArgs X3 = gecode_IntSetArgs_from_term(YAP_ARG3); + count(*space,X2,X3); + return TRUE; +} + +static YAP_Bool gecode_constraint_argmax_54(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + IntVarArgs X2 = gecode_IntVarArgs_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + bool X4 = gecode_bool_from_term(YAP_ARG4); + argmax(*space,X2,X3,X4); + return TRUE; +} + +static YAP_Bool gecode_constraint_ite_263(void) +{ + GenericSpace* space = gecode_Space_from_term(YAP_ARG1); + BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2); + IntVar X3 = gecode_IntVar_from_term(space,YAP_ARG3); + IntVar X4 = gecode_IntVar_from_term(space,YAP_ARG4); + IntVar X5 = gecode_IntVar_from_term(space,YAP_ARG5); + IntConLevel X6 = gecode_IntConLevel_from_term(YAP_ARG6); + ite(*space,X2,X3,X4,X5,X6); + return TRUE; +} + diff --git a/packages/gecode/4.4.0/gecode_yap_cc_init_auto_generated.icc b/packages/gecode/4.4.0/gecode_yap_cc_init_auto_generated.icc new file mode 100644 index 000000000..c3f4cbd90 --- /dev/null +++ b/packages/gecode/4.4.0/gecode_yap_cc_init_auto_generated.icc @@ -0,0 +1,646 @@ +// -*- c++ -*- +//============================================================================= +// 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 . +//============================================================================= + +{ YAP_Atom X= YAP_LookupAtom("RM_NONE"); + gecode_RM_NONE = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("RM_CONSTANT"); + gecode_RM_CONSTANT = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("RM_LINEAR"); + gecode_RM_LINEAR = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("RM_LUBY"); + gecode_RM_LUBY = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("RM_GEOMETRIC"); + gecode_RM_GEOMETRIC = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } + +{ YAP_Atom X= YAP_LookupAtom("FRT_EQ"); + gecode_FRT_EQ = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("FRT_NQ"); + gecode_FRT_NQ = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("FRT_LQ"); + gecode_FRT_LQ = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("FRT_LE"); + gecode_FRT_LE = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("FRT_GQ"); + gecode_FRT_GQ = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("FRT_GR"); + gecode_FRT_GR = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } + +{ YAP_Atom X= YAP_LookupAtom("RM_EQV"); + gecode_RM_EQV = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("RM_IMP"); + gecode_RM_IMP = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("RM_PMI"); + gecode_RM_PMI = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } + +{ YAP_Atom X= YAP_LookupAtom("IRT_EQ"); + gecode_IRT_EQ = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("IRT_NQ"); + gecode_IRT_NQ = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("IRT_LQ"); + gecode_IRT_LQ = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("IRT_LE"); + gecode_IRT_LE = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("IRT_GQ"); + gecode_IRT_GQ = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("IRT_GR"); + gecode_IRT_GR = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } + +{ YAP_Atom X= YAP_LookupAtom("BOT_AND"); + gecode_BOT_AND = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("BOT_OR"); + gecode_BOT_OR = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("BOT_IMP"); + gecode_BOT_IMP = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("BOT_EQV"); + gecode_BOT_EQV = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("BOT_XOR"); + gecode_BOT_XOR = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } + +{ YAP_Atom X= YAP_LookupAtom("ICL_VAL"); + gecode_ICL_VAL = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("ICL_BND"); + gecode_ICL_BND = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("ICL_DOM"); + gecode_ICL_DOM = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("ICL_DEF"); + gecode_ICL_DEF = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } + +{ YAP_Atom X= YAP_LookupAtom("TT_FIXP"); + gecode_TT_FIXP = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("TT_FIXS"); + gecode_TT_FIXS = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("TT_FIXE"); + gecode_TT_FIXE = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } + +{ YAP_Atom X= YAP_LookupAtom("EPK_DEF"); + gecode_EPK_DEF = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("EPK_SPEED"); + gecode_EPK_SPEED = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("EPK_MEMORY"); + gecode_EPK_MEMORY = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } + +{ YAP_Atom X= YAP_LookupAtom("SRT_EQ"); + gecode_SRT_EQ = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SRT_NQ"); + gecode_SRT_NQ = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SRT_SUB"); + gecode_SRT_SUB = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SRT_SUP"); + gecode_SRT_SUP = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SRT_DISJ"); + gecode_SRT_DISJ = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SRT_CMPL"); + gecode_SRT_CMPL = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SRT_LQ"); + gecode_SRT_LQ = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SRT_LE"); + gecode_SRT_LE = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SRT_GQ"); + gecode_SRT_GQ = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SRT_GR"); + gecode_SRT_GR = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } + +{ YAP_Atom X= YAP_LookupAtom("SOT_UNION"); + gecode_SOT_UNION = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SOT_DUNION"); + gecode_SOT_DUNION = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SOT_INTER"); + gecode_SOT_INTER = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } +{ YAP_Atom X= YAP_LookupAtom("SOT_MINUS"); + gecode_SOT_MINUS = YAP_MkAtomTerm(X); + YAP_AtomGetHold(X); } + +YAP_UserCPredicate("gecode_constraint_unary_464", gecode_constraint_unary_464, 6); +YAP_UserCPredicate("gecode_constraint_unary_460", gecode_constraint_unary_460, 6); +YAP_UserCPredicate("gecode_constraint_nvalues_351", gecode_constraint_nvalues_351, 5); +YAP_UserCPredicate("gecode_constraint_nvalues_353", gecode_constraint_nvalues_353, 5); +YAP_UserCPredicate("gecode_constraint_nvalues_347", gecode_constraint_nvalues_347, 5); +YAP_UserCPredicate("gecode_constraint_nvalues_349", gecode_constraint_nvalues_349, 5); +YAP_UserCPredicate("gecode_constraint_max_308", gecode_constraint_max_308, 4); +YAP_UserCPredicate("gecode_constraint_max_306", gecode_constraint_max_306, 4); +YAP_UserCPredicate("gecode_constraint_max_307", gecode_constraint_max_307, 4); +YAP_UserCPredicate("gecode_constraint_max_311", gecode_constraint_max_311, 4); +YAP_UserCPredicate("gecode_constraint_dom_206", gecode_constraint_dom_206, 6); +YAP_UserCPredicate("gecode_constraint_dom_215", gecode_constraint_dom_215, 6); +YAP_UserCPredicate("gecode_constraint_argmin_56", gecode_constraint_argmin_56, 3); +YAP_UserCPredicate("gecode_constraint_convex_97", gecode_constraint_convex_97, 3); +YAP_UserCPredicate("gecode_constraint_nooverlap_335", gecode_constraint_nooverlap_335, 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); +YAP_UserCPredicate("gecode_constraint_assign_1", gecode_constraint_assign_1, 3); +YAP_UserCPredicate("gecode_constraint_assign_9", gecode_constraint_assign_9, 3); +YAP_UserCPredicate("gecode_constraint_assign_17", gecode_constraint_assign_17, 3); +YAP_UserCPredicate("gecode_constraint_assign_12", gecode_constraint_assign_12, 3); +YAP_UserCPredicate("gecode_constraint_assign_19", gecode_constraint_assign_19, 3); +YAP_UserCPredicate("gecode_constraint_element_226", gecode_constraint_element_226, 4); +YAP_UserCPredicate("gecode_constraint_element_230", gecode_constraint_element_230, 4); +YAP_UserCPredicate("gecode_constraint_element_220", gecode_constraint_element_220, 4); +YAP_UserCPredicate("gecode_constraint_element_218", gecode_constraint_element_218, 4); +YAP_UserCPredicate("gecode_constraint_element_225", gecode_constraint_element_225, 4); +YAP_UserCPredicate("gecode_constraint_element_233", gecode_constraint_element_233, 4); +YAP_UserCPredicate("gecode_constraint_element_236", gecode_constraint_element_236, 4); +YAP_UserCPredicate("gecode_constraint_element_242", gecode_constraint_element_242, 4); +YAP_UserCPredicate("gecode_constraint_element_234", gecode_constraint_element_234, 4); +YAP_UserCPredicate("gecode_constraint_sequence_443", gecode_constraint_sequence_443, 2); +YAP_UserCPredicate("gecode_constraint_notMax_341", gecode_constraint_notMax_341, 3); +YAP_UserCPredicate("gecode_constraint_ite_262", gecode_constraint_ite_262, 5); +YAP_UserCPredicate("gecode_constraint_unary_457", gecode_constraint_unary_457, 3); +YAP_UserCPredicate("gecode_constraint_nroot_345", gecode_constraint_nroot_345, 5); +YAP_UserCPredicate("gecode_constraint_circuit_91", gecode_constraint_circuit_91, 4); +YAP_UserCPredicate("gecode_constraint_circuit_82", gecode_constraint_circuit_82, 4); +YAP_UserCPredicate("gecode_constraint_dom_205", gecode_constraint_dom_205, 5); +YAP_UserCPredicate("gecode_constraint_dom_204", gecode_constraint_dom_204, 5); +YAP_UserCPredicate("gecode_constraint_dom_208", gecode_constraint_dom_208, 5); +YAP_UserCPredicate("gecode_constraint_dom_200", gecode_constraint_dom_200, 5); +YAP_UserCPredicate("gecode_constraint_dom_191", gecode_constraint_dom_191, 5); +YAP_UserCPredicate("gecode_constraint_dom_187", gecode_constraint_dom_187, 5); +YAP_UserCPredicate("gecode_constraint_dom_193", gecode_constraint_dom_193, 5); +YAP_UserCPredicate("gecode_constraint_dom_214", gecode_constraint_dom_214, 5); +YAP_UserCPredicate("gecode_constraint_dom_216", gecode_constraint_dom_216, 5); +YAP_UserCPredicate("gecode_constraint_dom_212", gecode_constraint_dom_212, 5); +YAP_UserCPredicate("gecode_constraint_channel_72", gecode_constraint_channel_72, 4); +YAP_UserCPredicate("gecode_constraint_channel_68", gecode_constraint_channel_68, 4); +YAP_UserCPredicate("gecode_constraint_channel_66", gecode_constraint_channel_66, 4); +YAP_UserCPredicate("gecode_constraint_nooverlap_337", gecode_constraint_nooverlap_337, 8); +YAP_UserCPredicate("gecode_constraint_nooverlap_340", gecode_constraint_nooverlap_340, 8); +YAP_UserCPredicate("gecode_constraint_element_228", gecode_constraint_element_228, 7); +YAP_UserCPredicate("gecode_constraint_element_222", gecode_constraint_element_222, 7); +YAP_UserCPredicate("gecode_constraint_element_224", gecode_constraint_element_224, 7); +YAP_UserCPredicate("gecode_constraint_element_232", gecode_constraint_element_232, 7); +YAP_UserCPredicate("gecode_constraint_element_240", gecode_constraint_element_240, 7); +YAP_UserCPredicate("gecode_constraint_element_238", gecode_constraint_element_238, 7); +YAP_UserCPredicate("gecode_constraint_max_304", gecode_constraint_max_304, 3); +YAP_UserCPredicate("gecode_constraint_max_305", gecode_constraint_max_305, 3); +YAP_UserCPredicate("gecode_constraint_max_310", gecode_constraint_max_310, 3); +YAP_UserCPredicate("gecode_constraint_unshare_469", gecode_constraint_unshare_469, 2); +YAP_UserCPredicate("gecode_constraint_unshare_467", gecode_constraint_unshare_467, 2); +YAP_UserCPredicate("gecode_constraint_path_364", gecode_constraint_path_364, 5); +YAP_UserCPredicate("gecode_constraint_path_363", gecode_constraint_path_363, 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_331", gecode_constraint_mult_331, 4); +YAP_UserCPredicate("gecode_constraint_mult_330", gecode_constraint_mult_330, 4); +YAP_UserCPredicate("gecode_constraint_clause_95", gecode_constraint_clause_95, 6); +YAP_UserCPredicate("gecode_constraint_clause_93", gecode_constraint_clause_93, 6); +YAP_UserCPredicate("gecode_constraint_precede_372", gecode_constraint_precede_372, 5); +YAP_UserCPredicate("gecode_constraint_argmax_53", gecode_constraint_argmax_53, 3); +YAP_UserCPredicate("gecode_constraint_distinct_166", gecode_constraint_distinct_166, 2); +YAP_UserCPredicate("gecode_constraint_member_318", gecode_constraint_member_318, 4); +YAP_UserCPredicate("gecode_constraint_member_317", gecode_constraint_member_317, 4); +YAP_UserCPredicate("gecode_constraint_member_314", gecode_constraint_member_314, 4); +YAP_UserCPredicate("gecode_constraint_member_313", gecode_constraint_member_313, 4); +YAP_UserCPredicate("gecode_constraint_mod_329", gecode_constraint_mod_329, 5); +YAP_UserCPredicate("gecode_constraint_cardinality_63", gecode_constraint_cardinality_63, 3); +YAP_UserCPredicate("gecode_constraint_atmostOne_59", gecode_constraint_atmostOne_59, 3); +YAP_UserCPredicate("gecode_constraint_channelSorted_79", gecode_constraint_channelSorted_79, 3); +YAP_UserCPredicate("gecode_constraint_extensional_259", gecode_constraint_extensional_259, 5); +YAP_UserCPredicate("gecode_constraint_extensional_254", gecode_constraint_extensional_254, 5); +YAP_UserCPredicate("gecode_constraint_linear_278", gecode_constraint_linear_278, 4); +YAP_UserCPredicate("gecode_constraint_linear_276", gecode_constraint_linear_276, 4); +YAP_UserCPredicate("gecode_constraint_linear_264", gecode_constraint_linear_264, 4); +YAP_UserCPredicate("gecode_constraint_linear_268", gecode_constraint_linear_268, 4); +YAP_UserCPredicate("gecode_constraint_linear_296", gecode_constraint_linear_296, 4); +YAP_UserCPredicate("gecode_constraint_linear_300", gecode_constraint_linear_300, 4); +YAP_UserCPredicate("gecode_constraint_circuit_88", gecode_constraint_circuit_88, 2); +YAP_UserCPredicate("gecode_constraint_rel_412", gecode_constraint_rel_412, 5); +YAP_UserCPredicate("gecode_constraint_rel_414", gecode_constraint_rel_414, 5); +YAP_UserCPredicate("gecode_constraint_rel_428", gecode_constraint_rel_428, 5); +YAP_UserCPredicate("gecode_constraint_rel_426", gecode_constraint_rel_426, 5); +YAP_UserCPredicate("gecode_constraint_rel_398", gecode_constraint_rel_398, 5); +YAP_UserCPredicate("gecode_constraint_rel_394", gecode_constraint_rel_394, 5); +YAP_UserCPredicate("gecode_constraint_rel_392", gecode_constraint_rel_392, 5); +YAP_UserCPredicate("gecode_constraint_rel_389", gecode_constraint_rel_389, 5); +YAP_UserCPredicate("gecode_constraint_rel_388", gecode_constraint_rel_388, 5); +YAP_UserCPredicate("gecode_constraint_rel_385", gecode_constraint_rel_385, 5); +YAP_UserCPredicate("gecode_constraint_rel_384", gecode_constraint_rel_384, 5); +YAP_UserCPredicate("gecode_constraint_rel_381", gecode_constraint_rel_381, 5); +YAP_UserCPredicate("gecode_constraint_rel_379", gecode_constraint_rel_379, 5); +YAP_UserCPredicate("gecode_constraint_rel_408", gecode_constraint_rel_408, 5); +YAP_UserCPredicate("gecode_constraint_rel_410", gecode_constraint_rel_410, 5); +YAP_UserCPredicate("gecode_constraint_rel_404", gecode_constraint_rel_404, 5); +YAP_UserCPredicate("gecode_constraint_rel_417", gecode_constraint_rel_417, 5); +YAP_UserCPredicate("gecode_constraint_rel_416", gecode_constraint_rel_416, 5); +YAP_UserCPredicate("gecode_constraint_rel_421", gecode_constraint_rel_421, 5); +YAP_UserCPredicate("gecode_constraint_rel_420", gecode_constraint_rel_420, 5); +YAP_UserCPredicate("gecode_constraint_rel_425", gecode_constraint_rel_425, 5); +YAP_UserCPredicate("gecode_constraint_rel_436", gecode_constraint_rel_436, 5); +YAP_UserCPredicate("gecode_constraint_rel_438", gecode_constraint_rel_438, 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_min_324", gecode_constraint_min_324, 4); +YAP_UserCPredicate("gecode_constraint_min_322", gecode_constraint_min_322, 4); +YAP_UserCPredicate("gecode_constraint_min_323", gecode_constraint_min_323, 4); +YAP_UserCPredicate("gecode_constraint_min_327", gecode_constraint_min_327, 4); +YAP_UserCPredicate("gecode_constraint_cardinality_62", gecode_constraint_cardinality_62, 4); +YAP_UserCPredicate("gecode_constraint_cardinality_64", gecode_constraint_cardinality_64, 4); +YAP_UserCPredicate("gecode_constraint_count_115", gecode_constraint_count_115, 4); +YAP_UserCPredicate("gecode_constraint_count_112", gecode_constraint_count_112, 4); +YAP_UserCPredicate("gecode_constraint_count_106", gecode_constraint_count_106, 4); +YAP_UserCPredicate("gecode_constraint_count_105", gecode_constraint_count_105, 4); +YAP_UserCPredicate("gecode_constraint_count_102", gecode_constraint_count_102, 4); +YAP_UserCPredicate("gecode_constraint_sqrt_453", gecode_constraint_sqrt_453, 3); +YAP_UserCPredicate("gecode_constraint_sqrt_452", gecode_constraint_sqrt_452, 3); +YAP_UserCPredicate("gecode_constraint_cumulatives_163", gecode_constraint_cumulatives_163, 9); +YAP_UserCPredicate("gecode_constraint_cumulatives_161", gecode_constraint_cumulatives_161, 9); +YAP_UserCPredicate("gecode_constraint_cumulatives_159", gecode_constraint_cumulatives_159, 9); +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); +YAP_UserCPredicate("gecode_constraint_cumulatives_151", gecode_constraint_cumulatives_151, 9); +YAP_UserCPredicate("gecode_constraint_cumulatives_149", gecode_constraint_cumulatives_149, 9); +YAP_UserCPredicate("gecode_constraint_nvalues_350", gecode_constraint_nvalues_350, 4); +YAP_UserCPredicate("gecode_constraint_nvalues_352", gecode_constraint_nvalues_352, 4); +YAP_UserCPredicate("gecode_constraint_nvalues_346", gecode_constraint_nvalues_346, 4); +YAP_UserCPredicate("gecode_constraint_nvalues_348", gecode_constraint_nvalues_348, 4); +YAP_UserCPredicate("gecode_constraint_binpacking_60", gecode_constraint_binpacking_60, 4); +YAP_UserCPredicate("gecode_constraint_linear_291", gecode_constraint_linear_291, 7); +YAP_UserCPredicate("gecode_constraint_linear_295", gecode_constraint_linear_295, 7); +YAP_UserCPredicate("gecode_constraint_linear_283", gecode_constraint_linear_283, 7); +YAP_UserCPredicate("gecode_constraint_linear_287", gecode_constraint_linear_287, 7); +YAP_UserCPredicate("gecode_constraint_abs_52", gecode_constraint_abs_52, 4); +YAP_UserCPredicate("gecode_constraint_convex_96", gecode_constraint_convex_96, 2); +YAP_UserCPredicate("gecode_constraint_div_169", gecode_constraint_div_169, 4); +YAP_UserCPredicate("gecode_constraint_div_168", gecode_constraint_div_168, 4); +YAP_UserCPredicate("gecode_constraint_rel_418", gecode_constraint_rel_418, 6); +YAP_UserCPredicate("gecode_constraint_rel_422", gecode_constraint_rel_422, 6); +YAP_UserCPredicate("gecode_constraint_rel_401", gecode_constraint_rel_401, 6); +YAP_UserCPredicate("gecode_constraint_rel_402", gecode_constraint_rel_402, 6); +YAP_UserCPredicate("gecode_constraint_rel_390", gecode_constraint_rel_390, 6); +YAP_UserCPredicate("gecode_constraint_rel_386", gecode_constraint_rel_386, 6); +YAP_UserCPredicate("gecode_constraint_rel_382", gecode_constraint_rel_382, 6); +YAP_UserCPredicate("gecode_constraint_rel_380", gecode_constraint_rel_380, 6); +YAP_UserCPredicate("gecode_constraint_rel_431", gecode_constraint_rel_431, 6); +YAP_UserCPredicate("gecode_constraint_rel_432", gecode_constraint_rel_432, 6); +YAP_UserCPredicate("gecode_constraint_rel_433", gecode_constraint_rel_433, 6); +YAP_UserCPredicate("gecode_constraint_rel_434", gecode_constraint_rel_434, 6); +YAP_UserCPredicate("gecode_constraint_weights_471", gecode_constraint_weights_471, 5); +YAP_UserCPredicate("gecode_constraint_max_309", gecode_constraint_max_309, 5); +YAP_UserCPredicate("gecode_constraint_path_359", gecode_constraint_path_359, 9); +YAP_UserCPredicate("gecode_constraint_unary_465", gecode_constraint_unary_465, 4); +YAP_UserCPredicate("gecode_constraint_unary_461", gecode_constraint_unary_461, 4); +YAP_UserCPredicate("gecode_constraint_unary_455", gecode_constraint_unary_455, 4); +YAP_UserCPredicate("gecode_constraint_unary_458", gecode_constraint_unary_458, 4); +YAP_UserCPredicate("gecode_constraint_nroot_344", gecode_constraint_nroot_344, 4); +YAP_UserCPredicate("gecode_constraint_nroot_343", gecode_constraint_nroot_343, 4); +YAP_UserCPredicate("gecode_constraint_sorted_446", gecode_constraint_sorted_446, 5); +YAP_UserCPredicate("gecode_constraint_circuit_86", gecode_constraint_circuit_86, 5); +YAP_UserCPredicate("gecode_constraint_circuit_83", gecode_constraint_circuit_83, 5); +YAP_UserCPredicate("gecode_constraint_circuit_80", gecode_constraint_circuit_80, 5); +YAP_UserCPredicate("gecode_constraint_dom_195", gecode_constraint_dom_195, 4); +YAP_UserCPredicate("gecode_constraint_dom_192", gecode_constraint_dom_192, 4); +YAP_UserCPredicate("gecode_constraint_dom_178", gecode_constraint_dom_178, 4); +YAP_UserCPredicate("gecode_constraint_dom_176", gecode_constraint_dom_176, 4); +YAP_UserCPredicate("gecode_constraint_dom_174", gecode_constraint_dom_174, 4); +YAP_UserCPredicate("gecode_constraint_dom_186", gecode_constraint_dom_186, 4); +YAP_UserCPredicate("gecode_constraint_dom_185", gecode_constraint_dom_185, 4); +YAP_UserCPredicate("gecode_constraint_dom_183", gecode_constraint_dom_183, 4); +YAP_UserCPredicate("gecode_constraint_dom_181", gecode_constraint_dom_181, 4); +YAP_UserCPredicate("gecode_constraint_dom_203", gecode_constraint_dom_203, 4); +YAP_UserCPredicate("gecode_constraint_dom_207", gecode_constraint_dom_207, 4); +YAP_UserCPredicate("gecode_constraint_dom_202", gecode_constraint_dom_202, 4); +YAP_UserCPredicate("gecode_constraint_dom_210", gecode_constraint_dom_210, 4); +YAP_UserCPredicate("gecode_constraint_dom_199", gecode_constraint_dom_199, 4); +YAP_UserCPredicate("gecode_constraint_dom_198", gecode_constraint_dom_198, 4); +YAP_UserCPredicate("gecode_constraint_dom_190", gecode_constraint_dom_190, 4); +YAP_UserCPredicate("gecode_constraint_dom_189", gecode_constraint_dom_189, 4); +YAP_UserCPredicate("gecode_constraint_dom_213", gecode_constraint_dom_213, 4); +YAP_UserCPredicate("gecode_constraint_dom_211", gecode_constraint_dom_211, 4); +YAP_UserCPredicate("gecode_constraint_abs_51", gecode_constraint_abs_51, 3); +YAP_UserCPredicate("gecode_constraint_abs_50", gecode_constraint_abs_50, 3); +YAP_UserCPredicate("gecode_constraint_channel_74", gecode_constraint_channel_74, 5); +YAP_UserCPredicate("gecode_constraint_channel_69", gecode_constraint_channel_69, 5); +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_405", gecode_constraint_rel_405, 3); +YAP_UserCPredicate("gecode_constraint_rel_395", gecode_constraint_rel_395, 3); +YAP_UserCPredicate("gecode_constraint_path_362", gecode_constraint_path_362, 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); +YAP_UserCPredicate("gecode_constraint_branch_22", gecode_constraint_branch_22, 4); +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_332", gecode_constraint_mult_332, 5); +YAP_UserCPredicate("gecode_constraint_circuit_87", gecode_constraint_circuit_87, 6); +YAP_UserCPredicate("gecode_constraint_circuit_84", gecode_constraint_circuit_84, 6); +YAP_UserCPredicate("gecode_constraint_circuit_81", gecode_constraint_circuit_81, 6); +YAP_UserCPredicate("gecode_constraint_clause_94", gecode_constraint_clause_94, 5); +YAP_UserCPredicate("gecode_constraint_clause_92", gecode_constraint_clause_92, 5); +YAP_UserCPredicate("gecode_constraint_precede_374", gecode_constraint_precede_374, 4); +YAP_UserCPredicate("gecode_constraint_precede_371", gecode_constraint_precede_371, 4); +YAP_UserCPredicate("gecode_constraint_precede_370", gecode_constraint_precede_370, 4); +YAP_UserCPredicate("gecode_constraint_channel_75", gecode_constraint_channel_75, 6); +YAP_UserCPredicate("gecode_constraint_cumulative_132", gecode_constraint_cumulative_132, 7); +YAP_UserCPredicate("gecode_constraint_cumulative_135", gecode_constraint_cumulative_135, 7); +YAP_UserCPredicate("gecode_constraint_cumulative_128", gecode_constraint_cumulative_128, 7); +YAP_UserCPredicate("gecode_constraint_cumulative_131", gecode_constraint_cumulative_131, 7); +YAP_UserCPredicate("gecode_constraint_cumulative_125", gecode_constraint_cumulative_125, 7); +YAP_UserCPredicate("gecode_constraint_cumulative_144", gecode_constraint_cumulative_144, 7); +YAP_UserCPredicate("gecode_constraint_cumulative_147", gecode_constraint_cumulative_147, 7); +YAP_UserCPredicate("gecode_constraint_cumulative_140", gecode_constraint_cumulative_140, 7); +YAP_UserCPredicate("gecode_constraint_cumulative_143", gecode_constraint_cumulative_143, 7); +YAP_UserCPredicate("gecode_constraint_cumulative_137", gecode_constraint_cumulative_137, 7); +YAP_UserCPredicate("gecode_constraint_distinct_167", gecode_constraint_distinct_167, 3); +YAP_UserCPredicate("gecode_constraint_distinct_164", gecode_constraint_distinct_164, 3); +YAP_UserCPredicate("gecode_constraint_member_319", gecode_constraint_member_319, 5); +YAP_UserCPredicate("gecode_constraint_member_315", gecode_constraint_member_315, 5); +YAP_UserCPredicate("gecode_constraint_mod_328", gecode_constraint_mod_328, 4); +YAP_UserCPredicate("gecode_constraint_sqr_450", gecode_constraint_sqr_450, 3); +YAP_UserCPredicate("gecode_constraint_sqr_449", gecode_constraint_sqr_449, 3); +YAP_UserCPredicate("gecode_constraint_sequence_442", gecode_constraint_sequence_442, 7); +YAP_UserCPredicate("gecode_constraint_sequence_440", gecode_constraint_sequence_440, 7); +YAP_UserCPredicate("gecode_constraint_path_360", gecode_constraint_path_360, 7); +YAP_UserCPredicate("gecode_constraint_path_357", gecode_constraint_path_357, 7); +YAP_UserCPredicate("gecode_constraint_path_354", gecode_constraint_path_354, 7); +YAP_UserCPredicate("gecode_constraint_divmod_172", gecode_constraint_divmod_172, 6); +YAP_UserCPredicate("gecode_constraint_sorted_447", gecode_constraint_sorted_447, 3); +YAP_UserCPredicate("gecode_constraint_extensional_258", gecode_constraint_extensional_258, 4); +YAP_UserCPredicate("gecode_constraint_extensional_261", gecode_constraint_extensional_261, 4); +YAP_UserCPredicate("gecode_constraint_extensional_253", gecode_constraint_extensional_253, 4); +YAP_UserCPredicate("gecode_constraint_extensional_256", gecode_constraint_extensional_256, 4); +YAP_UserCPredicate("gecode_constraint_circuit_90", gecode_constraint_circuit_90, 3); +YAP_UserCPredicate("gecode_constraint_circuit_89", gecode_constraint_circuit_89, 3); +YAP_UserCPredicate("gecode_constraint_argmin_57", gecode_constraint_argmin_57, 4); +YAP_UserCPredicate("gecode_constraint_channel_77", gecode_constraint_channel_77, 3); +YAP_UserCPredicate("gecode_constraint_channel_67", gecode_constraint_channel_67, 3); +YAP_UserCPredicate("gecode_constraint_channel_70", gecode_constraint_channel_70, 3); +YAP_UserCPredicate("gecode_constraint_channel_65", gecode_constraint_channel_65, 3); +YAP_UserCPredicate("gecode_constraint_channel_73", gecode_constraint_channel_73, 3); +YAP_UserCPredicate("gecode_constraint_channel_71", gecode_constraint_channel_71, 3); +YAP_UserCPredicate("gecode_constraint_channel_78", gecode_constraint_channel_78, 3); +YAP_UserCPredicate("gecode_constraint_channel_76", gecode_constraint_channel_76, 3); +YAP_UserCPredicate("gecode_constraint_count_98", gecode_constraint_count_98, 5); +YAP_UserCPredicate("gecode_constraint_count_100", gecode_constraint_count_100, 5); +YAP_UserCPredicate("gecode_constraint_count_116", gecode_constraint_count_116, 5); +YAP_UserCPredicate("gecode_constraint_count_118", gecode_constraint_count_118, 5); +YAP_UserCPredicate("gecode_constraint_count_108", gecode_constraint_count_108, 5); +YAP_UserCPredicate("gecode_constraint_count_110", gecode_constraint_count_110, 5); +YAP_UserCPredicate("gecode_constraint_count_107", gecode_constraint_count_107, 5); +YAP_UserCPredicate("gecode_constraint_count_103", gecode_constraint_count_103, 5); +YAP_UserCPredicate("gecode_constraint_count_113", gecode_constraint_count_113, 5); +YAP_UserCPredicate("gecode_constraint_count_120", gecode_constraint_count_120, 5); +YAP_UserCPredicate("gecode_constraint_count_122", gecode_constraint_count_122, 5); +YAP_UserCPredicate("gecode_constraint_cumulatives_162", gecode_constraint_cumulatives_162, 8); +YAP_UserCPredicate("gecode_constraint_cumulatives_160", gecode_constraint_cumulatives_160, 8); +YAP_UserCPredicate("gecode_constraint_cumulatives_158", gecode_constraint_cumulatives_158, 8); +YAP_UserCPredicate("gecode_constraint_cumulatives_156", gecode_constraint_cumulatives_156, 8); +YAP_UserCPredicate("gecode_constraint_cumulatives_154", gecode_constraint_cumulatives_154, 8); +YAP_UserCPredicate("gecode_constraint_cumulatives_152", gecode_constraint_cumulatives_152, 8); +YAP_UserCPredicate("gecode_constraint_cumulatives_150", gecode_constraint_cumulatives_150, 8); +YAP_UserCPredicate("gecode_constraint_cumulatives_148", gecode_constraint_cumulatives_148, 8); +YAP_UserCPredicate("gecode_constraint_binpacking_61", gecode_constraint_binpacking_61, 5); +YAP_UserCPredicate("gecode_constraint_extensional_257", gecode_constraint_extensional_257, 3); +YAP_UserCPredicate("gecode_constraint_extensional_260", gecode_constraint_extensional_260, 3); +YAP_UserCPredicate("gecode_constraint_extensional_252", gecode_constraint_extensional_252, 3); +YAP_UserCPredicate("gecode_constraint_extensional_255", gecode_constraint_extensional_255, 3); +YAP_UserCPredicate("gecode_constraint_linear_299", gecode_constraint_linear_299, 6); +YAP_UserCPredicate("gecode_constraint_linear_303", gecode_constraint_linear_303, 6); +YAP_UserCPredicate("gecode_constraint_linear_267", gecode_constraint_linear_267, 6); +YAP_UserCPredicate("gecode_constraint_linear_271", gecode_constraint_linear_271, 6); +YAP_UserCPredicate("gecode_constraint_linear_275", gecode_constraint_linear_275, 6); +YAP_UserCPredicate("gecode_constraint_linear_273", gecode_constraint_linear_273, 6); +YAP_UserCPredicate("gecode_constraint_linear_290", gecode_constraint_linear_290, 6); +YAP_UserCPredicate("gecode_constraint_linear_289", gecode_constraint_linear_289, 6); +YAP_UserCPredicate("gecode_constraint_linear_294", gecode_constraint_linear_294, 6); +YAP_UserCPredicate("gecode_constraint_linear_293", gecode_constraint_linear_293, 6); +YAP_UserCPredicate("gecode_constraint_linear_282", gecode_constraint_linear_282, 6); +YAP_UserCPredicate("gecode_constraint_linear_281", gecode_constraint_linear_281, 6); +YAP_UserCPredicate("gecode_constraint_linear_286", gecode_constraint_linear_286, 6); +YAP_UserCPredicate("gecode_constraint_linear_285", gecode_constraint_linear_285, 6); +YAP_UserCPredicate("gecode_constraint_nooverlap_339", gecode_constraint_nooverlap_339, 7); +YAP_UserCPredicate("gecode_constraint_nooverlap_334", gecode_constraint_nooverlap_334, 7); +YAP_UserCPredicate("gecode_constraint_div_170", gecode_constraint_div_170, 5); +YAP_UserCPredicate("gecode_constraint_sqr_451", gecode_constraint_sqr_451, 4); +YAP_UserCPredicate("gecode_constraint_path_361", gecode_constraint_path_361, 8); +YAP_UserCPredicate("gecode_constraint_path_358", gecode_constraint_path_358, 8); +YAP_UserCPredicate("gecode_constraint_path_355", gecode_constraint_path_355, 8); +YAP_UserCPredicate("gecode_constraint_unary_463", gecode_constraint_unary_463, 5); +YAP_UserCPredicate("gecode_constraint_unary_466", gecode_constraint_unary_466, 5); +YAP_UserCPredicate("gecode_constraint_unary_459", gecode_constraint_unary_459, 5); +YAP_UserCPredicate("gecode_constraint_unary_462", gecode_constraint_unary_462, 5); +YAP_UserCPredicate("gecode_constraint_unary_456", gecode_constraint_unary_456, 5); +YAP_UserCPredicate("gecode_constraint_sorted_445", gecode_constraint_sorted_445, 4); +YAP_UserCPredicate("gecode_constraint_sorted_448", gecode_constraint_sorted_448, 4); +YAP_UserCPredicate("gecode_constraint_element_229", gecode_constraint_element_229, 8); +YAP_UserCPredicate("gecode_constraint_element_223", gecode_constraint_element_223, 8); +YAP_UserCPredicate("gecode_constraint_element_241", gecode_constraint_element_241, 8); +YAP_UserCPredicate("gecode_constraint_element_239", gecode_constraint_element_239, 8); +YAP_UserCPredicate("gecode_constraint_assign_16", gecode_constraint_assign_16, 4); +YAP_UserCPredicate("gecode_constraint_assign_7", gecode_constraint_assign_7, 4); +YAP_UserCPredicate("gecode_constraint_assign_4", gecode_constraint_assign_4, 4); +YAP_UserCPredicate("gecode_constraint_assign_2", gecode_constraint_assign_2, 4); +YAP_UserCPredicate("gecode_constraint_assign_10", gecode_constraint_assign_10, 4); +YAP_UserCPredicate("gecode_constraint_assign_18", gecode_constraint_assign_18, 4); +YAP_UserCPredicate("gecode_constraint_assign_13", gecode_constraint_assign_13, 4); +YAP_UserCPredicate("gecode_constraint_assign_20", gecode_constraint_assign_20, 4); +YAP_UserCPredicate("gecode_constraint_element_227", gecode_constraint_element_227, 5); +YAP_UserCPredicate("gecode_constraint_element_231", gecode_constraint_element_231, 5); +YAP_UserCPredicate("gecode_constraint_element_221", gecode_constraint_element_221, 5); +YAP_UserCPredicate("gecode_constraint_element_219", gecode_constraint_element_219, 5); +YAP_UserCPredicate("gecode_constraint_element_250", gecode_constraint_element_250, 5); +YAP_UserCPredicate("gecode_constraint_element_248", gecode_constraint_element_248, 5); +YAP_UserCPredicate("gecode_constraint_element_246", gecode_constraint_element_246, 5); +YAP_UserCPredicate("gecode_constraint_element_244", gecode_constraint_element_244, 5); +YAP_UserCPredicate("gecode_constraint_element_237", gecode_constraint_element_237, 5); +YAP_UserCPredicate("gecode_constraint_element_243", gecode_constraint_element_243, 5); +YAP_UserCPredicate("gecode_constraint_element_235", gecode_constraint_element_235, 5); +YAP_UserCPredicate("gecode_constraint_sequence_444", gecode_constraint_sequence_444, 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); +YAP_UserCPredicate("gecode_constraint_branch_32", gecode_constraint_branch_32, 5); +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_85", gecode_constraint_circuit_85, 7); +YAP_UserCPredicate("gecode_constraint_pow_367", gecode_constraint_pow_367, 4); +YAP_UserCPredicate("gecode_constraint_pow_366", gecode_constraint_pow_366, 4); +YAP_UserCPredicate("gecode_constraint_precede_373", gecode_constraint_precede_373, 3); +YAP_UserCPredicate("gecode_constraint_precede_369", gecode_constraint_precede_369, 3); +YAP_UserCPredicate("gecode_constraint_argmax_55", gecode_constraint_argmax_55, 5); +YAP_UserCPredicate("gecode_constraint_cumulative_134", gecode_constraint_cumulative_134, 6); +YAP_UserCPredicate("gecode_constraint_cumulative_130", gecode_constraint_cumulative_130, 6); +YAP_UserCPredicate("gecode_constraint_cumulative_124", gecode_constraint_cumulative_124, 6); +YAP_UserCPredicate("gecode_constraint_cumulative_127", gecode_constraint_cumulative_127, 6); +YAP_UserCPredicate("gecode_constraint_cumulative_146", gecode_constraint_cumulative_146, 6); +YAP_UserCPredicate("gecode_constraint_cumulative_142", gecode_constraint_cumulative_142, 6); +YAP_UserCPredicate("gecode_constraint_cumulative_136", gecode_constraint_cumulative_136, 6); +YAP_UserCPredicate("gecode_constraint_cumulative_139", gecode_constraint_cumulative_139, 6); +YAP_UserCPredicate("gecode_constraint_distinct_165", gecode_constraint_distinct_165, 4); +YAP_UserCPredicate("gecode_constraint_min_320", gecode_constraint_min_320, 3); +YAP_UserCPredicate("gecode_constraint_min_321", gecode_constraint_min_321, 3); +YAP_UserCPredicate("gecode_constraint_min_326", gecode_constraint_min_326, 3); +YAP_UserCPredicate("gecode_constraint_sqrt_454", gecode_constraint_sqrt_454, 4); +YAP_UserCPredicate("gecode_constraint_sequence_441", gecode_constraint_sequence_441, 6); +YAP_UserCPredicate("gecode_constraint_sequence_439", gecode_constraint_sequence_439, 6); +YAP_UserCPredicate("gecode_constraint_unshare_470", gecode_constraint_unshare_470, 3); +YAP_UserCPredicate("gecode_constraint_unshare_468", gecode_constraint_unshare_468, 3); +YAP_UserCPredicate("gecode_constraint_path_365", gecode_constraint_path_365, 6); +YAP_UserCPredicate("gecode_constraint_path_356", gecode_constraint_path_356, 6); +YAP_UserCPredicate("gecode_constraint_divmod_171", gecode_constraint_divmod_171, 5); +YAP_UserCPredicate("gecode_constraint_branch_31", gecode_constraint_branch_31, 6); +YAP_UserCPredicate("gecode_constraint_branch_27", gecode_constraint_branch_27, 6); +YAP_UserCPredicate("gecode_constraint_branch_25", gecode_constraint_branch_25, 6); +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_338", gecode_constraint_nooverlap_338, 9); +YAP_UserCPredicate("gecode_constraint_argmin_58", gecode_constraint_argmin_58, 5); +YAP_UserCPredicate("gecode_constraint_cumulative_126", gecode_constraint_cumulative_126, 5); +YAP_UserCPredicate("gecode_constraint_cumulative_138", gecode_constraint_cumulative_138, 5); +YAP_UserCPredicate("gecode_constraint_member_316", gecode_constraint_member_316, 3); +YAP_UserCPredicate("gecode_constraint_member_312", gecode_constraint_member_312, 3); +YAP_UserCPredicate("gecode_constraint_count_117", gecode_constraint_count_117, 6); +YAP_UserCPredicate("gecode_constraint_count_119", gecode_constraint_count_119, 6); +YAP_UserCPredicate("gecode_constraint_count_121", gecode_constraint_count_121, 6); +YAP_UserCPredicate("gecode_constraint_count_123", gecode_constraint_count_123, 6); +YAP_UserCPredicate("gecode_constraint_count_109", gecode_constraint_count_109, 6); +YAP_UserCPredicate("gecode_constraint_count_111", gecode_constraint_count_111, 6); +YAP_UserCPredicate("gecode_constraint_count_99", gecode_constraint_count_99, 6); +YAP_UserCPredicate("gecode_constraint_count_101", gecode_constraint_count_101, 6); +YAP_UserCPredicate("gecode_constraint_pow_368", gecode_constraint_pow_368, 5); +YAP_UserCPredicate("gecode_constraint_notMin_342", gecode_constraint_notMin_342, 3); +YAP_UserCPredicate("gecode_constraint_cumulative_133", gecode_constraint_cumulative_133, 8); +YAP_UserCPredicate("gecode_constraint_cumulative_129", gecode_constraint_cumulative_129, 8); +YAP_UserCPredicate("gecode_constraint_cumulative_145", gecode_constraint_cumulative_145, 8); +YAP_UserCPredicate("gecode_constraint_cumulative_141", gecode_constraint_cumulative_141, 8); +YAP_UserCPredicate("gecode_constraint_branch_46", gecode_constraint_branch_46, 3); +YAP_UserCPredicate("gecode_constraint_branch_21", gecode_constraint_branch_21, 3); +YAP_UserCPredicate("gecode_constraint_branch_44", gecode_constraint_branch_44, 3); +YAP_UserCPredicate("gecode_constraint_branch_48", gecode_constraint_branch_48, 3); +YAP_UserCPredicate("gecode_constraint_dom_194", gecode_constraint_dom_194, 3); +YAP_UserCPredicate("gecode_constraint_dom_196", gecode_constraint_dom_196, 3); +YAP_UserCPredicate("gecode_constraint_dom_177", gecode_constraint_dom_177, 3); +YAP_UserCPredicate("gecode_constraint_dom_179", gecode_constraint_dom_179, 3); +YAP_UserCPredicate("gecode_constraint_dom_175", gecode_constraint_dom_175, 3); +YAP_UserCPredicate("gecode_constraint_dom_173", gecode_constraint_dom_173, 3); +YAP_UserCPredicate("gecode_constraint_dom_184", gecode_constraint_dom_184, 3); +YAP_UserCPredicate("gecode_constraint_dom_182", gecode_constraint_dom_182, 3); +YAP_UserCPredicate("gecode_constraint_dom_180", gecode_constraint_dom_180, 3); +YAP_UserCPredicate("gecode_constraint_dom_201", gecode_constraint_dom_201, 3); +YAP_UserCPredicate("gecode_constraint_dom_209", gecode_constraint_dom_209, 3); +YAP_UserCPredicate("gecode_constraint_dom_197", gecode_constraint_dom_197, 3); +YAP_UserCPredicate("gecode_constraint_dom_188", gecode_constraint_dom_188, 3); +YAP_UserCPredicate("gecode_constraint_dom_217", gecode_constraint_dom_217, 3); +YAP_UserCPredicate("gecode_constraint_linear_298", gecode_constraint_linear_298, 5); +YAP_UserCPredicate("gecode_constraint_linear_297", gecode_constraint_linear_297, 5); +YAP_UserCPredicate("gecode_constraint_linear_302", gecode_constraint_linear_302, 5); +YAP_UserCPredicate("gecode_constraint_linear_301", gecode_constraint_linear_301, 5); +YAP_UserCPredicate("gecode_constraint_linear_279", gecode_constraint_linear_279, 5); +YAP_UserCPredicate("gecode_constraint_linear_277", gecode_constraint_linear_277, 5); +YAP_UserCPredicate("gecode_constraint_linear_266", gecode_constraint_linear_266, 5); +YAP_UserCPredicate("gecode_constraint_linear_265", gecode_constraint_linear_265, 5); +YAP_UserCPredicate("gecode_constraint_linear_270", gecode_constraint_linear_270, 5); +YAP_UserCPredicate("gecode_constraint_linear_269", gecode_constraint_linear_269, 5); +YAP_UserCPredicate("gecode_constraint_linear_274", gecode_constraint_linear_274, 5); +YAP_UserCPredicate("gecode_constraint_linear_272", gecode_constraint_linear_272, 5); +YAP_UserCPredicate("gecode_constraint_linear_288", gecode_constraint_linear_288, 5); +YAP_UserCPredicate("gecode_constraint_linear_292", gecode_constraint_linear_292, 5); +YAP_UserCPredicate("gecode_constraint_linear_280", gecode_constraint_linear_280, 5); +YAP_UserCPredicate("gecode_constraint_linear_284", gecode_constraint_linear_284, 5); +YAP_UserCPredicate("gecode_constraint_nooverlap_333", gecode_constraint_nooverlap_333, 6); +YAP_UserCPredicate("gecode_constraint_nooverlap_336", gecode_constraint_nooverlap_336, 6); +YAP_UserCPredicate("gecode_constraint_element_251", gecode_constraint_element_251, 6); +YAP_UserCPredicate("gecode_constraint_element_249", gecode_constraint_element_249, 6); +YAP_UserCPredicate("gecode_constraint_element_247", gecode_constraint_element_247, 6); +YAP_UserCPredicate("gecode_constraint_element_245", gecode_constraint_element_245, 6); +YAP_UserCPredicate("gecode_constraint_rel_411", gecode_constraint_rel_411, 4); +YAP_UserCPredicate("gecode_constraint_rel_413", gecode_constraint_rel_413, 4); +YAP_UserCPredicate("gecode_constraint_rel_429", gecode_constraint_rel_429, 4); +YAP_UserCPredicate("gecode_constraint_rel_427", gecode_constraint_rel_427, 4); +YAP_UserCPredicate("gecode_constraint_rel_399", gecode_constraint_rel_399, 4); +YAP_UserCPredicate("gecode_constraint_rel_400", gecode_constraint_rel_400, 4); +YAP_UserCPredicate("gecode_constraint_rel_397", gecode_constraint_rel_397, 4); +YAP_UserCPredicate("gecode_constraint_rel_393", gecode_constraint_rel_393, 4); +YAP_UserCPredicate("gecode_constraint_rel_391", gecode_constraint_rel_391, 4); +YAP_UserCPredicate("gecode_constraint_rel_396", gecode_constraint_rel_396, 4); +YAP_UserCPredicate("gecode_constraint_rel_387", gecode_constraint_rel_387, 4); +YAP_UserCPredicate("gecode_constraint_rel_383", gecode_constraint_rel_383, 4); +YAP_UserCPredicate("gecode_constraint_rel_407", gecode_constraint_rel_407, 4); +YAP_UserCPredicate("gecode_constraint_rel_409", gecode_constraint_rel_409, 4); +YAP_UserCPredicate("gecode_constraint_rel_403", gecode_constraint_rel_403, 4); +YAP_UserCPredicate("gecode_constraint_rel_406", gecode_constraint_rel_406, 4); +YAP_UserCPredicate("gecode_constraint_rel_415", gecode_constraint_rel_415, 4); +YAP_UserCPredicate("gecode_constraint_rel_419", gecode_constraint_rel_419, 4); +YAP_UserCPredicate("gecode_constraint_rel_423", gecode_constraint_rel_423, 4); +YAP_UserCPredicate("gecode_constraint_rel_424", gecode_constraint_rel_424, 4); +YAP_UserCPredicate("gecode_constraint_rel_430", gecode_constraint_rel_430, 4); +YAP_UserCPredicate("gecode_constraint_rel_435", gecode_constraint_rel_435, 4); +YAP_UserCPredicate("gecode_constraint_rel_437", gecode_constraint_rel_437, 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_min_325", gecode_constraint_min_325, 5); +YAP_UserCPredicate("gecode_constraint_count_114", gecode_constraint_count_114, 3); +YAP_UserCPredicate("gecode_constraint_count_104", gecode_constraint_count_104, 3); +YAP_UserCPredicate("gecode_constraint_argmax_54", gecode_constraint_argmax_54, 4); +YAP_UserCPredicate("gecode_constraint_ite_263", gecode_constraint_ite_263, 6); diff --git a/packages/gecode/dev/code-generator.py b/packages/gecode/dev/code-generator.py index 02bbf9461..b840130c5 100644 --- a/packages/gecode/dev/code-generator.py +++ b/packages/gecode/dev/code-generator.py @@ -666,15 +666,18 @@ def gecode_version(): @@GECODE_VERSION""") f.close() cxx.preprocess(file_hh,output_file=file_txt) - f = open(file_txt) - version = "" - for line in f: - if line.startswith("@@"): - version = line[3:-2] - break - f.close() - os.remove(file_hh) - os.remove(file_txt) + if True: + f = open(file_txt) + version = "" + for line in f: + if line.startswith("@@"): + version = line[3:-2] + break + f.close() + os.remove(file_hh) + os.remove(file_txt) + else: + version = "4.4.0" GECODE_VERSION = version return version diff --git a/packages/gecode/dev/extractor/Doxyfile b/packages/gecode/dev/extractor/Doxyfile index c11bf9b38..2b3c64d99 100644 --- a/packages/gecode/dev/extractor/Doxyfile +++ b/packages/gecode/dev/extractor/Doxyfile @@ -610,7 +610,7 @@ WARN_LOGFILE = # directories like "/usr/src/myproject". Separate the files or directories # with spaces. -INPUT = /usr/local/include/gecode +INPUT = /usr/include/gecode # This tag can be used to specify the character encoding of the source files # that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is diff --git a/packages/gecode/dev/extractor/xml/namespaceGecode.xml b/packages/gecode/dev/extractor/xml/namespaceGecode.xml new file mode 100644 index 000000000..437c19448 --- /dev/null +++ b/packages/gecode/dev/extractor/xml/namespaceGecode.xml @@ -0,0 +1,23233 @@ + + + + Gecode + Gecode::Activity + Gecode::ActivityWrongArity + Gecode::Actor + Gecode::ActorLink + Gecode::Advisor + Gecode::Advisors + Gecode::AFC + Gecode::AFCWrongArity + Gecode::AllVarConf + Gecode::Archive + Gecode::ArgArray + Gecode::ArgArrayBase + Gecode::ArrayTraits + Gecode::ArrayTraits< ArgArray< IntSet > > + Gecode::ArrayTraits< ArgArray< SymmetryHandle > > + Gecode::ArrayTraits< ArgArray< VarImpBase * > > + Gecode::ArrayTraits< BoolVarArgs > + Gecode::ArrayTraits< BoolVarArray > + Gecode::ArrayTraits< FloatValArgs > + Gecode::ArrayTraits< FloatVarArgs > + Gecode::ArrayTraits< FloatVarArray > + Gecode::ArrayTraits< IntArgs > + Gecode::ArrayTraits< IntVarArgs > + Gecode::ArrayTraits< IntVarArray > + Gecode::ArrayTraits< LiteralArgs > + Gecode::ArrayTraits< PrimArgArray< FloatVal > > + Gecode::ArrayTraits< PrimArgArray< int > > + Gecode::ArrayTraits< PrimArgArray< TaskType > > + Gecode::ArrayTraits< SetVarArgs > + Gecode::ArrayTraits< SetVarArray > + Gecode::ArrayTraits< VarArgArray< BoolVar > > + Gecode::ArrayTraits< VarArgArray< FloatVar > > + Gecode::ArrayTraits< VarArgArray< IntVar > > + Gecode::ArrayTraits< VarArgArray< SetVar > > + Gecode::ArrayTraits< VarArray< BoolVar > > + Gecode::ArrayTraits< VarArray< FloatVar > > + Gecode::ArrayTraits< VarArray< IntVar > > + Gecode::ArrayTraits< VarArray< SetVar > > + Gecode::BAB + Gecode::BaseOptions + Gecode::BinaryPropagator + Gecode::BoolExpr + Gecode::BoolVar + Gecode::BoolVarArgs + Gecode::BoolVarArray + Gecode::Brancher + Gecode::BrancherHandle + Gecode::BranchTraits + Gecode::BranchTraits< BoolVar > + Gecode::BranchTraits< FloatVar > + Gecode::BranchTraits< IntVar > + Gecode::BranchTraits< SetVar > + Gecode::Choice + Gecode::ChooseMax + Gecode::ChooseMin + Gecode::CloneStatistics + Gecode::CommitStatistics + Gecode::ConstView + Gecode::Council + Gecode::CRI + Gecode::Delta + Gecode::DerivedView + Gecode::DFA + Gecode::DFS + Gecode::DynamicCastFailed + Gecode::Exception + Gecode::FloatActivity + Gecode::FloatAFC + Gecode::FloatAssign + Gecode::FloatNumBranch + Gecode::FloatVal + Gecode::FloatValArgs + Gecode::FloatValBranch + Gecode::FloatVar + Gecode::FloatVarArgs + Gecode::FloatVarArray + Gecode::FloatVarBranch + Gecode::FreeList + Gecode::GlobalAFC + Gecode::Heap + Gecode::HeapChunk + Gecode::Home + Gecode::IllegalDecay + Gecode::InstanceOptions + Gecode::IntActivity + Gecode::IntAFC + Gecode::IntArgs + Gecode::IntAssign + Gecode::IntMaximizeSpace + Gecode::IntMinimizeSpace + Gecode::IntSet + Gecode::IntSetInit + Gecode::IntSetInit< IntArgs > + Gecode::IntSetInit< IntSet > + Gecode::IntSetRanges + Gecode::IntSetValues + Gecode::IntValBranch + Gecode::IntVar + Gecode::IntVarArgs + Gecode::IntVarArray + Gecode::IntVarBranch + Gecode::IntVarRanges + Gecode::IntVarValues + Gecode::LinIntExpr + Gecode::LinIntRel + Gecode::LocalHandle + Gecode::LocalObject + Gecode::Matrix + Gecode::MemoryChunk + Gecode::MemoryExhausted + Gecode::MemoryManager + Gecode::MeritActivity + Gecode::MeritAFC + Gecode::MeritBase + Gecode::MeritDegree + Gecode::MeritFunction + Gecode::MixBinaryPropagator + Gecode::MixNaryOnePropagator + Gecode::MixTernaryPropagator + Gecode::NaryOnePropagator + Gecode::NaryPropagator + Gecode::NGL + Gecode::NoGoods + Gecode::NoIdxVarImpConf + Gecode::NonLinIntExpr + Gecode::OperatingSystemError + Gecode::Options + Gecode::Pos + Gecode::PosChoice + Gecode::PosValChoice + Gecode::PrimArgArray + Gecode::Propagator + Gecode::PropCost + Gecode::RangeList + Gecode::RBS + Gecode::REG + Gecode::Region + Gecode::region_allocator + Gecode::region_allocator< void > + Gecode::Reify + Gecode::Rnd + Gecode::SetActivity + Gecode::SetAFC + Gecode::SetAssign + Gecode::SetValBranch + Gecode::SetVar + Gecode::SetVarArgs + Gecode::SetVarArray + Gecode::SetVarBranch + Gecode::SetVarGlbRanges + Gecode::SetVarGlbValues + Gecode::SetVarLubRanges + Gecode::SetVarLubValues + Gecode::SetVarUnknownRanges + Gecode::SetVarUnknownValues + Gecode::SharedArray + Gecode::SharedHandle + Gecode::SharedMemory + Gecode::SizeOptions + Gecode::Slice + Gecode::Space + Gecode::space_allocator + Gecode::space_allocator< void > + Gecode::SpaceFailed + Gecode::SpaceIllegalAlternative + Gecode::SpaceNoBrancher + Gecode::SpaceNotCloned + Gecode::SpaceNotStable + Gecode::StatusStatistics + Gecode::Symmetries + Gecode::SymmetryHandle + Gecode::TernaryPropagator + Gecode::TieBreak + Gecode::TooManyBranchers + Gecode::TupleSet + Gecode::UnaryPropagator + Gecode::UninitializedActivity + Gecode::UninitializedAFC + Gecode::UninitializedRnd + Gecode::ValBranch + Gecode::ValCommit + Gecode::ValCommitFunction + Gecode::ValSel + Gecode::ValSelCommit + Gecode::ValSelCommitBase + Gecode::ValSelFunction + Gecode::Var + Gecode::VarArgArray + Gecode::VarArray + Gecode::VarBranch + Gecode::VarImp + Gecode::VarImpBase + Gecode::VarImpDisposer + Gecode::VarImpDisposerBase + Gecode::VarImpVar + Gecode::VarImpView + Gecode::ViewAdvisor + Gecode::ViewArray + Gecode::ViewArray< Int::Linear::NoView > + Gecode::ViewBrancher + Gecode::ViewSel + Gecode::ViewSelChoose + Gecode::ViewSelChooseTbl + Gecode::ViewSelMax + Gecode::ViewSelMaxTbl + Gecode::ViewSelMin + Gecode::ViewSelMinTbl + Gecode::ViewSelNone + Gecode::ViewSelRnd + Gecode::ViewValBrancher + Gecode::ViewValNGL + Gecode::Driver + Gecode::FlatZinc + Gecode::Float + Gecode::Gist + Gecode::Int + Gecode::Iter + Gecode::Kernel + Gecode::MemoryConfig + Gecode::MiniModel + Gecode::Search + Gecode::Set + Gecode::Support + + + ScriptMode + + SM_SOLUTION + +Print solution and some statistics. + + + + + SM_TIME + +Measure average runtime. + + + + + SM_STAT + +Print statistics for script. + + + + + SM_GIST + +Run script in Gist. + + + + +Different modes for executing scripts. + + + + + + + + RestartMode + + RM_NONE + +No restarts. + + + + + RM_CONSTANT + +Restart with constant sequence. + + + + + RM_LINEAR + +Restart with linear sequence. + + + + + RM_LUBY + +Restart with Luby sequence. + + + + + RM_GEOMETRIC + +Restart with geometric sequence. + + + + +Different modes for restart-based search. + + + + + + + + FloatRelType + + FRT_EQ + +Equality ( $=$) + + + + + FRT_NQ + +Disequality ( $\neq$) + + + + + FRT_LQ + +Less or equal ( $\leq$) + + + + + FRT_LE + +Less ( $<$) + + + + + FRT_GQ + +Greater or equal ( $\geq$) + + + + + FRT_GR + +Greater ( $>$) + + + + +Relation types for floats. + + + + + + + + ReifyMode + + RM_EQV + +Equivalence for reification (default) + +For a constraint $c$ and a Boolean control variable $b$ defines that $b=1\Leftrightarrow c$ is propagated. + + + RM_IMP + +Implication for reification. + +For a constraint $c$ and a Boolean control variable $b$ defines that $b=1\Leftarrow c$ is propagated. + + + RM_PMI + +Inverse implication for reification. + +For a constraint $c$ and a Boolean control variable $b$ defines that $b=1\Rightarrow c$ is propagated. + + +Mode for reification. + + + + + + + + IntRelType + + IRT_EQ + +Equality ( $=$) + + + + + IRT_NQ + +Disequality ( $\neq$) + + + + + IRT_LQ + +Less or equal ( $\leq$) + + + + + IRT_LE + +Less ( $<$) + + + + + IRT_GQ + +Greater or equal ( $\geq$) + + + + + IRT_GR + +Greater ( $>$) + + + + +Relation types for integers. + + + + + + + + BoolOpType + + BOT_AND + +Conjunction. + + + + + BOT_OR + +Disjunction. + + + + + BOT_IMP + +Implication. + + + + + BOT_EQV + +Equivalence. + + + + + BOT_XOR + +Exclusive or. + + + + +Operation types for Booleans. + + + + + + + + IntConLevel + + ICL_VAL + +Value propagation or consistency (naive) + + + + + ICL_BND + +Bounds propagation or consistency. + + + + + ICL_DOM + +Domain propagation or consistency. + + + + + ICL_DEF + +The default consistency for a constraint. + + + + +Consistency levels for integer propagators. + +The descriptions are meant to be suggestions. It is not required that a propagator achieves full domain consistency or full bounds consistency. It is more like: which level of consistency comes closest.If in the description of a constraint below no consistency level is mentioned, the propagator for the constraint implements domain consistency. + + + + + + TaskType + + TT_FIXP + + + + + + + TT_FIXS + + + + + + + TT_FIXE + + + + + + +Type of task for scheduling constraints. + + + + + + + + ExtensionalPropKind + + EPK_DEF + +Make a default decision. + + + + + EPK_SPEED + +Prefer speed over memory consumption. + + + + + EPK_MEMORY + +Prefer little memory over speed. + + + + +Extensional propagation kind. + +Signals that a particular kind is used in propagation for the implementation of a extensional constraint. + + + + + + ExecStatus + + __ES_SUBSUMED + = -2 + +Internal: propagator is subsumed, do not use. + + + + + ES_FAILED + = -1 + +Execution has resulted in failure. + + + + + ES_NOFIX + = 0 + +Propagation has not computed fixpoint. + + + + + ES_OK + = 0 + +Execution is okay. + + + + + ES_FIX + = 1 + +Propagation has computed fixpoint. + + + + + ES_NOFIX_FORCE + = 2 + +Advisor forces rescheduling of propagator. + + + + + __ES_PARTIAL + = 2 + +Internal: propagator has computed partial fixpoint, do not use. + + + + + + + + + + + + + ActorProperty + + AP_DISPOSE + = (1 << 0) + +Actor must always be disposed. + +Normally, a propagator will not be disposed if its home space is deleted. However, if an actor uses external resources, this property can be used to make sure that the actor will always be disposed. + + + AP_WEAKLY + = (1 << 1) + + + +Propagator is only weakly monotonic, that is, the propagator is only monotonic on assignments. + + +Actor properties. + + + + + + + + SpaceStatus + + SS_FAILED + +Space is failed + + + + + SS_SOLVED + +Space is solved (no brancher left) + + + + + SS_BRANCH + +Space must be branched (at least one brancher left) + + + + +Space status + + + + + + + + SetRelType + + SRT_EQ + +Equality ( $=$) + + + + + SRT_NQ + +Disequality ( $\neq$) + + + + + SRT_SUB + +Subset ( $\subseteq$) + + + + + SRT_SUP + +Superset ( $\supseteq$) + + + + + SRT_DISJ + +Disjoint ( $\parallel$) + + + + + SRT_CMPL + +Complement. + + + + + SRT_LQ + +Less or equal ( $\leq$) + + + + + SRT_LE + +Less ( $<$) + + + + + SRT_GQ + +Greater or equal ( $\geq$) + + + + + SRT_GR + +Greater ( $>$) + + + + +Common relation types for sets. + +The total order on sets is defined as the lexicographic order on their characteristic functions, e.g., $x\leq y$ means that either $x$ is empty or the minimal element of the symmetric difference $x\ominus y$ is in $y$. + + + + + + SetOpType + + SOT_UNION + +Union. + + + + + SOT_DUNION + +Disjoint union. + + + + + SOT_INTER + +Intersection + + + + + SOT_MINUS + +Difference. + + + + +Common operations for sets. + + + + + + + + + + Driver::ScriptBase< Driver::IgnoreStepOption< Space > > + typedef Driver::ScriptBase<Driver::IgnoreStepOption<Space> > Gecode::Script + + Script + +Base-class for scripts. + + + + + + + + Driver::ScriptBase< Driver::IgnoreStepOption< MinimizeSpace > > + typedef Driver::ScriptBase<Driver::IgnoreStepOption<MinimizeSpace> > Gecode::MinimizeScript + + MinimizeScript + +Base-class for scripts for finding solution of lowest integer cost. + + + + + + + + Driver::ScriptBase< Driver::IgnoreStepOption< MaximizeSpace > > + typedef Driver::ScriptBase<Driver::IgnoreStepOption<MaximizeSpace> > Gecode::MaximizeScript + + MaximizeScript + +Base-class for scripts for finding solution of highest integer cost. + + + + + + + + Driver::ScriptBase< Driver::IgnoreStepOption< IntMinimizeSpace > > + typedef Driver::ScriptBase<Driver::IgnoreStepOption<IntMinimizeSpace> > Gecode::IntMinimizeScript + + IntMinimizeScript + +Base-class for scripts for finding solution of lowest integer cost. + + + + + + + + Driver::ScriptBase< Driver::IgnoreStepOption< IntMaximizeSpace > > + typedef Driver::ScriptBase<Driver::IgnoreStepOption<IntMaximizeSpace> > Gecode::IntMaximizeScript + + IntMaximizeScript + +Base-class for scripts for finding solution of highest integer cost. + + + + + + + + double + typedef double Gecode::FloatNum + + FloatNum + +Floating point number base type. + +This type defines the interval bounds used for representing floating point values. + + + + + + bool(* + typedef bool(* Gecode::FloatBranchFilter) (const Space &home, FloatVar x, int i) + )(const Space &home, FloatVar x, int i) + FloatBranchFilter + +Branch filter function type for float variables. + +The variable x is considered for selection and i refers to the variable's position in the original array passed to the brancher. + + + + + + double(* + typedef double(* Gecode::FloatBranchMerit) (const Space &home, FloatVar x, int i) + )(const Space &home, FloatVar x, int i) + FloatBranchMerit + +Branch merit function type for float variables. + +The function must return a merit value for the variable x. The value i refers to the variable's position in the original array passed to the brancher. + + + + + + FloatNumBranch(* + typedef FloatNumBranch(* Gecode::FloatBranchVal) (const Space &home, FloatVar x, int i) + )(const Space &home, FloatVar x, int i) + FloatBranchVal + +Branch value function type for float variables. + +Returns a value for the variable x that is to be used in the corresponding branch commit function. The integer i refers to the variable's position in the original array passed to the brancher. + + + + + + void(* + typedef void(* Gecode::FloatBranchCommit) (Space &home, unsigned int a, FloatVar x, int i, FloatNumBranch nl) + )(Space &home, unsigned int a, FloatVar x, int i, FloatNumBranch nl) + FloatBranchCommit + +Branch commit function type for float variables. + +The function must post a constraint on the variable x which corresponds to the alternative a. The integer i refers to the variable's position in the original array passed to the brancher. The value nl is the value description computed by the corresponding branch value function. + + + + + + void(* + typedef void(* Gecode::FloatVarValPrint) (const Space &home, const BrancherHandle &bh, unsigned int a, FloatVar x, int i, const FloatNumBranch &n, std::ostream &o) + )(const Space &home, const BrancherHandle &bh, unsigned int a, FloatVar x, int i, const FloatNumBranch &n, std::ostream &o) + FloatVarValPrint + +Function type for explaining branching alternatives for set variables. + + + + + + + + ArgArray< Int::LDSB::Literal > + typedef ArgArray<Int::LDSB::Literal> Gecode::LiteralArgs + + LiteralArgs + +An array of literals. + + + + + + + + ArgArray< IntSet > + typedef ArgArray<IntSet> Gecode::IntSetArgs + + IntSetArgs + +Passing set arguments. + + + + + + + + PrimArgArray< TaskType > + typedef PrimArgArray<TaskType> Gecode::TaskTypeArgs + + TaskTypeArgs + +Argument arrays for passing task type arguments. + + + + + + + + SharedArray< int > + typedef SharedArray<int> Gecode::IntSharedArray + + IntSharedArray + +Arrays of integers that can be shared among several element constraints. + + + + + + + + bool(* + typedef bool(* Gecode::IntBranchFilter) (const Space &home, IntVar x, int i) + )(const Space &home, IntVar x, int i) + IntBranchFilter + +Branch filter function type for integer variables. + +The variable x is considered for selection and i refers to the variable's position in the original array passed to the brancher. + + + + + + bool(* + typedef bool(* Gecode::BoolBranchFilter) (const Space &home, BoolVar x, int i) + )(const Space &home, BoolVar x, int i) + BoolBranchFilter + +Branch filter function type for Boolean variables. + +The variable x is considered for selection and i refers to the variable's position in the original array passed to the brancher. + + + + + + double(* + typedef double(* Gecode::IntBranchMerit) (const Space &home, IntVar x, int i) + )(const Space &home, IntVar x, int i) + IntBranchMerit + +Branch merit function type for integer variables. + +The function must return a merit value for the variable x. The integer i refers to the variable's position in the original array passed to the brancher. + + + + + + double(* + typedef double(* Gecode::BoolBranchMerit) (const Space &home, BoolVar x, int i) + )(const Space &home, BoolVar x, int i) + BoolBranchMerit + +Branch merit function type for Boolean variables. + +The function must return a merit value for the variable x. The integer i refers to the variable's position in the original array passed to the brancher. + + + + + + int(* + typedef int(* Gecode::IntBranchVal) (const Space &home, IntVar x, int i) + )(const Space &home, IntVar x, int i) + IntBranchVal + +Branch value function type for integer variables. + +Returns a value for the variable x that is to be used in the corresponding branch commit function. The integer i refers to the variable's position in the original array passed to the brancher. + + + + + + int(* + typedef int(* Gecode::BoolBranchVal) (const Space &home, BoolVar x, int i) + )(const Space &home, BoolVar x, int i) + BoolBranchVal + +Branch value function type for Boolean variables. + +Returns a value for the variable x that is to be used in the corresponding branch commit function. The integer i refers to the variable's position in the original array passed to the brancher. + + + + + + void(* + typedef void(* Gecode::IntBranchCommit) (Space &home, unsigned int a, IntVar x, int i, int n) + )(Space &home, unsigned int a, IntVar x, int i, int n) + IntBranchCommit + +Branch commit function type for integer variables. + +The function must post a constraint on the variable x which corresponds to the alternative a. The integer i refers to the variable's position in the original array passed to the brancher. The value n is the value computed by the corresponding branch value function. + + + + + + void(* + typedef void(* Gecode::BoolBranchCommit) (Space &home, unsigned int a, BoolVar x, int i, int n) + )(Space &home, unsigned int a, BoolVar x, int i, int n) + BoolBranchCommit + +Branch commit function type for Boolean variables. + +The function must post a constraint on the variable x which corresponds to the alternative a. The integer i refers to the variable's position in the original array passed to the brancher. The value n is the value computed by the corresponding branch value function. + + + + + + void(* + typedef void(* Gecode::IntVarValPrint) (const Space &home, const BrancherHandle &bh, unsigned int a, IntVar x, int i, const int &n, std::ostream &o) + )(const Space &home, const BrancherHandle &bh, unsigned int a, IntVar x, int i, const int &n, std::ostream &o) + IntVarValPrint + +Function type for printing branching alternatives for integer variables. + + + + + + + + void(* + typedef void(* Gecode::BoolVarValPrint) (const Space &home, const BrancherHandle &bh, unsigned int a, BoolVar x, int i, const int &n, std::ostream &o) + )(const Space &home, const BrancherHandle &bh, unsigned int a, BoolVar x, int i, const int &n, std::ostream &o) + BoolVarValPrint + +Function type for printing branching alternatives for Boolean variables. + + + + + + + + double(* + typedef double(* Gecode::BranchTbl) (const Space &home, double w, double b) + )(const Space &home, double w, double b) + BranchTbl + +Tie-break limit function. + +Here the value w is the worst and is the best merit value found. The function must return the merit value that is considered the limit for breaking ties. + + + + + + int + typedef int Gecode::ModEvent + + ModEvent + +Type for modification events. + + + + + + + + int + typedef int Gecode::PropCond + + PropCond + +Type for propagation conditions. + + + + + + + + int + typedef int Gecode::ModEventDelta + + ModEventDelta + +Modification event deltas. + +Modification event deltas are used by propagators. A propagator stores a modification event for each variable type. They can be accessed through a variable or a view from a given propagator. They can be constructed from a given modevent by a variable or view. + + + + + + IntMinimizeSpace + typedef IntMinimizeSpace Gecode::MinimizeSpace + + MinimizeSpace + +Class for minimizing integer cost. + +DeprecatedUse IntMinimizeSpace instead. + + + + + + IntMaximizeSpace + typedef IntMaximizeSpace Gecode::MaximizeSpace + + MaximizeSpace + +Class for maximizing integer cost. + +DeprecatedUse IntMaximizeSpace instead. + + + + + + bool(* + typedef bool(* Gecode::SetBranchFilter) (const Space &home, SetVar x, int i) + )(const Space &home, SetVar x, int i) + SetBranchFilter + +Branch filter function type for set variables. + +The variable x is considered for selection and i refers to the variable's position in the original array passed to the brancher. + + + + + + double(* + typedef double(* Gecode::SetBranchMerit) (const Space &home, SetVar x, int i) + )(const Space &home, SetVar x, int i) + SetBranchMerit + +Branch merit function type for set variables. + +The function must return a merit value for the variable x. The value i refers to the variable's position in the original array passed to the brancher. + + + + + + int(* + typedef int(* Gecode::SetBranchVal) (const Space &home, SetVar x, int i) + )(const Space &home, SetVar x, int i) + SetBranchVal + +Branch value function type for set variables. + +Returns a value for the variable x that is to be used in the corresponding branch commit function. The integer i refers to the variable's position in the original array passed to the brancher. + + + + + + void(* + typedef void(* Gecode::SetBranchCommit) (Space &home, unsigned int a, SetVar x, int i, int n) + )(Space &home, unsigned int a, SetVar x, int i, int n) + SetBranchCommit + +Branch commit function type for set variables. + +The function must post a constraint on the variable x which corresponds to the alternative a. The integer i refers to the variable's position in the original array passed to the brancher. The value n is the value computed by the corresponding branch value function. + + + + + + void(* + typedef void(* Gecode::SetVarValPrint) (const Space &home, const BrancherHandle &bh, unsigned int a, SetVar x, int i, const int &n, std::ostream &o) + )(const Space &home, const BrancherHandle &bh, unsigned int a, SetVar x, int i, const int &n, std::ostream &o) + SetVarValPrint + +Function type for printing branching alternatives for set variables. + + + + + + + + void(* + typedef void(* Gecode::VoidFunction) (void) + )(void) + VoidFunction + +Base type for any function pointer. + + + + + + + + + + const ModEvent + const ModEvent Gecode::ME_GEN_FAILED + + ME_GEN_FAILED + = -1 + +Generic modification event: failed variable. + + + + + + + + const ModEvent + const ModEvent Gecode::ME_GEN_NONE + + ME_GEN_NONE + = 0 + +Generic modification event: no modification. + + + + + + + + const ModEvent + const ModEvent Gecode::ME_GEN_ASSIGNED + + ME_GEN_ASSIGNED + = 1 + +Generic modification event: variable is assigned a value. + + + + + + + + const PropCond + const PropCond Gecode::PC_GEN_NONE + + PC_GEN_NONE + = -1 + +Propagation condition to be ignored (convenience) + + + + + + + + const PropCond + const PropCond Gecode::PC_GEN_ASSIGNED + + PC_GEN_ASSIGNED + = 0 + +Propagation condition for an assigned variable. + + + + + + + + GECODE_SUPPORT_EXPORT Heap + GECODE_SUPPORT_EXPORT Heap Gecode::heap + + heap + +The single global heap. + + + + + + + + + + FloatAssign + FloatAssign Gecode::FLOAT_ASSIGN_MIN + (void) + FLOAT_ASSIGN_MIN + + void + + +Select median value of the lower part. + + + + + + + + FloatAssign + FloatAssign Gecode::FLOAT_ASSIGN_MAX + (void) + FLOAT_ASSIGN_MAX + + void + + +Select median value of the upper part. + + + + + + + + FloatAssign + FloatAssign Gecode::FLOAT_ASSIGN_RND + (Rnd r) + FLOAT_ASSIGN_RND + + Rnd + r + + +Select median value of a randomly chosen part. + + + + + + + + FloatAssign + FloatAssign Gecode::FLOAT_ASSIGN + (FloatBranchVal v, FloatBranchCommit c) + FLOAT_ASSIGN + + FloatBranchVal + v + + + FloatBranchCommit + c + NULL + + + + +Select value as defined by the value function v and commit function c The default commit function posts the constraint that the float variable x must be less or equal than the value n. + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator<< + (Archive &e, FloatNumBranch nl) + operator<< + + Archive & + e + + + FloatNumBranch + nl + + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator>> + (Archive &e, FloatNumBranch &nl) + operator>> + + Archive & + e + + + FloatNumBranch & + nl + + + + + + + + + + + FloatValBranch + FloatValBranch Gecode::FLOAT_VAL_SPLIT_MIN + (void) + FLOAT_VAL_SPLIT_MIN + + void + + +Select values not greater than mean of smallest and largest value. + + + + + + + + FloatValBranch + FloatValBranch Gecode::FLOAT_VAL_SPLIT_MAX + (void) + FLOAT_VAL_SPLIT_MAX + + void + + +Select values greater than mean of smallest and largest value. + + + + + + + + FloatValBranch + FloatValBranch Gecode::FLOAT_VAL_SPLIT_RND + (Rnd r) + FLOAT_VAL_SPLIT_RND + + Rnd + r + + +Select values randomly which are not greater or not smaller than mean of largest and smallest value. + + + + + + + + FloatValBranch + FloatValBranch Gecode::FLOAT_VAL + (FloatBranchVal v, FloatBranchCommit c) + FLOAT_VAL + + FloatBranchVal + v + + + FloatBranchCommit + c + NULL + + + + +Select value as defined by the value function v and commit function c The default commit function posts the constraint that the float variable x must be less or equal than the value n for the first alternative and that x must be greater or equal than n otherwise. + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_NONE + (void) + FLOAT_VAR_NONE + + void + + +Select first unassigned variable. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_MERIT_MIN + (FloatBranchMerit bm, BranchTbl tbl=NULL) + FLOAT_VAR_MERIT_MIN + + FloatBranchMerit + bm + + + BranchTbl + tbl + + +Select variable with least merit according to branch merit function bm. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_MERIT_MAX + (FloatBranchMerit bm, BranchTbl tbl=NULL) + FLOAT_VAR_MERIT_MAX + + FloatBranchMerit + bm + + + BranchTbl + tbl + + +Select variable with highest merit according to branch merit function bm. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_RND + (Rnd r) + FLOAT_VAR_RND + + Rnd + r + + +Select random variable (uniform distribution, for tie breaking) + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_DEGREE_MIN + (BranchTbl tbl=NULL) + FLOAT_VAR_DEGREE_MIN + + BranchTbl + tbl + + +Select variable with smallest degree. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_DEGREE_MAX + (BranchTbl tbl=NULL) + FLOAT_VAR_DEGREE_MAX + + BranchTbl + tbl + + +Select variable with largest degree. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_AFC_MIN + (double d=1.0, BranchTbl tbl=NULL) + FLOAT_VAR_AFC_MIN + + double + d + + + BranchTbl + tbl + + +Select variable with smallest accumulated failure count with decay factor d. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_AFC_MIN + (FloatAFC a, BranchTbl tbl=NULL) + FLOAT_VAR_AFC_MIN + + FloatAFC + a + + + BranchTbl + tbl + + +Select variable with smallest accumulated failure count. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_AFC_MAX + (double d=1.0, BranchTbl tbl=NULL) + FLOAT_VAR_AFC_MAX + + double + d + + + BranchTbl + tbl + + +Select variable with largest accumulated failure count with decay factor d. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_AFC_MAX + (FloatAFC a, BranchTbl tbl=NULL) + FLOAT_VAR_AFC_MAX + + FloatAFC + a + + + BranchTbl + tbl + + +Select variable with largest accumulated failure count. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_ACTIVITY_MIN + (double d=1.0, BranchTbl tbl=NULL) + FLOAT_VAR_ACTIVITY_MIN + + double + d + + + BranchTbl + tbl + + +Select variable with lowest activity with decay factor d. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_ACTIVITY_MIN + (FloatActivity a, BranchTbl tbl=NULL) + FLOAT_VAR_ACTIVITY_MIN + + FloatActivity + a + + + BranchTbl + tbl + + +Select variable with lowest activity. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_ACTIVITY_MAX + (double d=1.0, BranchTbl tbl=NULL) + FLOAT_VAR_ACTIVITY_MAX + + double + d + + + BranchTbl + tbl + + +Select variable with highest activity with decay factor d. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_ACTIVITY_MAX + (FloatActivity a, BranchTbl tbl=NULL) + FLOAT_VAR_ACTIVITY_MAX + + FloatActivity + a + + + BranchTbl + tbl + + +Select variable with highest activity. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_MIN_MIN + (BranchTbl tbl=NULL) + FLOAT_VAR_MIN_MIN + + BranchTbl + tbl + + +Select variable with smallest min. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_MIN_MAX + (BranchTbl tbl=NULL) + FLOAT_VAR_MIN_MAX + + BranchTbl + tbl + + +Select variable with largest min. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_MAX_MIN + (BranchTbl tbl=NULL) + FLOAT_VAR_MAX_MIN + + BranchTbl + tbl + + +Select variable with smallest max. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_MAX_MAX + (BranchTbl tbl=NULL) + FLOAT_VAR_MAX_MAX + + BranchTbl + tbl + + +Select variable with largest max. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_SIZE_MIN + (BranchTbl tbl=NULL) + FLOAT_VAR_SIZE_MIN + + BranchTbl + tbl + + +Select variable with smallest domain size. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_SIZE_MAX + (BranchTbl tbl=NULL) + FLOAT_VAR_SIZE_MAX + + BranchTbl + tbl + + +Select variable with largest domain size. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_DEGREE_SIZE_MIN + (BranchTbl tbl=NULL) + FLOAT_VAR_DEGREE_SIZE_MIN + + BranchTbl + tbl + + +Select variable with smallest degree divided by domain size. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_DEGREE_SIZE_MAX + (BranchTbl tbl=NULL) + FLOAT_VAR_DEGREE_SIZE_MAX + + BranchTbl + tbl + + +Select variable with largest degree divided by domain size. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_AFC_SIZE_MIN + (double d=1.0, BranchTbl tbl=NULL) + FLOAT_VAR_AFC_SIZE_MIN + + double + d + + + BranchTbl + tbl + + +Select variable with smalllest accumulated failure count divided by domain size with decay factor d. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_AFC_SIZE_MIN + (FloatAFC a, BranchTbl tbl=NULL) + FLOAT_VAR_AFC_SIZE_MIN + + FloatAFC + a + + + BranchTbl + tbl + + +Select variable with smallest accumulated failure count divided by domain size. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_AFC_SIZE_MAX + (double d=1.0, BranchTbl tbl=NULL) + FLOAT_VAR_AFC_SIZE_MAX + + double + d + + + BranchTbl + tbl + + +Select variable with largest accumulated failure count divided by domain size with decay factor d. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_AFC_SIZE_MAX + (FloatAFC a, BranchTbl tbl=NULL) + FLOAT_VAR_AFC_SIZE_MAX + + FloatAFC + a + + + BranchTbl + tbl + + +Select variable with largest accumulated failure count divided by domain size. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_ACTIVITY_SIZE_MIN + (double d=1.0, BranchTbl tbl=NULL) + FLOAT_VAR_ACTIVITY_SIZE_MIN + + double + d + + + BranchTbl + tbl + + +Select variable with smallest activity divided by domain size with decay factor d. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_ACTIVITY_SIZE_MIN + (FloatActivity a, BranchTbl tbl=NULL) + FLOAT_VAR_ACTIVITY_SIZE_MIN + + FloatActivity + a + + + BranchTbl + tbl + + +Select variable with smallest activity divided by domain size. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_ACTIVITY_SIZE_MAX + (double d=1.0, BranchTbl tbl=NULL) + FLOAT_VAR_ACTIVITY_SIZE_MAX + + double + d + + + BranchTbl + tbl + + +Select variable with largest activity divided by domain size with decay factor d. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_ACTIVITY_SIZE_MAX + (FloatActivity a, BranchTbl tbl=NULL) + FLOAT_VAR_ACTIVITY_SIZE_MAX + + FloatActivity + a + + + BranchTbl + tbl + + +Select variable with largest activity divided by domain size. + + + + + + + + forceinline FloatNum + FloatNum Gecode::pi_half_lower + (void) + pi_half_lower + + void + + +Return lower bound of $\pi/2$. + + + + + + + + forceinline FloatNum + FloatNum Gecode::pi_half_upper + (void) + pi_half_upper + + void + + +Return upper bound of $\pi/2$. + + + + + + + + forceinline FloatNum + FloatNum Gecode::pi_lower + (void) + pi_lower + + void + + +Return lower bound of $\pi$. + + + + + + + + forceinline FloatNum + FloatNum Gecode::pi_upper + (void) + pi_upper + + void + + +Return upper bound of $\pi$. + + + + + + + + forceinline FloatNum + FloatNum Gecode::pi_twice_lower + (void) + pi_twice_lower + + void + + +Return lower bound of $2\pi$. + + + + + + + + forceinline FloatNum + FloatNum Gecode::pi_twice_upper + (void) + pi_twice_upper + + void + + +Return upper bound of $2\pi$. + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::operator+ + (const FloatVal &x) + operator+ + + const FloatVal & + x + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::operator- + (const FloatVal &x) + operator- + + const FloatVal & + x + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::operator+ + (const FloatVal &x, const FloatVal &y) + operator+ + + const FloatVal & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::operator+ + (const FloatVal &x, const FloatNum &y) + operator+ + + const FloatVal & + x + + + const FloatNum & + y + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::operator+ + (const FloatNum &x, const FloatVal &y) + operator+ + + const FloatNum & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::operator- + (const FloatVal &x, const FloatVal &y) + operator- + + const FloatVal & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::operator- + (const FloatVal &x, const FloatNum &y) + operator- + + const FloatVal & + x + + + const FloatNum & + y + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::operator- + (const FloatNum &x, const FloatVal &y) + operator- + + const FloatNum & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::operator* + (const FloatVal &x, const FloatVal &y) + operator* + + const FloatVal & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::operator* + (const FloatVal &x, const FloatNum &y) + operator* + + const FloatVal & + x + + + const FloatNum & + y + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::operator* + (const FloatNum &x, const FloatVal &y) + operator* + + const FloatNum & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::operator/ + (const FloatVal &x, const FloatVal &y) + operator/ + + const FloatVal & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::operator/ + (const FloatVal &x, const FloatNum &y) + operator/ + + const FloatVal & + x + + + const FloatNum & + y + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::operator/ + (const FloatNum &x, const FloatVal &y) + operator/ + + const FloatNum & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline bool + forceinline bool Gecode::operator< + (const FloatVal &x, const FloatVal &y) + operator< + + const FloatVal & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline bool + forceinline bool Gecode::operator< + (const FloatVal &x, const FloatNum &y) + operator< + + const FloatVal & + x + + + const FloatNum & + y + + + + + + + + + + + forceinline bool + forceinline bool Gecode::operator<= + (const FloatVal &x, const FloatVal &y) + operator<= + + const FloatVal & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline bool + forceinline bool Gecode::operator<= + (const FloatVal &x, const FloatNum &y) + operator<= + + const FloatVal & + x + + + const FloatNum & + y + + + + + + + + + + + forceinline bool + forceinline bool Gecode::operator> + (const FloatVal &x, const FloatVal &y) + operator> + + const FloatVal & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline bool + forceinline bool Gecode::operator> + (const FloatVal &x, const FloatNum &y) + operator> + + const FloatVal & + x + + + const FloatNum & + y + + + + + + + + + + + forceinline bool + forceinline bool Gecode::operator>= + (const FloatVal &x, const FloatVal &y) + operator>= + + const FloatVal & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline bool + forceinline bool Gecode::operator>= + (const FloatVal &x, const FloatNum &y) + operator>= + + const FloatVal & + x + + + const FloatNum & + y + + + + + + + + + + + forceinline bool + forceinline bool Gecode::operator== + (const FloatVal &x, const FloatVal &y) + operator== + + const FloatVal & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline bool + forceinline bool Gecode::operator== + (const FloatVal &x, const FloatNum &y) + operator== + + const FloatVal & + x + + + const FloatNum & + y + + + + + + + + + + + forceinline bool + forceinline bool Gecode::operator!= + (const FloatVal &x, const FloatVal &y) + operator!= + + const FloatVal & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline bool + forceinline bool Gecode::operator!= + (const FloatVal &x, const FloatNum &y) + operator!= + + const FloatVal & + x + + + const FloatNum & + y + + + + + + + + + + + forceinline bool + forceinline bool Gecode::operator< + (const FloatNum &x, const FloatVal &y) + operator< + + const FloatNum & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline bool + forceinline bool Gecode::operator<= + (const FloatNum &x, const FloatVal &y) + operator<= + + const FloatNum & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline bool + forceinline bool Gecode::operator> + (const FloatNum &x, const FloatVal &y) + operator> + + const FloatNum & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline bool + forceinline bool Gecode::operator>= + (const FloatNum &x, const FloatVal &y) + operator>= + + const FloatNum & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline bool + forceinline bool Gecode::operator== + (const FloatNum &x, const FloatVal &y) + operator== + + const FloatNum & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline bool + forceinline bool Gecode::operator!= + (const FloatNum &x, const FloatVal &y) + operator!= + + const FloatNum & + x + + + const FloatVal & + y + + + + + + + + + + + + + class Char + + + class Traits + + + std::basic_ostream< Char, Traits > & + std::basic_ostream<Char,Traits>& Gecode::operator<< + (std::basic_ostream< Char, Traits > &os, const FloatVal &x) + operator<< + + std::basic_ostream< Char, Traits > & + os + + + const FloatVal & + x + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::abs + (const FloatVal &x) + abs + + const FloatVal & + x + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::sqrt + (const FloatVal &x) + sqrt + + const FloatVal & + x + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::sqr + (const FloatVal &x) + sqr + + const FloatVal & + x + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::pow + (const FloatVal &x, int n) + pow + + const FloatVal & + x + + + int + n + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::nroot + (const FloatVal &x, int n) + nroot + + const FloatVal & + x + + + int + n + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::max + (const FloatVal &x, const FloatVal &y) + max + + const FloatVal & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::max + (const FloatVal &x, const FloatNum &y) + max + + const FloatVal & + x + + + const FloatNum & + y + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::max + (const FloatNum &x, const FloatVal &y) + max + + const FloatNum & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::min + (const FloatVal &x, const FloatVal &y) + min + + const FloatVal & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::min + (const FloatVal &x, const FloatNum &y) + min + + const FloatVal & + x + + + const FloatNum & + y + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::min + (const FloatNum &x, const FloatVal &y) + min + + const FloatNum & + x + + + const FloatVal & + y + + + + + + + + + + + + + class Char + + + class Traits + + + std::basic_ostream< Char, Traits > & + std::basic_ostream<Char,Traits>& Gecode::operator<< + (std::basic_ostream< Char, Traits > &os, const FloatVar &x) + operator<< + + std::basic_ostream< Char, Traits > & + os + + + const FloatVar & + x + + + + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::dom + (Home home, FloatVar x, FloatVal n) + dom + + Home + home + + + FloatVar + x + + + FloatVal + n + + +Propagates $x=n$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::dom + (Home home, const FloatVarArgs &x, FloatVal n) + dom + + Home + home + + + const FloatVarArgs & + x + + + FloatVal + n + + +Propagates $ x_i=n$ for all $0\leq i<|x|$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::dom + (Home home, FloatVar x, FloatNum l, FloatNum m) + dom + + Home + home + + + FloatVar + x + + + FloatNum + l + + + FloatNum + m + + +Propagates $ l\leq x\leq u$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::dom + (Home home, const FloatVarArgs &x, FloatNum l, FloatNum u) + dom + + Home + home + + + const FloatVarArgs & + x + + + FloatNum + l + + + FloatNum + u + + +Propagates $ l\leq x_i\leq u$ for all $0\leq i<|x|$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::dom + (Home home, FloatVar x, FloatVal n, Reify r) + dom + + Home + home + + + FloatVar + x + + + FloatVal + n + + + Reify + r + + +Post domain consistent propagator for $ (x=n) \equiv r$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::dom + (Home home, FloatVar x, FloatNum l, FloatNum u, Reify r) + dom + + Home + home + + + FloatVar + x + + + FloatNum + l + + + FloatNum + u + + + Reify + r + + +Post domain consistent propagator for $ (l\leq x \leq u) \equiv r$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::dom + (Home home, FloatVar x, FloatVar d) + dom + + Home + home + + + FloatVar + x + + + FloatVar + d + + +Constrain domain of x according to domain of d. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::dom + (Home home, const FloatVarArgs &x, const FloatVarArgs &d) + dom + + Home + home + + + const FloatVarArgs & + x + + + const FloatVarArgs & + d + + +Constrain domain of $ x_i $ according to domain of $ d_i $ for all $0\leq i<|x|$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::rel + (Home home, FloatVar x0, FloatRelType frt, FloatVar x1) + rel + + Home + home + + + FloatVar + x0 + + + FloatRelType + frt + + + FloatVar + x1 + + +Post propagator for $ x_0 \sim_{frt} x_1$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::rel + (Home home, FloatVar x, FloatRelType frt, FloatVal c) + rel + + Home + home + + + FloatVar + x + + + FloatRelType + frt + + + FloatVal + c + + +Propagates $ x \sim_{frt} c$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::rel + (Home home, FloatVar x, FloatRelType frt, FloatVal c, Reify r) + rel + + Home + home + + + FloatVar + x + + + FloatRelType + frt + + + FloatVal + c + + + Reify + r + + +Post propagator for $(x \sim_{frt} c)\equiv r$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::rel + (Home home, FloatVar x0, FloatRelType frt, FloatVar x1, Reify r) + rel + + Home + home + + + FloatVar + x0 + + + FloatRelType + frt + + + FloatVar + x1 + + + Reify + r + + +Post propagator for $(x_0 \sim_{frt} x_1)\equiv r$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::rel + (Home home, const FloatVarArgs &x, FloatRelType frt, FloatVal c) + rel + + Home + home + + + const FloatVarArgs & + x + + + FloatRelType + frt + + + FloatVal + c + + +Propagates $ x_i \sim_{frt} c $ for all $0\leq i<|x|$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::rel + (Home home, const FloatVarArgs &x, FloatRelType frt, FloatVar y) + rel + + Home + home + + + const FloatVarArgs & + x + + + FloatRelType + frt + + + FloatVar + y + + +Propagates $ x_i \sim_{frt} y $ for all $0\leq i<|x|$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::min + (Home home, FloatVar x0, FloatVar x1, FloatVar x2) + min + + Home + home + + + FloatVar + x0 + + + FloatVar + x1 + + + FloatVar + x2 + + +Post propagator for $ \min\{x_0,x_1\}=x_2$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::min + (Home home, const FloatVarArgs &x, FloatVar y) + min + + Home + home + + + const FloatVarArgs & + x + + + FloatVar + y + + +Post propagator for $ \min x=y$ If x is empty, an exception of type Float::TooFewArguments is thrown. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::max + (Home home, FloatVar x0, FloatVar x1, FloatVar x2) + max + + Home + home + + + FloatVar + x0 + + + FloatVar + x1 + + + FloatVar + x2 + + +Post propagator for $ \max\{x_0,x_1\}=x_2$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::max + (Home home, const FloatVarArgs &x, FloatVar y) + max + + Home + home + + + const FloatVarArgs & + x + + + FloatVar + y + + +Post propagator for $ \max x=y$ If x is empty, an exception of type Float::TooFewArguments is thrown. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::abs + (Home home, FloatVar x0, FloatVar x1) + abs + + Home + home + + + FloatVar + x0 + + + FloatVar + x1 + + +Post propagator for $ |x_0|=x_1$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::mult + (Home home, FloatVar x0, FloatVar x1, FloatVar x2) + mult + + Home + home + + + FloatVar + x0 + + + FloatVar + x1 + + + FloatVar + x2 + + +Post propagator for $x_0\cdot x_1=x_2$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::sqr + (Home home, FloatVar x0, FloatVar x1) + sqr + + Home + home + + + FloatVar + x0 + + + FloatVar + x1 + + +Post propagator for $x_0\cdot x_0=x_1$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::sqrt + (Home home, FloatVar x0, FloatVar x1) + sqrt + + Home + home + + + FloatVar + x0 + + + FloatVar + x1 + + +Post propagator for $\sqrt{x_0}=x_1$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::pow + (Home home, FloatVar x0, int n, FloatVar x1) + pow + + Home + home + + + FloatVar + x0 + + + int + n + + + FloatVar + x1 + + +Post propagator for ${x_0}^{n}=x_1$ for $n 0$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::nroot + (Home home, FloatVar x0, int n, FloatVar x1) + nroot + + Home + home + + + FloatVar + x0 + + + int + n + + + FloatVar + x1 + + +Post propagator for ${x_0}^{1/n}=x_1$ for $n 0$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::div + (Home home, FloatVar x0, FloatVar x1, FloatVar x2) + div + + Home + home + + + FloatVar + x0 + + + FloatVar + x1 + + + FloatVar + x2 + + +Post propagator for $x_0\ \mathrm{div}\ x_1=x_2$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::linear + (Home home, const FloatVarArgs &x, FloatRelType frt, FloatNum c) + linear + + Home + home + + + const FloatVarArgs & + x + + + FloatRelType + frt + + + FloatNum + c + + +Post propagator for $\sum_{i=0}^{|x|-1}x_i\sim_{frt} c$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::linear + (Home home, const FloatVarArgs &x, FloatRelType frt, FloatVar y) + linear + + Home + home + + + const FloatVarArgs & + x + + + FloatRelType + frt + + + FloatVar + y + + +Post propagator for $\sum_{i=0}^{|x|-1}x_i\sim_{frt} y$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::linear + (Home home, const FloatVarArgs &x, FloatRelType frt, FloatNum c, Reify r) + linear + + Home + home + + + const FloatVarArgs & + x + + + FloatRelType + frt + + + FloatNum + c + + + Reify + r + + +Post propagator for $\left(\sum_{i=0}^{|x|-1}x_i\sim_{frt} c\right)\equiv r$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::linear + (Home home, const FloatVarArgs &x, FloatRelType frt, FloatVar y, Reify r) + linear + + Home + home + + + const FloatVarArgs & + x + + + FloatRelType + frt + + + FloatVar + y + + + Reify + r + + +Post propagator for $\left(\sum_{i=0}^{|x|-1}x_i\sim_{frt} y\right)\equiv r$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::linear + (Home home, const FloatValArgs &a, const FloatVarArgs &x, FloatRelType frt, FloatNum c) + linear + + Home + home + + + const FloatValArgs & + a + + + const FloatVarArgs & + x + + + FloatRelType + frt + + + FloatNum + c + + +Post propagator for $\sum_{i=0}^{|x|-1}a_i\cdot x_i\sim_{frt} c$. + +Throws an exception of type Float::ArgumentSizeMismatch, if a and x are of different size. + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::linear + (Home home, const FloatValArgs &a, const FloatVarArgs &x, FloatRelType frt, FloatVar y) + linear + + Home + home + + + const FloatValArgs & + a + + + const FloatVarArgs & + x + + + FloatRelType + frt + + + FloatVar + y + + +Post propagator for $\sum_{i=0}^{|x|-1}a_i\cdot x_i\sim_{frt} y$. + +Throws an exception of type Float::ArgumentSizeMismatch, if a and x are of different size. + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::linear + (Home home, const FloatValArgs &a, const FloatVarArgs &x, FloatRelType frt, FloatNum c, Reify r) + linear + + Home + home + + + const FloatValArgs & + a + + + const FloatVarArgs & + x + + + FloatRelType + frt + + + FloatNum + c + + + Reify + r + + +Post propagator for $\left(\sum_{i=0}^{|x|-1}a_i\cdot x_i\sim_{frt} c\right)\equiv r$. + +Throws an exception of type Float::ArgumentSizeMismatch, if a and x are of different size. + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::linear + (Home home, const FloatValArgs &a, const FloatVarArgs &x, FloatRelType frt, FloatVar y, Reify r) + linear + + Home + home + + + const FloatValArgs & + a + + + const FloatVarArgs & + x + + + FloatRelType + frt + + + FloatVar + y + + + Reify + r + + +Post propagator for $\left(\sum_{i=0}^{|x|-1}a_i\cdot x_i\sim_{frt} y\right)\equiv r$. + +Throws an exception of type Float::ArgumentSizeMismatch, if a and x are of different size. + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::channel + (Home home, FloatVar x0, IntVar x1) + channel + + Home + home + + + FloatVar + x0 + + + IntVar + x1 + + +Post propagator for channeling a float and an integer variable $ x_0 = x_1$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::channel + (Home home, IntVar x0, FloatVar x1) + channel + + Home + home + + + IntVar + x0 + + + FloatVar + x1 + + +Post propagator for channeling a float and an integer variable $ x_0 = x_1$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::wait + (Home home, FloatVar x, void(*c)(Space &home)) + wait + + Home + home + + + FloatVar + x + + + void(*)(Space &home) + c + + +Execute c when x becomes assigned. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::wait + (Home home, const FloatVarArgs &x, void(*c)(Space &home)) + wait + + Home + home + + + const FloatVarArgs & + x + + + void(*)(Space &home) + c + + +Execute c when all variables in x become assigned. + + + + + + + + GECODE_FLOAT_EXPORT BrancherHandle + GECODE_FLOAT_EXPORT BrancherHandle Gecode::branch + (Home home, const FloatVarArgs &x, FloatVarBranch vars, FloatValBranch vals, FloatBranchFilter bf=NULL, FloatVarValPrint vvp=NULL) + branch + + Home + home + + + const FloatVarArgs & + x + + + FloatVarBranch + vars + + + FloatValBranch + vals + + + FloatBranchFilter + bf + NULL + + + FloatVarValPrint + vvp + NULL + + +Branch over x with variable selection vars and value selection vals. + + + + + + + + GECODE_FLOAT_EXPORT BrancherHandle + GECODE_FLOAT_EXPORT BrancherHandle Gecode::branch + (Home home, const FloatVarArgs &x, TieBreak< FloatVarBranch > vars, FloatValBranch vals, FloatBranchFilter bf=NULL, FloatVarValPrint vvp=NULL) + branch + + Home + home + + + const FloatVarArgs & + x + + + TieBreak< FloatVarBranch > + vars + + + FloatValBranch + vals + + + FloatBranchFilter + bf + NULL + + + FloatVarValPrint + vvp + NULL + + +Branch over x with tie-breaking variable selection vars and value selection vals. + + + + + + + + GECODE_FLOAT_EXPORT BrancherHandle + GECODE_FLOAT_EXPORT BrancherHandle Gecode::branch + (Home home, FloatVar x, FloatValBranch vals, FloatVarValPrint vvp=NULL) + branch + + Home + home + + + FloatVar + x + + + FloatValBranch + vals + + + FloatVarValPrint + vvp + NULL + + +Branch over x with value selection vals. + + + + + + + + GECODE_FLOAT_EXPORT BrancherHandle + GECODE_FLOAT_EXPORT BrancherHandle Gecode::assign + (Home home, const FloatVarArgs &x, FloatAssign vals, FloatBranchFilter fbf=NULL, FloatVarValPrint vvp=NULL) + assign + + Home + home + + + const FloatVarArgs & + x + + + FloatAssign + vals + + + FloatBranchFilter + fbf + NULL + + + FloatVarValPrint + vvp + NULL + + +Assign all x with value selection vals. + + + + + + + + GECODE_FLOAT_EXPORT BrancherHandle + GECODE_FLOAT_EXPORT BrancherHandle Gecode::assign + (Home home, FloatVar x, FloatAssign vals, FloatVarValPrint vvp=NULL) + assign + + Home + home + + + FloatVar + x + + + FloatAssign + vals + + + FloatVarValPrint + vvp + NULL + + +Assign x with value selection vals. + + + + + + + + IntAssign + IntAssign Gecode::INT_ASSIGN_MIN + (void) + INT_ASSIGN_MIN + + void + + +Select smallest value. + + + + + + + + IntAssign + IntAssign Gecode::INT_ASSIGN_MED + (void) + INT_ASSIGN_MED + + void + + +Select greatest value not greater than the median. + + + + + + + + IntAssign + IntAssign Gecode::INT_ASSIGN_MAX + (void) + INT_ASSIGN_MAX + + void + + +Select largest value. + + + + + + + + IntAssign + IntAssign Gecode::INT_ASSIGN_RND + (Rnd r) + INT_ASSIGN_RND + + Rnd + r + + +Select random value. + + + + + + + + IntAssign + IntAssign Gecode::INT_ASSIGN + (IntBranchVal v, IntBranchCommit c=NULL) + INT_ASSIGN + + IntBranchVal + v + + + IntBranchCommit + c + NULL + + +Select value as defined by the value function v and commit function c. + +Uses a commit function as default that posts the constraint that a variable x must be equal to the value n. + + + + + + IntAssign + IntAssign Gecode::INT_ASSIGN + (BoolBranchVal v, BoolBranchCommit c=NULL) + INT_ASSIGN + + BoolBranchVal + v + + + BoolBranchCommit + c + NULL + + +Select value as defined by the value function v and commit function c. + +Uses a commit function as default that posts the constraint that a variable x must be equal to the value n. + + + + + + IntValBranch + IntValBranch Gecode::INT_VAL_MIN + (void) + INT_VAL_MIN + + void + + +Select smallest value. + + + + + + + + IntValBranch + IntValBranch Gecode::INT_VAL_MED + (void) + INT_VAL_MED + + void + + +Select greatest value not greater than the median. + + + + + + + + IntValBranch + IntValBranch Gecode::INT_VAL_MAX + (void) + INT_VAL_MAX + + void + + +Select largest value. + + + + + + + + IntValBranch + IntValBranch Gecode::INT_VAL_RND + (Rnd r) + INT_VAL_RND + + Rnd + r + + +Select random value. + + + + + + + + IntValBranch + IntValBranch Gecode::INT_VAL_SPLIT_MIN + (void) + INT_VAL_SPLIT_MIN + + void + + +Select values not greater than mean of smallest and largest value. + + + + + + + + IntValBranch + IntValBranch Gecode::INT_VAL_SPLIT_MAX + (void) + INT_VAL_SPLIT_MAX + + void + + +Select values greater than mean of smallest and largest value. + + + + + + + + IntValBranch + IntValBranch Gecode::INT_VAL_RANGE_MIN + (void) + INT_VAL_RANGE_MIN + + void + + +Select the smallest range of the variable domain if it has several ranges, otherwise select values not greater than mean of smallest and largest value. + + + + + + + + IntValBranch + IntValBranch Gecode::INT_VAL_RANGE_MAX + (void) + INT_VAL_RANGE_MAX + + void + + +Select the largest range of the variable domain if it has several ranges, otherwise select values greater than mean of smallest and largest value. + + + + + + + + IntValBranch + IntValBranch Gecode::INT_VAL + (IntBranchVal v, IntBranchCommit c=NULL) + INT_VAL + + IntBranchVal + v + + + IntBranchCommit + c + + +Select value as defined by the value function v and commit function c Uses a commit function as default that posts the constraints that a variable x must be equal to a value n for the first alternative and that x must be different from n for the second alternative. + + + + + + + + IntValBranch + IntValBranch Gecode::INT_VAL + (BoolBranchVal v, BoolBranchCommit c=NULL) + INT_VAL + + BoolBranchVal + v + + + BoolBranchCommit + c + + +Select value as defined by the value function v and commit function c Uses a commit function as default that posts the constraints that a variable x must be equal to a value n for the first alternative and that x must be different from n for the second alternative. + + + + + + + + IntValBranch + IntValBranch Gecode::INT_VALUES_MIN + (void) + INT_VALUES_MIN + + void + + +Try all values starting from smallest. + + + + + + + + IntValBranch + IntValBranch Gecode::INT_VALUES_MAX + (void) + INT_VALUES_MAX + + void + + +Try all values starting from largest. + + + + + + + + IntValBranch + IntValBranch Gecode::INT_VAL_NEAR_MIN + (IntSharedArray n) + INT_VAL_NEAR_MIN + + IntSharedArray + n + + +Try value nearest to a given value for a variable, in case of ties use the smaller value. + + + + + + + + IntValBranch + IntValBranch Gecode::INT_VAL_NEAR_MAX + (IntSharedArray n) + INT_VAL_NEAR_MAX + + IntSharedArray + n + + +Try value nearest to a given value for a variable, in case of ties use the larger value. + + + + + + + + IntValBranch + IntValBranch Gecode::INT_VAL_NEAR_INC + (IntSharedArray n) + INT_VAL_NEAR_INC + + IntSharedArray + n + + +Try value larger than a given value for a variable first. + + + + + + + + IntValBranch + IntValBranch Gecode::INT_VAL_NEAR_DEC + (IntSharedArray n) + INT_VAL_NEAR_DEC + + IntSharedArray + n + + +Try value smaller than a given value for a variable first. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_NONE + (void) + INT_VAR_NONE + + void + + +Select first unassigned variable. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_RND + (Rnd r) + INT_VAR_RND + + Rnd + r + + +Select random variable (uniform distribution, for tie breaking) + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_MERIT_MIN + (IntBranchMerit bm, BranchTbl tbl=NULL) + INT_VAR_MERIT_MIN + + IntBranchMerit + bm + + + BranchTbl + tbl + + +Select variable with least merit according to branch merit function bm. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_MERIT_MIN + (BoolBranchMerit bm, BranchTbl tbl=NULL) + INT_VAR_MERIT_MIN + + BoolBranchMerit + bm + + + BranchTbl + tbl + + +Select variable with least merit according to branch merit function bm. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_MERIT_MAX + (IntBranchMerit bm, BranchTbl tbl=NULL) + INT_VAR_MERIT_MAX + + IntBranchMerit + bm + + + BranchTbl + tbl + + +Select variable with highest merit according to branch merit function bm. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_MERIT_MAX + (BoolBranchMerit bm, BranchTbl tbl=NULL) + INT_VAR_MERIT_MAX + + BoolBranchMerit + bm + + + BranchTbl + tbl + + +Select variable with highest merit according to branch merit function bm. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_DEGREE_MIN + (BranchTbl tbl=NULL) + INT_VAR_DEGREE_MIN + + BranchTbl + tbl + + +Select variable with smallest degree. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_DEGREE_MAX + (BranchTbl tbl=NULL) + INT_VAR_DEGREE_MAX + + BranchTbl + tbl + + +Select variable with largest degree. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_AFC_MIN + (double d=1.0, BranchTbl tbl=NULL) + INT_VAR_AFC_MIN + + double + d + + + BranchTbl + tbl + + +Select variable with smallest accumulated failure count with decay factor d. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_AFC_MIN + (IntAFC a, BranchTbl tbl=NULL) + INT_VAR_AFC_MIN + + IntAFC + a + + + BranchTbl + tbl + + +Select variable with smallest accumulated failure count. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_AFC_MAX + (double d=1.0, BranchTbl tbl=NULL) + INT_VAR_AFC_MAX + + double + d + + + BranchTbl + tbl + + +Select variable with largest accumulated failure count with decay factor d. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_AFC_MAX + (IntAFC a, BranchTbl tbl=NULL) + INT_VAR_AFC_MAX + + IntAFC + a + + + BranchTbl + tbl + + +Select variable with largest accumulated failure count. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_ACTIVITY_MIN + (double d=1.0, BranchTbl tbl=NULL) + INT_VAR_ACTIVITY_MIN + + double + d + + + BranchTbl + tbl + + +Select variable with lowest activity with decay factor d. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_ACTIVITY_MIN + (IntActivity a, BranchTbl tbl=NULL) + INT_VAR_ACTIVITY_MIN + + IntActivity + a + + + BranchTbl + tbl + + +Select variable with lowest activity. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_ACTIVITY_MAX + (double d=1.0, BranchTbl tbl=NULL) + INT_VAR_ACTIVITY_MAX + + double + d + + + BranchTbl + tbl + + +Select variable with highest activity with decay factor d. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_ACTIVITY_MAX + (IntActivity a, BranchTbl tbl=NULL) + INT_VAR_ACTIVITY_MAX + + IntActivity + a + + + BranchTbl + tbl + + +Select variable with highest activity. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_MIN_MIN + (BranchTbl tbl=NULL) + INT_VAR_MIN_MIN + + BranchTbl + tbl + + +Select variable with smallest min. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_MIN_MAX + (BranchTbl tbl=NULL) + INT_VAR_MIN_MAX + + BranchTbl + tbl + + +Select variable with largest min. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_MAX_MIN + (BranchTbl tbl=NULL) + INT_VAR_MAX_MIN + + BranchTbl + tbl + + +Select variable with smallest max. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_MAX_MAX + (BranchTbl tbl=NULL) + INT_VAR_MAX_MAX + + BranchTbl + tbl + + +Select variable with largest max. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_SIZE_MIN + (BranchTbl tbl=NULL) + INT_VAR_SIZE_MIN + + BranchTbl + tbl + + +Select variable with smallest domain size. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_SIZE_MAX + (BranchTbl tbl=NULL) + INT_VAR_SIZE_MAX + + BranchTbl + tbl + + +Select variable with largest domain size. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_DEGREE_SIZE_MIN + (BranchTbl tbl=NULL) + INT_VAR_DEGREE_SIZE_MIN + + BranchTbl + tbl + + +Select variable with smallest degree divided by domain size. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_DEGREE_SIZE_MAX + (BranchTbl tbl=NULL) + INT_VAR_DEGREE_SIZE_MAX + + BranchTbl + tbl + + +Select variable with largest degree divided by domain size. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_AFC_SIZE_MIN + (double d=1.0, BranchTbl tbl=NULL) + INT_VAR_AFC_SIZE_MIN + + double + d + + + BranchTbl + tbl + + +Select variable with smallest accumulated failure count divided by domain size with decay factor d. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_AFC_SIZE_MIN + (IntAFC a, BranchTbl tbl=NULL) + INT_VAR_AFC_SIZE_MIN + + IntAFC + a + + + BranchTbl + tbl + + +Select variable with smallest accumulated failure count divided by domain size. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_AFC_SIZE_MAX + (double d=1.0, BranchTbl tbl=NULL) + INT_VAR_AFC_SIZE_MAX + + double + d + + + BranchTbl + tbl + + +Select variable with largest accumulated failure count divided by domain size with decay factor d. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_AFC_SIZE_MAX + (IntAFC a, BranchTbl tbl=NULL) + INT_VAR_AFC_SIZE_MAX + + IntAFC + a + + + BranchTbl + tbl + + +Select variable with largest accumulated failure count divided by domain size. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_ACTIVITY_SIZE_MIN + (double d=1.0, BranchTbl tbl=NULL) + INT_VAR_ACTIVITY_SIZE_MIN + + double + d + + + BranchTbl + tbl + + +Select variable with smallest activity divided by domain size with decay factor d. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_ACTIVITY_SIZE_MIN + (IntActivity a, BranchTbl tbl=NULL) + INT_VAR_ACTIVITY_SIZE_MIN + + IntActivity + a + + + BranchTbl + tbl + + +Select variable with smallest activity divided by domain size. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_ACTIVITY_SIZE_MAX + (double d=1.0, BranchTbl tbl=NULL) + INT_VAR_ACTIVITY_SIZE_MAX + + double + d + + + BranchTbl + tbl + + +Select variable with largest activity divided by domain size with decay factor d. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_ACTIVITY_SIZE_MAX + (IntActivity a, BranchTbl tbl=NULL) + INT_VAR_ACTIVITY_SIZE_MAX + + IntActivity + a + + + BranchTbl + tbl + + +Select variable with largest activity divided by domain size. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_REGRET_MIN_MIN + (BranchTbl tbl=NULL) + INT_VAR_REGRET_MIN_MIN + + BranchTbl + tbl + NULL + + +Select variable with smallest min-regret. + +The min-regret of a variable is the difference between the smallest and second-smallest value still in the domain. + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_REGRET_MIN_MAX + (BranchTbl tbl=NULL) + INT_VAR_REGRET_MIN_MAX + + BranchTbl + tbl + NULL + + +Select variable with largest min-regret. + +The min-regret of a variable is the difference between the smallest and second-smallest value still in the domain. + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_REGRET_MAX_MIN + (BranchTbl tbl=NULL) + INT_VAR_REGRET_MAX_MIN + + BranchTbl + tbl + NULL + + +Select variable with smallest max-regret. + +The max-regret of a variable is the difference between the largest and second-largest value still in the domain. + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_REGRET_MAX_MAX + (BranchTbl tbl=NULL) + INT_VAR_REGRET_MAX_MAX + + BranchTbl + tbl + NULL + + +Select variable with largest max-regret. + +The max-regret of a variable is the difference between the largest and second-largest value still in the domain. + + + + + + + + class Char + + + class Traits + + + std::basic_ostream< Char, Traits > & + std::basic_ostream<Char,Traits>& Gecode::operator<< + (std::basic_ostream< Char, Traits > &os, const DFA &d) + operator<< + + std::basic_ostream< Char, Traits > & + os + + + const DFA & + d + + + + + + + + + + + + + class Char + + + class Traits + + + class T + + + std::basic_ostream< Char, Traits > & + std::basic_ostream<Char,Traits>& Gecode::operator<< + (std::basic_ostream< Char, Traits > &os, const TupleSet &ts) + operator<< + + std::basic_ostream< Char, Traits > & + os + + + const TupleSet & + ts + + + + + + + + + + + + + class Char + + + class Traits + + + std::basic_ostream< Char, Traits > & + std::basic_ostream<Char,Traits>& Gecode::operator<< + (std::basic_ostream< Char, Traits > &os, const IntSet &is) + operator<< + + std::basic_ostream< Char, Traits > & + os + + + const IntSet & + is + + + + + + + + + + + forceinline Reify + Reify Gecode::eqv + (BoolVar x) + eqv + + BoolVar + x + + +Use equivalence for reification. + + + + + + + + forceinline Reify + Reify Gecode::imp + (BoolVar x) + imp + + BoolVar + x + + +Use implication for reification. + + + + + + + + forceinline Reify + Reify Gecode::pmi + (BoolVar x) + pmi + + BoolVar + x + + +Use reverse implication for reification. + + + + + + + + + + class Char + + + class Traits + + + std::basic_ostream< Char, Traits > & + std::basic_ostream<Char,Traits>& Gecode::operator<< + (std::basic_ostream< Char, Traits > &os, const IntVar &x) + operator<< + + std::basic_ostream< Char, Traits > & + os + + + const IntVar & + x + + + + + + + + + + + + + class Char + + + class Traits + + + std::basic_ostream< Char, Traits > & + std::basic_ostream<Char,Traits>& Gecode::operator<< + (std::basic_ostream< Char, Traits > &os, const BoolVar &x) + operator<< + + std::basic_ostream< Char, Traits > & + os + + + const BoolVar & + x + + + + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::dom + (Home home, IntVar x, int n, IntConLevel icl=ICL_DEF) + dom + + Home + home + + + IntVar + x + + + int + n + + + IntConLevel + icl + ICL_DEF + + +Propagates $x=n$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::dom + (Home home, const IntVarArgs &x, int n, IntConLevel icl=ICL_DEF) + dom + + Home + home + + + const IntVarArgs & + x + + + int + n + + + IntConLevel + icl + ICL_DEF + + +Propagates $ x_i=n$ for all $0\leq i<|x|$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::dom + (Home home, IntVar x, int l, int m, IntConLevel icl=ICL_DEF) + dom + + Home + home + + + IntVar + x + + + int + l + + + int + m + + + IntConLevel + icl + ICL_DEF + + +Propagates $ l\leq x\leq m$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::dom + (Home home, const IntVarArgs &x, int l, int m, IntConLevel icl=ICL_DEF) + dom + + Home + home + + + const IntVarArgs & + x + + + int + l + + + int + m + + + IntConLevel + icl + ICL_DEF + + +Propagates $ l\leq x_i\leq m$ for all $0\leq i<|x|$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::dom + (Home home, IntVar x, const IntSet &s, IntConLevel icl=ICL_DEF) + dom + + Home + home + + + IntVar + x + + + const IntSet & + s + + + IntConLevel + icl + ICL_DEF + + +Propagates $ x\in s $. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::dom + (Home home, const IntVarArgs &x, const IntSet &s, IntConLevel icl=ICL_DEF) + dom + + Home + home + + + const IntVarArgs & + x + + + const IntSet & + s + + + IntConLevel + icl + ICL_DEF + + +Propagates $ x_i\in s$ for all $0\leq i<|x|$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::dom + (Home home, IntVar x, int n, Reify r, IntConLevel icl=ICL_DEF) + dom + + Home + home + + + IntVar + x + + + int + n + + + Reify + r + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $ (x=n) \equiv r$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::dom + (Home home, IntVar x, int l, int m, Reify r, IntConLevel icl=ICL_DEF) + dom + + Home + home + + + IntVar + x + + + int + l + + + int + m + + + Reify + r + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $ (l\leq x \leq m) \equiv r$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::dom + (Home home, IntVar x, const IntSet &s, Reify r, IntConLevel icl=ICL_DEF) + dom + + Home + home + + + IntVar + x + + + const IntSet & + s + + + Reify + r + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $ (x \in s) \equiv r$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::dom + (Home home, IntVar x, IntVar d, IntConLevel icl=ICL_DEF) + dom + + Home + home + + + IntVar + x + + + IntVar + d + + + IntConLevel + icl + ICL_DEF + + +Constrain domain of x according to domain of d. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::dom + (Home home, BoolVar x, BoolVar d, IntConLevel icl=ICL_DEF) + dom + + Home + home + + + BoolVar + x + + + BoolVar + d + + + IntConLevel + icl + ICL_DEF + + +Constrain domain of x according to domain of d. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::dom + (Home home, const IntVarArgs &x, const IntVarArgs &d, IntConLevel icl=ICL_DEF) + dom + + Home + home + + + const IntVarArgs & + x + + + const IntVarArgs & + d + + + IntConLevel + icl + ICL_DEF + + +Constrain domain of $ x_i $ according to domain of $ d_i $ for all $0\leq i<|x|$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::dom + (Home home, const BoolVarArgs &x, const BoolVarArgs &d, IntConLevel icl=ICL_DEF) + dom + + Home + home + + + const BoolVarArgs & + x + + + const BoolVarArgs & + d + + + IntConLevel + icl + ICL_DEF + + +Constrain domain of $ x_i $ according to domain of $ d_i $ for all $0\leq i<|x|$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, IntVar x0, IntRelType irt, IntVar x1, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + IntVar + x0 + + + IntRelType + irt + + + IntVar + x1 + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $ x_0 \sim_{irt} x_1$. + +Supports both bounds (icl = ICL_BND) and domain consistency (icl = ICL_DOM, default). + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, const IntVarArgs &x, IntRelType irt, IntVar y, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + const IntVarArgs & + x + + + IntRelType + irt + + + IntVar + y + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $ x_i \sim_{irt} y $ for all $0\leq i<|x|$. + +Supports both bounds (icl = ICL_BND) and domain consistency (icl = ICL_DOM, default). + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, IntVar x, IntRelType irt, int c, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + IntVar + x + + + IntRelType + irt + + + int + c + + + IntConLevel + icl + ICL_DEF + + +Propagates $ x \sim_{irt} c$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, const IntVarArgs &x, IntRelType irt, int c, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + const IntVarArgs & + x + + + IntRelType + irt + + + int + c + + + IntConLevel + icl + ICL_DEF + + +Propagates $ x_i \sim_{irt} c $ for all $0\leq i<|x|$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, IntVar x0, IntRelType irt, IntVar x1, Reify r, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + IntVar + x0 + + + IntRelType + irt + + + IntVar + x1 + + + Reify + r + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $ (x_0 \sim_{irt} x_1)\equiv r$. + +Supports both bounds (icl = ICL_BND) and domain consistency (icl = ICL_DOM, default). + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, IntVar x, IntRelType irt, int c, Reify r, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + IntVar + x + + + IntRelType + irt + + + int + c + + + Reify + r + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $(x \sim_{irt} c)\equiv r$. + +Supports both bounds (icl = ICL_BND) and domain consistency (icl = ICL_DOM, default). + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, const IntVarArgs &x, IntRelType irt, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + const IntVarArgs & + x + + + IntRelType + irt + + + IntConLevel + icl + ICL_DEF + + +Post propagator for relation among elements in x. + +States that the elements of x are in the following relation: +if r = IRT_LE, r = IRT_LQ, r = IRT_GR, or r = IRT_GQ, then the elements of x are ordered with respect to r. Supports domain consistency (icl = ICL_DOM, default).if r = IRT_EQ, then all elements of x must be equal. Supports both bounds (icl = ICL_BND) and domain consistency (icl = ICL_DOM, default).if r = IRT_NQ, then not all elements of x must be equal. Supports domain consistency (icl = ICL_DOM, default). + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, const IntVarArgs &x, IntRelType irt, const IntVarArgs &y, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + const IntVarArgs & + x + + + IntRelType + irt + + + const IntVarArgs & + y + + + IntConLevel + icl + ICL_DEF + + +Post propagator for relation between x and y. + +Note that for the inequality relations this corresponds to the lexical order between x and y.Supports both bounds (icl = ICL_BND) and domain consistency (icl = ICL_DOM, default).Note that the constraint is also defined if x and y are of different size. That means that if x and y are of different size, then if r = IRT_EQ the constraint is false and if r = IRT_NQ the constraint is subsumed. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, BoolVar x0, IntRelType irt, BoolVar x1, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + BoolVar + x0 + + + IntRelType + irt + + + BoolVar + x1 + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $ x_0 \sim_{irt} x_1$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, BoolVar x0, IntRelType irt, BoolVar x1, Reify r, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + BoolVar + x0 + + + IntRelType + irt + + + BoolVar + x1 + + + Reify + r + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $(x_0 \sim_{irt} x_1)\equiv r$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, const BoolVarArgs &x, IntRelType irt, BoolVar y, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + const BoolVarArgs & + x + + + IntRelType + irt + + + BoolVar + y + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $ x_i \sim_{irt} y $ for all $0\leq i<|x|$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, BoolVar x, IntRelType irt, int n, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + BoolVar + x + + + IntRelType + irt + + + int + n + + + IntConLevel + icl + ICL_DEF + + +Propagates $ x \sim_{irt} n$. + +Throws an exception of type Int::NotZeroOne, if n is neither 0 or 1. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, BoolVar x, IntRelType irt, int n, Reify r, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + BoolVar + x + + + IntRelType + irt + + + int + n + + + Reify + r + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $(x \sim_{irt} n)\equiv r$. + +Throws an exception of type Int::NotZeroOne, if n is neither 0 or 1. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, const BoolVarArgs &x, IntRelType irt, int n, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + const BoolVarArgs & + x + + + IntRelType + irt + + + int + n + + + IntConLevel + icl + ICL_DEF + + +Propagates $ x_i \sim_{irt} n $ for all $0\leq i<|x|$. + +Throws an exception of type Int::NotZeroOne, if n is neither 0 or 1. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, const BoolVarArgs &x, IntRelType irt, const BoolVarArgs &y, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + const BoolVarArgs & + x + + + IntRelType + irt + + + const BoolVarArgs & + y + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for relation between x and y. + +Note that for the inequality relations this corresponds to the lexical order between x and y.Throws an exception of type Int::ArgumentSizeMismatch, if x and y are of different size. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, const BoolVarArgs &x, IntRelType irt, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + const BoolVarArgs & + x + + + IntRelType + irt + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for relation between elements in x. + +States that the elements of x are in the following relation: +if r = IRT_LE, r = IRT_LQ, r = IRT_GR, or r = IRT_GQ, then the elements of x are ordered with respect to r.if r = IRT_EQ, then all elements of x must be equal.if r = IRT_NQ, then not all elements of x must be equal. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, BoolVar x0, BoolOpType o, BoolVar x1, BoolVar x2, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + BoolVar + x0 + + + BoolOpType + o + + + BoolVar + x1 + + + BoolVar + x2 + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for Boolean operation on x0 and x1. + +Posts propagator for $ x_0 \diamond_{\mathit{o}} x_1 = x_2$ + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, BoolVar x0, BoolOpType o, BoolVar x1, int n, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + BoolVar + x0 + + + BoolOpType + o + + + BoolVar + x1 + + + int + n + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for Boolean operation on x0 and x1. + +Posts propagator for $ x_0 \diamond_{\mathit{o}} x_1 = n$Throws an exception of type Int::NotZeroOne, if n is neither 0 or 1. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, BoolOpType o, const BoolVarArgs &x, BoolVar y, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + BoolOpType + o + + + const BoolVarArgs & + x + + + BoolVar + y + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for Boolean operation on x. + +Posts propagator for $ x_0 \diamond_{\mathit{o}} \cdots \diamond_{\mathit{o}} x_{|x|-1}= y$Throws an exception of type Int::TooFewArguments, if $|x|<2$ and o is BOT_IMP, BOT_EQV, or BOT_XOR. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, BoolOpType o, const BoolVarArgs &x, int n, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + BoolOpType + o + + + const BoolVarArgs & + x + + + int + n + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for Boolean operation on x. + +Posts propagator for $ x_0 \diamond_{\mathit{o}} \cdots \diamond_{\mathit{o}} x_{|x|-1}= n$Throws an exception of type Int::NotZeroOne, if n is neither 0 or 1.Throws an exception of type Int::TooFewArguments, if $|x|<2$ and o is BOT_IMP, BOT_EQV, or BOT_XOR. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::clause + (Home home, BoolOpType o, const BoolVarArgs &x, const BoolVarArgs &y, BoolVar z, IntConLevel icl=ICL_DEF) + clause + + Home + home + + + BoolOpType + o + + + const BoolVarArgs & + x + + + const BoolVarArgs & + y + + + BoolVar + z + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for Boolean clause with positive variables x and negative variables y. + +Posts propagator for $ x_0 \diamond_{\mathit{o}} \cdots \diamond_{\mathit{o}} x_{|x|-1} \diamond_{\mathit{o}} \neg y_0 \diamond_{\mathit{o}} \cdots \diamond_{\mathit{o}} \neg y_{|y|-1}= z$Throws an exception of type Int::IllegalOperation, if o is different from BOT_AND or BOT_OR. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::clause + (Home home, BoolOpType o, const BoolVarArgs &x, const BoolVarArgs &y, int n, IntConLevel icl=ICL_DEF) + clause + + Home + home + + + BoolOpType + o + + + const BoolVarArgs & + x + + + const BoolVarArgs & + y + + + int + n + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for Boolean clause with positive variables x and negative variables y. + +Posts propagator for $ x_0 \diamond_{\mathit{o}} \cdots \diamond_{\mathit{o}} x_{|x|-1} \diamond_{\mathit{o}} \neg y_0 \diamond_{\mathit{o}} \cdots \diamond_{\mathit{o}} \neg y_{|y|-1}= n$Throws an exception of type Int::NotZeroOne, if n is neither 0 or 1.Throws an exception of type Int::IllegalOperation, if o is different from BOT_AND or BOT_OR. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::ite + (Home home, BoolVar b, IntVar x, IntVar y, IntVar z, IntConLevel icl=ICL_DEF) + ite + + Home + home + + + BoolVar + b + + + IntVar + x + + + IntVar + y + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post propagator for if-then-else constraint. + +Posts propagator for $ z = b ? x : y $ + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::precede + (Home home, const IntVarArgs &x, int s, int t, IntConLevel=ICL_DEF) + precede + + Home + home + + + const IntVarArgs & + x + + + int + s + + + int + t + + + IntConLevel + ICL_DEF + + +Post propagator that s precedes t in x. + +This constraint enforces that $x_0\neq t$ and $x_j=t \to \bigvee_{0\leq i<j} x_i=s$ for $0\leq j<|x|$. The propagator is domain consistent. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::precede + (Home home, const IntVarArgs &x, const IntArgs &c, IntConLevel=ICL_DEF) + precede + + Home + home + + + const IntVarArgs & + x + + + const IntArgs & + c + + + IntConLevel + ICL_DEF + + +Post propagator that successive values in c precede each other in x. + +This constraint enforces that $x_0\neq c_k$ for $0<k<|c|$ and $x_j=c_{k} \to \bigvee_{0\leq i<j} x_i=c_{k-1}$ for $0\leq j<|x|$ and $0< k<|c|$. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::member + (Home home, const IntVarArgs &x, IntVar y, IntConLevel icl=ICL_DEF) + member + + Home + home + + + const IntVarArgs & + x + + + IntVar + y + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $y\in \{x_0,\ldots,x_{|x|-1}\}$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::member + (Home home, const BoolVarArgs &x, BoolVar y, IntConLevel icl=ICL_DEF) + member + + Home + home + + + const BoolVarArgs & + x + + + BoolVar + y + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $y\in \{x_0,\ldots,x_{|x|-1}\}$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::member + (Home home, const IntVarArgs &x, IntVar y, Reify r, IntConLevel icl=ICL_DEF) + member + + Home + home + + + const IntVarArgs & + x + + + IntVar + y + + + Reify + r + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $\left(y\in \{x_0,\ldots,x_{|x|-1}\}\right)\equiv r$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::member + (Home home, const BoolVarArgs &x, BoolVar y, Reify r, IntConLevel icl=ICL_DEF) + member + + Home + home + + + const BoolVarArgs & + x + + + BoolVar + y + + + Reify + r + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $\left(y\in \{x_0,\ldots,x_{|x|-1}\}\right)\equiv r$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::element + (Home home, IntSharedArray n, IntVar x0, IntVar x1, IntConLevel icl=ICL_DEF) + element + + Home + home + + + IntSharedArray + n + + + IntVar + x0 + + + IntVar + x1 + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $ n_{x_0}=x_1$. + +Throws an exception of type Int::OutOfLimits, if the integers in n exceed the limits in Int::Limits. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::element + (Home home, IntSharedArray n, IntVar x0, BoolVar x1, IntConLevel icl=ICL_DEF) + element + + Home + home + + + IntSharedArray + n + + + IntVar + x0 + + + BoolVar + x1 + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $ n_{x_0}=x_1$. + +Throws an exception of type Int::OutOfLimits, if the integers in n exceed the limits in Int::Limits. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::element + (Home home, IntSharedArray n, IntVar x0, int x1, IntConLevel icl=ICL_DEF) + element + + Home + home + + + IntSharedArray + n + + + IntVar + x0 + + + int + x1 + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $ n_{x_0}=x_1$. + +Throws an exception of type Int::OutOfLimits, if the integers in n exceed the limits in Int::Limits. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::element + (Home home, const IntVarArgs &x, IntVar y0, IntVar y1, IntConLevel icl=ICL_DEF) + element + + Home + home + + + const IntVarArgs & + x + + + IntVar + y0 + + + IntVar + y1 + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $ x_{y_0}=y_1$. + +Supports both bounds (icl = ICL_BND) and domain consistency (icl = ICL_DOM, default). + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::element + (Home home, const IntVarArgs &x, IntVar y0, int y1, IntConLevel icl=ICL_DEF) + element + + Home + home + + + const IntVarArgs & + x + + + IntVar + y0 + + + int + y1 + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $ x_{y_0}=y_1$. + +Supports both bounds (icl = ICL_BND) and domain consistency (icl = ICL_DOM, default). + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::element + (Home home, const BoolVarArgs &x, IntVar y0, BoolVar y1, IntConLevel icl=ICL_DEF) + element + + Home + home + + + const BoolVarArgs & + x + + + IntVar + y0 + + + BoolVar + y1 + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $ x_{y_0}=y_1$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::element + (Home home, const BoolVarArgs &x, IntVar y0, int y1, IntConLevel icl=ICL_DEF) + element + + Home + home + + + const BoolVarArgs & + x + + + IntVar + y0 + + + int + y1 + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $ x_{y_0}=y_1$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::element + (Home home, IntSharedArray a, IntVar x, int w, IntVar y, int h, IntVar z, IntConLevel icl=ICL_DEF) + element + + Home + home + + + IntSharedArray + a + + + IntVar + x + + + int + w + + + IntVar + y + + + int + h + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $ a_{x+w\cdot y}=z$. + +If a is regarded as a two-dimensional array in row-major order of width w and height h, then z is constrained to be the element in column x and row y.Throws an exception of type Int::OutOfLimits, if the integers in n exceed the limits in Int::Limits.Throws an exception of type Int::ArgumentSizeMismatch, if $ w\cdot h\neq|a|$. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::element + (Home home, IntSharedArray a, IntVar x, int w, IntVar y, int h, BoolVar z, IntConLevel icl=ICL_DEF) + element + + Home + home + + + IntSharedArray + a + + + IntVar + x + + + int + w + + + IntVar + y + + + int + h + + + BoolVar + z + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $ a_{x+w\cdot y}=z$. + +If a is regarded as a two-dimensional array in row-major order of width w and height h, then z is constrained to be the element in column x and row y.Throws an exception of type Int::OutOfLimits, if the integers in n exceed the limits in Int::Limits.Throws an exception of type Int::ArgumentSizeMismatch, if $ w\cdot h\neq|a|$. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::element + (Home home, const IntVarArgs &a, IntVar x, int w, IntVar y, int h, IntVar z, IntConLevel icl=ICL_DEF) + element + + Home + home + + + const IntVarArgs & + a + + + IntVar + x + + + int + w + + + IntVar + y + + + int + h + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $ a_{x+w\cdot y}=z$. + +If a is regarded as a two-dimensional array in row-major order of width w and height h, then z is constrained to be the element in column x and row y.Supports both bounds (icl = ICL_BND) and domain consistency (icl = ICL_DOM, default).Throws an exception of type Int::OutOfLimits, if the integers in n exceed the limits in Int::Limits.Throws an exception of type Int::ArgumentSizeMismatch, if $ w\cdot h\neq|a|$. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::element + (Home home, const BoolVarArgs &a, IntVar x, int w, IntVar y, int h, BoolVar z, IntConLevel icl=ICL_DEF) + element + + Home + home + + + const BoolVarArgs & + a + + + IntVar + x + + + int + w + + + IntVar + y + + + int + h + + + BoolVar + z + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $ a_{x+w\cdot y}=z$. + +If a is regarded as a two-dimensional array in row-major order of width w and height h, then z is constrained to be the element in column x and row y.Throws an exception of type Int::OutOfLimits, if the integers in n exceed the limits in Int::Limits.Throws an exception of type Int::ArgumentSizeMismatch, if $ w\cdot h\neq|a|$. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::distinct + (Home home, const IntVarArgs &x, IntConLevel icl=ICL_DEF) + distinct + + Home + home + + + const IntVarArgs & + x + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $ x_i\neq x_j$ for all $0\leq i\neq j<|x|$. + +Supports value (icl = ICL_VAL, default), bounds (icl = ICL_BND), and domain consistency (icl = ICL_DOM).Throws an exception of type Int::ArgumentSame, if x contains the same unassigned variable multiply. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::distinct + (Home home, const IntArgs &n, const IntVarArgs &x, IntConLevel icl=ICL_DEF) + distinct + + Home + home + + + const IntArgs & + n + + + const IntVarArgs & + x + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $ x_i+n_i\neq x_j+n_j$ for all $0\leq i\neq j<|x|$. + + +Supports value (icl = ICL_VAL, default), bounds (icl = ICL_BND), and domain consistency (icl = ICL_DOM). +Throws an exception of type Int::OutOfLimits, if the integers in n exceed the limits in Int::Limits or if the sum of n and x exceed the limits. +Throws an exception of type Int::ArgumentSizeMismatch, if x and n are of different size. +Throws an exception of type Int::ArgumentSame, if x contains the same unassigned variable multiply. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::channel + (Home home, const IntVarArgs &x, const IntVarArgs &y, IntConLevel icl=ICL_DEF) + channel + + Home + home + + + const IntVarArgs & + x + + + const IntVarArgs & + y + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $ x_i = j\leftrightarrow y_j=i$ for all $0\leq i<|x|$. + + +Supports domain consistency (icl = ICL_DOM) and value propagation (all other values for icl, default). +Throws an exception of type Int::ArgumentSizeMismatch, if x and y are of different size. +Throws an exception of type Int::ArgumentSame, if x or y contain the same unassigned variable multiply. Note that a variable can occur in both x and y, but not more than once in either x or y. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::channel + (Home home, const IntVarArgs &x, int xoff, const IntVarArgs &y, int yoff, IntConLevel icl=ICL_DEF) + channel + + Home + home + + + const IntVarArgs & + x + + + int + xoff + + + const IntVarArgs & + y + + + int + yoff + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $ x_i - \mathit{xoff} = j\leftrightarrow y_j - \mathit{yoff} = i$ for all $0\leq i<|x|$. + + +Supports domain consistency (icl = ICL_DOM) and value propagation (all other values for icl, default). +Throws an exception of type Int::ArgumentSizeMismatch, if x and y are of different size. +Throws an exception of type Int::ArgumentSame, if x or y contain the same unassigned variable multiply. Note that a variable can occur in both x and y, but not more than once in either x or y. +Throws an exception of type Int::OutOfLimits, if xoff or yoff are negative. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::channel + (Home home, BoolVar x0, IntVar x1, IntConLevel icl=ICL_DEF) + channel + + Home + home + + + BoolVar + x0 + + + IntVar + x1 + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for channeling a Boolean and an integer variable $ x_0 = x_1$. + + + + + + + + forceinline void + forceinline void Gecode::channel + (Home home, IntVar x0, BoolVar x1, IntConLevel icl=ICL_DEF) + channel + + Home + home + + + IntVar + x0 + + + BoolVar + x1 + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for channeling an integer and a Boolean variable $ x_0 = x_1$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::channel + (Home home, const BoolVarArgs &x, IntVar y, int o=0, IntConLevel icl=ICL_DEF) + channel + + Home + home + + + const BoolVarArgs & + x + + + IntVar + y + + + int + o + 0 + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for channeling Boolean and integer variables $ x_i = 1\leftrightarrow y=i+o$. + +Throws an exception of type Int::ArgumentSame, if x contains the same unassigned variable multiply. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::sorted + (Home home, const IntVarArgs &x, const IntVarArgs &y, IntConLevel icl=ICL_DEF) + sorted + + Home + home + + + const IntVarArgs & + x + + + const IntVarArgs & + y + + + IntConLevel + icl + ICL_DEF + + +Post propagator that y is x sorted in increasing order. + +Might throw the following exceptions: +Int::ArgumentSizeMismatch, if x and y differ in size.Int::ArgumentSame, if x or y contain shared unassigned variables. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::sorted + (Home home, const IntVarArgs &x, const IntVarArgs &y, const IntVarArgs &z, IntConLevel icl=ICL_DEF) + sorted + + Home + home + + + const IntVarArgs & + x + + + const IntVarArgs & + y + + + const IntVarArgs & + z + + + IntConLevel + icl + ICL_DEF + + +Post propagator that y is x sorted in increasing order. + +The values in z describe the sorting permutation, that is $\forall i\in\{0,\dots,|x|-1\}: x_i=y_{z_i} $.Might throw the following exceptions: +Int::ArgumentSizeMismatch, if x and y differ in size.Int::ArgumentSame, if x or y contain shared unassigned variables. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::count + (Home home, const IntVarArgs &x, int n, IntRelType irt, int m, IntConLevel icl=ICL_DEF) + count + + Home + home + + + const IntVarArgs & + x + + + int + n + + + IntRelType + irt + + + int + m + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=n\}\sim_{irt} m$. + +Performs domain propagation but is not domain consistent. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::count + (Home home, const IntVarArgs &x, const IntSet &y, IntRelType irt, int m, IntConLevel icl=ICL_DEF) + count + + Home + home + + + const IntVarArgs & + x + + + const IntSet & + y + + + IntRelType + irt + + + int + m + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i\in y\}\sim_{irt} m$. + +Performs domain propagation but is not domain consistent. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::count + (Home home, const IntVarArgs &x, IntVar y, IntRelType irt, int m, IntConLevel icl=ICL_DEF) + count + + Home + home + + + const IntVarArgs & + x + + + IntVar + y + + + IntRelType + irt + + + int + m + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y\}\sim_{irt} m$. + +Performs domain propagation (icl = ICL_DOM, default) and slightly less domain propagation (all other values for icl), where y is not pruned. Note that in both cases propagation is not comain consistent. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::count + (Home home, const IntVarArgs &x, const IntArgs &y, IntRelType irt, int m, IntConLevel icl=ICL_DEF) + count + + Home + home + + + const IntVarArgs & + x + + + const IntArgs & + y + + + IntRelType + irt + + + int + m + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y_i\}\sim_{irt} m$. + +Performs domain propagation but is not domain consistent.Throws an exception of type Int::ArgumentSizeMismatch, if x and y are of different size. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::count + (Home home, const IntVarArgs &x, int n, IntRelType irt, IntVar z, IntConLevel icl=ICL_DEF) + count + + Home + home + + + const IntVarArgs & + x + + + int + n + + + IntRelType + irt + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=n\}\sim_{irt} z$. + +Performs domain propagation but is not domain consistent. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::count + (Home home, const IntVarArgs &x, const IntSet &y, IntRelType irt, IntVar z, IntConLevel icl=ICL_DEF) + count + + Home + home + + + const IntVarArgs & + x + + + const IntSet & + y + + + IntRelType + irt + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i\in y\}\sim_{irt} z$. + +Performs domain propagation but is not domain consistent. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::count + (Home home, const IntVarArgs &x, IntVar y, IntRelType irt, IntVar z, IntConLevel icl=ICL_DEF) + count + + Home + home + + + const IntVarArgs & + x + + + IntVar + y + + + IntRelType + irt + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y\}\sim_{irt} z$. + +Performs domain propagation (icl = ICL_DOM, default) and slightly less domain propagation (all other values for icl), where y is not pruned. Note that in both cases propagation is not comain consistent. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::count + (Home home, const IntVarArgs &x, const IntArgs &y, IntRelType irt, IntVar z, IntConLevel icl=ICL_DEF) + count + + Home + home + + + const IntVarArgs & + x + + + const IntArgs & + y + + + IntRelType + irt + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y_i\}\sim_{irt} z$. + +Performs domain propagation but is not domain consistent.Throws an exception of type Int::ArgumentSizeMismatch, if x and y are of different size. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::count + (Home home, const IntVarArgs &x, const IntVarArgs &c, IntConLevel icl=ICL_DEF) + count + + Home + home + + + const IntVarArgs & + x + + + const IntVarArgs & + c + + + IntConLevel + icl + ICL_DEF + + +Posts a global count (cardinality) constraint. + +Posts the constraint that $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=j\}=c_j$ and $ \bigcup_i \{x_i\} \subseteq \{0,\ldots,|c|-1\}$ (no other value occurs).Supports value (icl = ICL_VAL, default), bounds (icl = ICL_BND), and domain consistency (icl = ICL_DOM).Throws an exception of type Int::ArgumentSame, if x contains the same unassigned variable multiply. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::count + (Home home, const IntVarArgs &x, const IntSetArgs &c, IntConLevel icl=ICL_DEF) + count + + Home + home + + + const IntVarArgs & + x + + + const IntSetArgs & + c + + + IntConLevel + icl + ICL_DEF + + +Posts a global count (cardinality) constraint. + +Posts the constraint that $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=j\}\in c_j$ and $ \bigcup_i \{x_i\} \subseteq \{0,\ldots,|c|-1\}$ (no other value occurs).Supports value (icl = ICL_VAL, default), bounds (icl = ICL_BND), and domain consistency (icl = ICL_DOM).Throws an exception of type Int::ArgumentSame, if x contains the same unassigned variable multiply. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::count + (Home home, const IntVarArgs &x, const IntVarArgs &c, const IntArgs &v, IntConLevel icl=ICL_DEF) + count + + Home + home + + + const IntVarArgs & + x + + + const IntVarArgs & + c + + + const IntArgs & + v + + + IntConLevel + icl + ICL_DEF + + +Posts a global count (cardinality) constraint. + +Posts the constraint that $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=v_j\}=c_j$ and $ \bigcup_i \{x_i\} \subseteq \bigcup_j \{v_j\}$ (no other value occurs).Supports value (icl = ICL_VAL, default), bounds (icl = ICL_BND), and domain consistency (icl = ICL_DOM).Throws an exception of type Int::ArgumentSame, if x contains the same unassigned variable multiply.Throws an exception of type Int::ArgumentSizeMismatch, if c and v are of different size. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::count + (Home home, const IntVarArgs &x, const IntSetArgs &c, const IntArgs &v, IntConLevel icl=ICL_DEF) + count + + Home + home + + + const IntVarArgs & + x + + + const IntSetArgs & + c + + + const IntArgs & + v + + + IntConLevel + icl + ICL_DEF + + +Posts a global count (cardinality) constraint. + +Posts the constraint that $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=v_j\}\in c_j$ and $ \bigcup_i \{x_i\} \subseteq \bigcup_j \{v_j\}$ (no other value occurs).Supports value (icl = ICL_VAL, default), bounds (icl = ICL_BND), and domain consistency (icl = ICL_DOM).Throws an exception of type Int::ArgumentSame, if x contains the same unassigned variable multiply.Throws an exception of type Int::ArgumentSizeMismatch, if c and v are of different size. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::count + (Home home, const IntVarArgs &x, const IntSet &c, const IntArgs &v, IntConLevel icl=ICL_DEF) + count + + Home + home + + + const IntVarArgs & + x + + + const IntSet & + c + + + const IntArgs & + v + + + IntConLevel + icl + ICL_DEF + + +Posts a global count (cardinality) constraint. + +Posts the constraint that $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=v_j\}\in c$ and $ \bigcup_i \{x_i\} \subseteq \bigcup_j \{v_j\}$ (no other value occurs).Supports value (icl = ICL_VAL, default), bounds (icl = ICL_BND), and domain consistency (icl = ICL_DOM).Throws an exception of type Int::ArgumentSame, if x contains the same unassigned variable multiply.Throws an exception of type Int::ArgumentSizeMismatch, if c and v are of different size. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::nvalues + (Home home, const IntVarArgs &x, IntRelType irt, int y, IntConLevel icl=ICL_DEF) + nvalues + + Home + home + + + const IntVarArgs & + x + + + IntRelType + irt + + + int + y + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\#\{x_0,\ldots,x_{|x|-1}\}\sim_{irt} y$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::nvalues + (Home home, const IntVarArgs &x, IntRelType irt, IntVar y, IntConLevel icl=ICL_DEF) + nvalues + + Home + home + + + const IntVarArgs & + x + + + IntRelType + irt + + + IntVar + y + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\#\{x_0,\ldots,x_{|x|-1}\}\sim_{irt} y$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::nvalues + (Home home, const BoolVarArgs &x, IntRelType irt, int y, IntConLevel icl=ICL_DEF) + nvalues + + Home + home + + + const BoolVarArgs & + x + + + IntRelType + irt + + + int + y + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\#\{x_0,\ldots,x_{|x|-1}\}\sim_{irt} y$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::nvalues + (Home home, const BoolVarArgs &x, IntRelType irt, IntVar y, IntConLevel icl=ICL_DEF) + nvalues + + Home + home + + + const BoolVarArgs & + x + + + IntRelType + irt + + + IntVar + y + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\#\{x_0,\ldots,x_{|x|-1}\}\sim_{irt} y$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::sequence + (Home home, const IntVarArgs &x, const IntSet &s, int q, int l, int u, IntConLevel icl=ICL_DEF) + sequence + + Home + home + + + const IntVarArgs & + x + + + const IntSet & + s + + + int + q + + + int + l + + + int + u + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\operatorname{sequence}(x,s,q,l,u)$. + +Posts a domain consistent propagator for the constraint $\bigwedge_{i=0}^{|x|-q} \operatorname{among}(\langle x_i,\ldots,x_{i+q-1}\rangle,s,l,u)$ where the among constraint is defined as $l\leq\#\{j\in\{i,\ldots,i+q-1\}\;|\;x_j\in s\} \leq u$.Throws the following exceptions: +Of type Int::TooFewArguments, if $|x|=0$.Of type Int::ArgumentSame, if x contains the same unassigned variable multiply.Of type Int::OutOfRange, if $q < 1 \vee q > |x|$. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::sequence + (Home home, const BoolVarArgs &x, const IntSet &s, int q, int l, int u, IntConLevel icl=ICL_DEF) + sequence + + Home + home + + + const BoolVarArgs & + x + + + const IntSet & + s + + + int + q + + + int + l + + + int + u + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\operatorname{sequence}(x,s,q,l,u)$. + +Posts a domain consistent propagator for the constraint $\bigwedge_{i=0}^{|x|-q} \operatorname{among}(\langle x_i,\ldots,x_{i+q-1}\rangle,s,l,u)$ where the among constraint is defined as $l\leq\#\{j\in\{i,\ldots,i+q-1\}\;|\;x_j\in s\} \leq u$.Throws the following exceptions: +Of type Int::TooFewArguments, if $|x|=0$.Of type Int::ArgumentSame, if x contains the same unassigned variable multiply.Of type Int::OutOfRange, if $q < 1 \vee q > |x|$. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::extensional + (Home home, const IntVarArgs &x, DFA d, IntConLevel icl=ICL_DEF) + extensional + + Home + home + + + const IntVarArgs & + x + + + DFA + d + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for extensional constraint described by a DFA. + +The elements of x must be a word of the language described by the DFA d.Throws an exception of type Int::ArgumentSame, if x contains the same unassigned variable multiply. If shared occurences of variables are required, unshare should be used. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::extensional + (Home home, const BoolVarArgs &x, DFA d, IntConLevel icl=ICL_DEF) + extensional + + Home + home + + + const BoolVarArgs & + x + + + DFA + d + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for extensional constraint described by a DFA. + +The elements of x must be a word of the language described by the DFA d.Throws an exception of type Int::ArgumentSame, if x contains the same unassigned variable multiply. If shared occurences of variables are required, unshare should be used. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::extensional + (Home home, const IntVarArgs &x, const TupleSet &t, ExtensionalPropKind epk=EPK_DEF, IntConLevel icl=ICL_DEF) + extensional + + Home + home + + + const IntVarArgs & + x + + + const TupleSet & + t + + + ExtensionalPropKind + epk + EPK_DEF + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $x\in t$. + + +Supports implementations optimized for memory (epk = EPK_MEMORY, default) and speed (epk = EPK_SPEED). +Supports domain consistency (icl = ICL_DOM, default) only. +Throws an exception of type Int::ArgumentSizeMismatch, if x and t are of different size. +Throws an exception of type Int::NotYetFinalized, if the tuple set t has not been finalized. + +If the domains for the $x_i$ are not dense and have similar bounds, lots of memory will be wasted (memory consumption is in $ O\left(|x|\cdot\min_i(\underline{x_i})\cdot\max_i(\overline{x_i})\right)$ for the basic algorithm (epk = EPK_MEMORY) and additionally $ O\left(|x|^2\cdot\min_i(\underline{x_i})\cdot\max_i(\overline{x_i})\right)$ for the incremental algorithm (epk = EPK_SPEED). + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::extensional + (Home home, const BoolVarArgs &x, const TupleSet &t, ExtensionalPropKind epk=EPK_DEF, IntConLevel icl=ICL_DEF) + extensional + + Home + home + + + const BoolVarArgs & + x + + + const TupleSet & + t + + + ExtensionalPropKind + epk + EPK_DEF + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $x\in t$. + + +Supports implementations optimized for memory (epk = EPK_MEMORY, default) and speed (epk = EPK_SPEED). +Supports domain consistency (icl = ICL_DOM, default) only. +Throws an exception of type Int::ArgumentSizeMismatch, if x and t are of different size. +Throws an exception of type Int::NotYetFinalized, if the tuple set t has not been finalized. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::min + (Home home, IntVar x0, IntVar x1, IntVar x2, IntConLevel icl=ICL_DEF) + min + + Home + home + + + IntVar + x0 + + + IntVar + x1 + + + IntVar + x2 + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $ \min\{x_0,x_1\}=x_2$. + +Supports both bounds consistency (icl = ICL_BND, default) and domain consistency (icl = ICL_DOM). + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::min + (Home home, const IntVarArgs &x, IntVar y, IntConLevel icl=ICL_DEF) + min + + Home + home + + + const IntVarArgs & + x + + + IntVar + y + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $ \min x=y$. + +Supports both bounds consistency (icl = ICL_BND, default) and domain consistency (icl = ICL_DOM).If x is empty, an exception of type Int::TooFewArguments is thrown. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::max + (Home home, IntVar x0, IntVar x1, IntVar x2, IntConLevel icl=ICL_DEF) + max + + Home + home + + + IntVar + x0 + + + IntVar + x1 + + + IntVar + x2 + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $ \max\{x_0,x_1\}=x_2$. + +Supports both bounds consistency (icl = ICL_BND, default) and domain consistency (icl = ICL_DOM). + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::max + (Home home, const IntVarArgs &x, IntVar y, IntConLevel icl=ICL_DEF) + max + + Home + home + + + const IntVarArgs & + x + + + IntVar + y + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $ \max x=y$. + +Supports both bounds consistency (icl = ICL_BND, default) and domain consistency (icl = ICL_DOM).If x is empty, an exception of type Int::TooFewArguments is thrown. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::argmin + (Home home, const IntVarArgs &x, IntVar y, bool tiebreak=true, IntConLevel icl=ICL_DEF) + argmin + + Home + home + + + const IntVarArgs & + x + + + IntVar + y + + + bool + tiebreak + true + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $ \operatorname{argmin} x=y$. + +In case of ties, the smallest value for y is chosen (provided tiebreak is true).If x is empty, an exception of type Int::TooFewArguments is thrown. If y occurs in x, an exception of type Int::ArgumentSame is thrown. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::argmax + (Home home, const IntVarArgs &x, IntVar y, bool tiebreak=true, IntConLevel icl=ICL_DEF) + argmax + + Home + home + + + const IntVarArgs & + x + + + IntVar + y + + + bool + tiebreak + true + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $ \operatorname{argmax} x=y$. + +In case of ties, the smallest value for y is chosen (provided tiebreak is true).If x is empty, an exception of type Int::TooFewArguments is thrown. If y occurs in x, an exception of type Int::ArgumentSame is thrown. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::abs + (Home home, IntVar x0, IntVar x1, IntConLevel icl=ICL_DEF) + abs + + Home + home + + + IntVar + x0 + + + IntVar + x1 + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $ |x_0|=x_1$. + +Supports both bounds consistency (icl = ICL_BND, default) and domain consistency (icl = ICL_DOM). + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::mult + (Home home, IntVar x0, IntVar x1, IntVar x2, IntConLevel icl=ICL_DEF) + mult + + Home + home + + + IntVar + x0 + + + IntVar + x1 + + + IntVar + x2 + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $x_0\cdot x_1=x_2$. + +Supports both bounds consistency (icl = ICL_BND, default) and domain consistency (icl = ICL_DOM). + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::divmod + (Home home, IntVar x0, IntVar x1, IntVar x2, IntVar x3, IntConLevel icl=ICL_DEF) + divmod + + Home + home + + + IntVar + x0 + + + IntVar + x1 + + + IntVar + x2 + + + IntVar + x3 + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $x_0\ \mathrm{div}\ x_1=x_2 \land x_0\ \mathrm{mod}\ x_1 = x_3$. + +Supports bounds consistency (icl = ICL_BND, default). + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::div + (Home home, IntVar x0, IntVar x1, IntVar x2, IntConLevel icl=ICL_DEF) + div + + Home + home + + + IntVar + x0 + + + IntVar + x1 + + + IntVar + x2 + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $x_0\ \mathrm{div}\ x_1=x_2$. + +Supports bounds consistency (icl = ICL_BND, default). + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::mod + (Home home, IntVar x0, IntVar x1, IntVar x2, IntConLevel icl=ICL_DEF) + mod + + Home + home + + + IntVar + x0 + + + IntVar + x1 + + + IntVar + x2 + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $x_0\ \mathrm{mod}\ x_1=x_2$. + +Supports bounds consistency (icl = ICL_BND, default). + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::sqr + (Home home, IntVar x0, IntVar x1, IntConLevel icl=ICL_DEF) + sqr + + Home + home + + + IntVar + x0 + + + IntVar + x1 + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $x_0^2=x_1$. + +Supports both bounds consistency (icl = ICL_BND, default) and domain consistency (icl = ICL_DOM). + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::sqrt + (Home home, IntVar x0, IntVar x1, IntConLevel icl=ICL_DEF) + sqrt + + Home + home + + + IntVar + x0 + + + IntVar + x1 + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\lfloor\sqrt{x_0}\rfloor=x_1$. + +Supports both bounds consistency (icl = ICL_BND, default) and domain consistency (icl = ICL_DOM). + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::pow + (Home home, IntVar x0, int n, IntVar x1, IntConLevel icl=ICL_DEF) + pow + + Home + home + + + IntVar + x0 + + + int + n + + + IntVar + x1 + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $x_0^n=x_1$. + +Supports both bounds consistency (icl = ICL_BND, default) and domain consistency (icl = ICL_DOM).Throws an exception of type Int::OutOfLimits, if n is negative. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::nroot + (Home home, IntVar x0, int n, IntVar x1, IntConLevel icl=ICL_DEF) + nroot + + Home + home + + + IntVar + x0 + + + int + n + + + IntVar + x1 + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\lfloor\sqrt[n]{x_0}\rfloor=x_1$. + +Supports both bounds consistency (icl = ICL_BND, default) and domain consistency (icl = ICL_DOM).Throws an exception of type Int::OutOfLimits, if n is not strictly positive. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::linear + (Home home, const IntVarArgs &x, IntRelType irt, int c, IntConLevel icl=ICL_DEF) + linear + + Home + home + + + const IntVarArgs & + x + + + IntRelType + irt + + + int + c + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\sum_{i=0}^{|x|-1}x_i\sim_{irt} c$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::linear + (Home home, const IntVarArgs &x, IntRelType irt, IntVar y, IntConLevel icl=ICL_DEF) + linear + + Home + home + + + const IntVarArgs & + x + + + IntRelType + irt + + + IntVar + y + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\sum_{i=0}^{|x|-1}x_i\sim_{irt} y$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::linear + (Home home, const IntVarArgs &x, IntRelType irt, int c, Reify r, IntConLevel icl=ICL_DEF) + linear + + Home + home + + + const IntVarArgs & + x + + + IntRelType + irt + + + int + c + + + Reify + r + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\left(\sum_{i=0}^{|x|-1}x_i\sim_{irt} c\right)\equiv r$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::linear + (Home home, const IntVarArgs &x, IntRelType irt, IntVar y, Reify r, IntConLevel icl=ICL_DEF) + linear + + Home + home + + + const IntVarArgs & + x + + + IntRelType + irt + + + IntVar + y + + + Reify + r + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\left(\sum_{i=0}^{|x|-1}x_i\sim_{irt} y\right)\equiv r$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::linear + (Home home, const IntArgs &a, const IntVarArgs &x, IntRelType irt, int c, IntConLevel icl=ICL_DEF) + linear + + Home + home + + + const IntArgs & + a + + + const IntVarArgs & + x + + + IntRelType + irt + + + int + c + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\sum_{i=0}^{|x|-1}a_i\cdot x_i\sim_{irt} c$. + +Throws an exception of type Int::ArgumentSizeMismatch, if a and x are of different size. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::linear + (Home home, const IntArgs &a, const IntVarArgs &x, IntRelType irt, IntVar y, IntConLevel icl=ICL_DEF) + linear + + Home + home + + + const IntArgs & + a + + + const IntVarArgs & + x + + + IntRelType + irt + + + IntVar + y + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\sum_{i=0}^{|x|-1}a_i\cdot x_i\sim_{irt} y$. + +Throws an exception of type Int::ArgumentSizeMismatch, if a and x are of different size. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::linear + (Home home, const IntArgs &a, const IntVarArgs &x, IntRelType irt, int c, Reify r, IntConLevel icl=ICL_DEF) + linear + + Home + home + + + const IntArgs & + a + + + const IntVarArgs & + x + + + IntRelType + irt + + + int + c + + + Reify + r + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\left(\sum_{i=0}^{|x|-1}a_i\cdot x_i\sim_{irt} c\right)\equiv r$. + +Throws an exception of type Int::ArgumentSizeMismatch, if a and x are of different size. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::linear + (Home home, const IntArgs &a, const IntVarArgs &x, IntRelType irt, IntVar y, Reify r, IntConLevel icl=ICL_DEF) + linear + + Home + home + + + const IntArgs & + a + + + const IntVarArgs & + x + + + IntRelType + irt + + + IntVar + y + + + Reify + r + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\left(\sum_{i=0}^{|x|-1}a_i\cdot x_i\sim_{irt} y\right)\equiv r$. + +Throws an exception of type Int::ArgumentSizeMismatch, if a and x are of different size. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::linear + (Home home, const BoolVarArgs &x, IntRelType irt, int c, IntConLevel icl=ICL_DEF) + linear + + Home + home + + + const BoolVarArgs & + x + + + IntRelType + irt + + + int + c + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\sum_{i=0}^{|x|-1}x_i\sim_{irt} c$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::linear + (Home home, const BoolVarArgs &x, IntRelType irt, int c, Reify r, IntConLevel icl=ICL_DEF) + linear + + Home + home + + + const BoolVarArgs & + x + + + IntRelType + irt + + + int + c + + + Reify + r + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\left(\sum_{i=0}^{|x|-1}x_i\sim_{irt} c\right)\equiv r$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::linear + (Home home, const BoolVarArgs &x, IntRelType irt, IntVar y, IntConLevel icl=ICL_DEF) + linear + + Home + home + + + const BoolVarArgs & + x + + + IntRelType + irt + + + IntVar + y + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\sum_{i=0}^{|x|-1}x_i\sim_{irt} y$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::linear + (Home home, const BoolVarArgs &x, IntRelType irt, IntVar y, Reify r, IntConLevel icl=ICL_DEF) + linear + + Home + home + + + const BoolVarArgs & + x + + + IntRelType + irt + + + IntVar + y + + + Reify + r + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\left(\sum_{i=0}^{|x|-1}x_i\sim_{irt} y\right)\equiv r$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::linear + (Home home, const IntArgs &a, const BoolVarArgs &x, IntRelType irt, int c, IntConLevel icl=ICL_DEF) + linear + + Home + home + + + const IntArgs & + a + + + const BoolVarArgs & + x + + + IntRelType + irt + + + int + c + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\sum_{i=0}^{|x|-1}a_i\cdot x_i\sim_{irt} c$. + +Throws an exception of type Int::ArgumentSizeMismatch, if a and x are of different size. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::linear + (Home home, const IntArgs &a, const BoolVarArgs &x, IntRelType irt, int c, Reify r, IntConLevel icl=ICL_DEF) + linear + + Home + home + + + const IntArgs & + a + + + const BoolVarArgs & + x + + + IntRelType + irt + + + int + c + + + Reify + r + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\left(\sum_{i=0}^{|x|-1}a_i\cdot x_i\sim_{irt} c\right)\equiv r$. + +Throws an exception of type Int::ArgumentSizeMismatch, if a and x are of different size. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::linear + (Home home, const IntArgs &a, const BoolVarArgs &x, IntRelType irt, IntVar y, IntConLevel icl=ICL_DEF) + linear + + Home + home + + + const IntArgs & + a + + + const BoolVarArgs & + x + + + IntRelType + irt + + + IntVar + y + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\sum_{i=0}^{|x|-1}a_i\cdot x_i\sim_{irt} y$. + +Throws an exception of type Int::ArgumentSizeMismatch, if a and x are of different size. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::linear + (Home home, const IntArgs &a, const BoolVarArgs &x, IntRelType irt, IntVar y, Reify r, IntConLevel icl=ICL_DEF) + linear + + Home + home + + + const IntArgs & + a + + + const BoolVarArgs & + x + + + IntRelType + irt + + + IntVar + y + + + Reify + r + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\left(\sum_{i=0}^{|x|-1}a_i\cdot x_i\sim_{irt} y\right)\equiv r$. + +Throws an exception of type Int::ArgumentSizeMismatch, if a and x are of different size. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::binpacking + (Home home, const IntVarArgs &l, const IntVarArgs &b, const IntArgs &s, IntConLevel icl=ICL_DEF) + binpacking + + Home + home + + + const IntVarArgs & + l + + + const IntVarArgs & + b + + + const IntArgs & + s + + + IntConLevel + icl + ICL_DEF + + +Post propagator for bin packing. + +The variables in l are the loads for each bin, whereas the variables in b define for each item into which bin it is packed. The integer values s define the size of the items.It is propagated that for each $j$ with $0\leq j<|l|$ the constraint $l_j=\sum_{0\leq i<|b|\wedge b_i=j}s_i$ holds and that for each $i$ with $0\leq i<|b|$ the constraint $0\leq b_i<|l|$ holds.The propagation follows: Paul Shaw. A Constraint for Bin Packing. CP 2004.Throws the following exceptions: +Of type Int::ArgumentSizeMismatch if b and s are not of the same size.Of type Int::ArgumentSame if l and b share unassigned variables.Of type Int::OutOfLimits if s contains a negative number. + + + + + + + GECODE_INT_EXPORT IntSet + GECODE_INT_EXPORT IntSet Gecode::binpacking + (Home home, int d, const IntVarArgs &l, const IntVarArgs &b, const IntArgs &s, const IntArgs &c, IntConLevel icl=ICL_DEF) + binpacking + + Home + home + + + int + d + + + const IntVarArgs & + l + + + const IntVarArgs & + b + + + const IntArgs & + s + + + const IntArgs & + c + + + IntConLevel + icl + ICL_DEF + + + + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::nooverlap + (Home home, const IntVarArgs &x, const IntArgs &w, const IntVarArgs &y, const IntArgs &h, IntConLevel icl=ICL_DEF) + nooverlap + + Home + home + + + const IntVarArgs & + x + + + const IntArgs & + w + + + const IntVarArgs & + y + + + const IntArgs & + h + + + IntConLevel + icl + ICL_DEF + + +Post propagator for rectangle packing. + +Propagate that no two rectangles as described by the coordinates x, and y, widths w, and heights h overlap.Throws the following exceptions: +Of type Int::ArgumentSizeMismatch if x, w, y, or h are not of the same size.Of type Int::OutOfLimits if w or h contain a negative number. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::nooverlap + (Home home, const IntVarArgs &x, const IntArgs &w, const IntVarArgs &y, const IntArgs &h, const BoolVarArgs &o, IntConLevel icl=ICL_DEF) + nooverlap + + Home + home + + + const IntVarArgs & + x + + + const IntArgs & + w + + + const IntVarArgs & + y + + + const IntArgs & + h + + + const BoolVarArgs & + o + + + IntConLevel + icl + ICL_DEF + + +Post propagator for rectangle packing. + +Propagate that no two rectangles as described by the coordinates x, and y, widths w, and heights h overlap. The rectangles can be optional, as described by the Boolean variables o.Throws the following exceptions: +Of type Int::ArgumentSizeMismatch if x, w, y, h, or o are not of the same size.Of type Int::OutOfLimits if w or h contain a negative number. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::nooverlap + (Home home, const IntVarArgs &x0, const IntVarArgs &w, const IntVarArgs &x1, const IntVarArgs &y0, const IntVarArgs &h, const IntVarArgs &y1, IntConLevel icl=ICL_DEF) + nooverlap + + Home + home + + + const IntVarArgs & + x0 + + + const IntVarArgs & + w + + + const IntVarArgs & + x1 + + + const IntVarArgs & + y0 + + + const IntVarArgs & + h + + + const IntVarArgs & + y1 + + + IntConLevel + icl + ICL_DEF + + +Post propagator for rectangle packing. + +Propagate that no two rectangles as described by the start coordinates x0 and y0, widths w and heights h, and end coordinates x1 and y1 overlap.Note that the relations $x0_i+w_i=x1_i$ and $y0_i+h_i=y1_i$ are not propagated (for $0\leq i<|x0|$). That is, additional constraints must be posted to enforce that relation.Throws the following exceptions: +Of type Int::ArgumentSizeMismatch if x0, x1, w, y0, y1, or h are not of the same size. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::nooverlap + (Home home, const IntVarArgs &x0, const IntVarArgs &w, const IntVarArgs &x1, const IntVarArgs &y0, const IntVarArgs &h, const IntVarArgs &y1, const BoolVarArgs &o, IntConLevel icl=ICL_DEF) + nooverlap + + Home + home + + + const IntVarArgs & + x0 + + + const IntVarArgs & + w + + + const IntVarArgs & + x1 + + + const IntVarArgs & + y0 + + + const IntVarArgs & + h + + + const IntVarArgs & + y1 + + + const BoolVarArgs & + o + + + IntConLevel + icl + ICL_DEF + + +Post propagator for rectangle packing. + +Propagate that no two rectangles as described by the start coordinates x0 and y0, widths w and heights h, and end coordinates x1 and y1 overlap. The rectangles can be optional, as described by the Boolean variables o.Note that the relations $x0_i+w_i=x1_i$ and $y0_i+h_i=y1_i$ are not propagated (for $0\leq i<|x0|$). That is, additional constraints must be posted to enforce that relation.Throws the following exceptions: +Of type Int::ArgumentSizeMismatch if x0, x1, w, y0, y1, or h are not of the same size. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulatives + (Home home, const IntVarArgs &m, const IntVarArgs &s, const IntVarArgs &p, const IntVarArgs &e, const IntVarArgs &u, const IntArgs &c, bool at_most, IntConLevel icl=ICL_DEF) + cumulatives + + Home + home + + + const IntVarArgs & + m + + + const IntVarArgs & + s + + + const IntVarArgs & + p + + + const IntVarArgs & + e + + + const IntVarArgs & + u + + + const IntArgs & + c + + + bool + at_most + + + IntConLevel + icl + ICL_DEF + + +Post propagators for the cumulatives constraint. + +This function creates propagators for the cumulatives constraint presented in "A new multi-resource cumulatives constraint +with negative heights", Nicolas Beldiceanu and Mats Carlsson, Principles and Practice of Constraint Programming 2002.The constraint models a set of machines and a set of tasks that should be assigned to the machines. The machines have a positive resource limit and the tasks each have a resource usage that can be either positive, negative, or zero. The constraint is enforced over each point in time for a machine where there is at least one task assigned.The propagator does not enforce $s_i+p_i=e_i$, this constraint has to be posted in addition to ensure consistency of the task bounds.The limit for a machine is either the maximum amount available at any given time (at_most = true), or else the least amount to be used (at_most = false). + +home + + +current space + + + +m + + +$ m_i $ is the machine assigned to task $ i $ + + + +s + + +$ s_i $ is the start time assigned to task $ i $ + + + +p + + +$ p_i $ is the processing time of task $ i $ + + + +e + + +$ e_i $ is the end time assigned to task $ i $ + + + +u + + +$ u_i $ is the amount of resources consumed by task $ i $ + + + +c + + +$ c_r $ is the capacity, the amount of resource available for machine $ r $ + + + +at_most + + +at_most tells if the amount of resources used for a machine should be less than the limit (at_most = true) or greater than the limit (at_most = false) + + + +icl + + +Supports value-consistency only (icl = ICL_VAL, default). + + + + +Int::ArgumentSizeMismatch + + +thrown if the sizes of the arguments representing tasks does not match. + + + +Int::OutOfLimits + + +thrown if any numerical argument is larger than Int::Limits::max or less than Int::Limits::min. + + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulatives + (Home home, const IntArgs &m, const IntVarArgs &s, const IntVarArgs &p, const IntVarArgs &e, const IntVarArgs &u, const IntArgs &c, bool at_most, IntConLevel icl=ICL_DEF) + cumulatives + + Home + home + + + const IntArgs & + m + + + const IntVarArgs & + s + + + const IntVarArgs & + p + + + const IntVarArgs & + e + + + const IntVarArgs & + u + + + const IntArgs & + c + + + bool + at_most + + + IntConLevel + icl + ICL_DEF + + +Post propagators for the cumulatives constraint. + +Post propagators for the cumulatives constraint. This function creates propagators for the cumulatives constraint presented in "A new multi-resource cumulatives constraint +with negative heights", Nicolas Beldiceanu and Mats Carlsson, Principles and Practice of Constraint Programming 2002.The constraint models a set of machines and a set of tasks that should be assigned to the machines. The machines have a positive resource limit and the tasks each have a resource usage that can be either positive, negative, or zero. The constraint is enforced over each point in time for a machine where there is at least one task assigned.The propagator does not enforce $s_i+p_i=e_i$, this constraint has to be posted in addition to ensure consistency of the task bounds.The limit for a machine is either the maximum amount available at any given time (at_most = true), or else the least amount to be used (at_most = false). + +home + + +current space + + + +m + + +$ m_i $ is the machine assigned to task $ i $ + + + +s + + +$ s_i $ is the start time assigned to task $ i $ + + + +p + + +$ p_i $ is the processing time of task $ i $ + + + +e + + +$ e_i $ is the end time assigned to task $ i $ + + + +u + + +$ u_i $ is the amount of resources consumed by task $ i $ + + + +c + + +$ c_r $ is the capacity, the amount of resource available for machine $ r $ + + + +at_most + + +at_most tells if the amount of resources used for a machine should be less than the limit (at_most = true) or greater than the limit (at_most = false) + + + +icl + + +Supports value-consistency only (icl = ICL_VAL, default). + + + + +Int::ArgumentSizeMismatch + + +thrown if the sizes of the arguments representing tasks does not match. + + + +Int::OutOfLimits + + +thrown if any numerical argument is larger than Int::Limits::max or less than Int::Limits::min. + + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulatives + (Home home, const IntVarArgs &m, const IntVarArgs &s, const IntArgs &p, const IntVarArgs &e, const IntVarArgs &u, const IntArgs &c, bool at_most, IntConLevel icl=ICL_DEF) + cumulatives + + Home + home + + + const IntVarArgs & + m + + + const IntVarArgs & + s + + + const IntArgs & + p + + + const IntVarArgs & + e + + + const IntVarArgs & + u + + + const IntArgs & + c + + + bool + at_most + + + IntConLevel + icl + ICL_DEF + + +Post propagators for the cumulatives constraint. + +Post propagators for the cumulatives constraint. This function creates propagators for the cumulatives constraint presented in "A new multi-resource cumulatives constraint +with negative heights", Nicolas Beldiceanu and Mats Carlsson, Principles and Practice of Constraint Programming 2002.The constraint models a set of machines and a set of tasks that should be assigned to the machines. The machines have a positive resource limit and the tasks each have a resource usage that can be either positive, negative, or zero. The constraint is enforced over each point in time for a machine where there is at least one task assigned.The propagator does not enforce $s_i+p_i=e_i$, this constraint has to be posted in addition to ensure consistency of the task bounds.The limit for a machine is either the maximum amount available at any given time (at_most = true), or else the least amount to be used (at_most = false). + +home + + +current space + + + +m + + +$ m_i $ is the machine assigned to task $ i $ + + + +s + + +$ s_i $ is the start time assigned to task $ i $ + + + +p + + +$ p_i $ is the processing time of task $ i $ + + + +e + + +$ e_i $ is the end time assigned to task $ i $ + + + +u + + +$ u_i $ is the amount of resources consumed by task $ i $ + + + +c + + +$ c_r $ is the capacity, the amount of resource available for machine $ r $ + + + +at_most + + +at_most tells if the amount of resources used for a machine should be less than the limit (at_most = true) or greater than the limit (at_most = false) + + + +icl + + +Supports value-consistency only (icl = ICL_VAL, default). + + + + +Int::ArgumentSizeMismatch + + +thrown if the sizes of the arguments representing tasks does not match. + + + +Int::OutOfLimits + + +thrown if any numerical argument is larger than Int::Limits::max or less than Int::Limits::min. + + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulatives + (Home home, const IntArgs &m, const IntVarArgs &s, const IntArgs &p, const IntVarArgs &e, const IntVarArgs &u, const IntArgs &c, bool at_most, IntConLevel icl=ICL_DEF) + cumulatives + + Home + home + + + const IntArgs & + m + + + const IntVarArgs & + s + + + const IntArgs & + p + + + const IntVarArgs & + e + + + const IntVarArgs & + u + + + const IntArgs & + c + + + bool + at_most + + + IntConLevel + icl + ICL_DEF + + +Post propagators for the cumulatives constraint. + +Post propagators for the cumulatives constraint. This function creates propagators for the cumulatives constraint presented in "A new multi-resource cumulatives constraint +with negative heights", Nicolas Beldiceanu and Mats Carlsson, Principles and Practice of Constraint Programming 2002.The constraint models a set of machines and a set of tasks that should be assigned to the machines. The machines have a positive resource limit and the tasks each have a resource usage that can be either positive, negative, or zero. The constraint is enforced over each point in time for a machine where there is at least one task assigned.The propagator does not enforce $s_i+p_i=e_i$, this constraint has to be posted in addition to ensure consistency of the task bounds.The limit for a machine is either the maximum amount available at any given time (at_most = true), or else the least amount to be used (at_most = false). + +home + + +current space + + + +m + + +$ m_i $ is the machine assigned to task $ i $ + + + +s + + +$ s_i $ is the start time assigned to task $ i $ + + + +p + + +$ p_i $ is the processing time of task $ i $ + + + +e + + +$ e_i $ is the end time assigned to task $ i $ + + + +u + + +$ u_i $ is the amount of resources consumed by task $ i $ + + + +c + + +$ c_r $ is the capacity, the amount of resource available for machine $ r $ + + + +at_most + + +at_most tells if the amount of resources used for a machine should be less than the limit (at_most = true) or greater than the limit (at_most = false) + + + +icl + + +Supports value-consistency only (icl = ICL_VAL, default). + + + + +Int::ArgumentSizeMismatch + + +thrown if the sizes of the arguments representing tasks does not match. + + + +Int::OutOfLimits + + +thrown if any numerical argument is larger than Int::Limits::max or less than Int::Limits::min. + + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulatives + (Home home, const IntVarArgs &m, const IntVarArgs &s, const IntVarArgs &p, const IntVarArgs &e, const IntArgs &u, const IntArgs &c, bool at_most, IntConLevel icl=ICL_DEF) + cumulatives + + Home + home + + + const IntVarArgs & + m + + + const IntVarArgs & + s + + + const IntVarArgs & + p + + + const IntVarArgs & + e + + + const IntArgs & + u + + + const IntArgs & + c + + + bool + at_most + + + IntConLevel + icl + ICL_DEF + + +Post propagators for the cumulatives constraint. + +Post propagators for the cumulatives constraint. This function creates propagators for the cumulatives constraint presented in "A new multi-resource cumulatives constraint +with negative heights", Nicolas Beldiceanu and Mats Carlsson, Principles and Practice of Constraint Programming 2002.The constraint models a set of machines and a set of tasks that should be assigned to the machines. The machines have a positive resource limit and the tasks each have a resource usage that can be either positive, negative, or zero. The constraint is enforced over each point in time for a machine where there is at least one task assigned.The propagator does not enforce $s_i+p_i=e_i$, this constraint has to be posted in addition to ensure consistency of the task bounds.The limit for a machine is either the maximum amount available at any given time (at_most = true), or else the least amount to be used (at_most = false). + +home + + +current space + + + +m + + +$ m_i $ is the machine assigned to task $ i $ + + + +s + + +$ s_i $ is the start time assigned to task $ i $ + + + +p + + +$ p_i $ is the processing time of task $ i $ + + + +e + + +$ e_i $ is the end time assigned to task $ i $ + + + +u + + +$ u_i $ is the amount of resources consumed by task $ i $ + + + +c + + +$ c_r $ is the capacity, the amount of resource available for machine $ r $ + + + +at_most + + +at_most tells if the amount of resources used for a machine should be less than the limit (at_most = true) or greater than the limit (at_most = false) + + + +icl + + +Supports value-consistency only (icl = ICL_VAL, default). + + + + +Int::ArgumentSizeMismatch + + +thrown if the sizes of the arguments representing tasks does not match. + + + +Int::OutOfLimits + + +thrown if any numerical argument is larger than Int::Limits::max or less than Int::Limits::min. + + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulatives + (Home home, const IntArgs &m, const IntVarArgs &s, const IntVarArgs &p, const IntVarArgs &e, const IntArgs &u, const IntArgs &c, bool at_most, IntConLevel icl=ICL_DEF) + cumulatives + + Home + home + + + const IntArgs & + m + + + const IntVarArgs & + s + + + const IntVarArgs & + p + + + const IntVarArgs & + e + + + const IntArgs & + u + + + const IntArgs & + c + + + bool + at_most + + + IntConLevel + icl + ICL_DEF + + +Post propagators for the cumulatives constraint. + +Post propagators for the cumulatives constraint. This function creates propagators for the cumulatives constraint presented in "A new multi-resource cumulatives constraint +with negative heights", Nicolas Beldiceanu and Mats Carlsson, Principles and Practice of Constraint Programming 2002.The constraint models a set of machines and a set of tasks that should be assigned to the machines. The machines have a positive resource limit and the tasks each have a resource usage that can be either positive, negative, or zero. The constraint is enforced over each point in time for a machine where there is at least one task assigned.The propagator does not enforce $s_i+p_i=e_i$, this constraint has to be posted in addition to ensure consistency of the task bounds.The limit for a machine is either the maximum amount available at any given time (at_most = true), or else the least amount to be used (at_most = false). + +home + + +current space + + + +m + + +$ m_i $ is the machine assigned to task $ i $ + + + +s + + +$ s_i $ is the start time assigned to task $ i $ + + + +p + + +$ p_i $ is the processing time of task $ i $ + + + +e + + +$ e_i $ is the end time assigned to task $ i $ + + + +u + + +$ u_i $ is the amount of resources consumed by task $ i $ + + + +c + + +$ c_r $ is the capacity, the amount of resource available for machine $ r $ + + + +at_most + + +at_most tells if the amount of resources used for a machine should be less than the limit (at_most = true) or greater than the limit (at_most = false) + + + +icl + + +Supports value-consistency only (icl = ICL_VAL, default). + + + + +Int::ArgumentSizeMismatch + + +thrown if the sizes of the arguments representing tasks does not match. + + + +Int::OutOfLimits + + +thrown if any numerical argument is larger than Int::Limits::max or less than Int::Limits::min. + + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulatives + (Home home, const IntVarArgs &m, const IntVarArgs &s, const IntArgs &p, const IntVarArgs &e, const IntArgs &u, const IntArgs &c, bool at_most, IntConLevel icl=ICL_DEF) + cumulatives + + Home + home + + + const IntVarArgs & + m + + + const IntVarArgs & + s + + + const IntArgs & + p + + + const IntVarArgs & + e + + + const IntArgs & + u + + + const IntArgs & + c + + + bool + at_most + + + IntConLevel + icl + ICL_DEF + + +Post propagators for the cumulatives constraint. + +Post propagators for the cumulatives constraint. This function creates propagators for the cumulatives constraint presented in "A new multi-resource cumulatives constraint +with negative heights", Nicolas Beldiceanu and Mats Carlsson, Principles and Practice of Constraint Programming 2002.The constraint models a set of machines and a set of tasks that should be assigned to the machines. The machines have a positive resource limit and the tasks each have a resource usage that can be either positive, negative, or zero. The constraint is enforced over each point in time for a machine where there is at least one task assigned.The propagator does not enforce $s_i+p_i=e_i$, this constraint has to be posted in addition to ensure consistency of the task bounds.The limit for a machine is either the maximum amount available at any given time (at_most = true), or else the least amount to be used (at_most = false). + +home + + +current space + + + +m + + +$ m_i $ is the machine assigned to task $ i $ + + + +s + + +$ s_i $ is the start time assigned to task $ i $ + + + +p + + +$ p_i $ is the processing time of task $ i $ + + + +e + + +$ e_i $ is the end time assigned to task $ i $ + + + +u + + +$ u_i $ is the amount of resources consumed by task $ i $ + + + +c + + +$ c_r $ is the capacity, the amount of resource available for machine $ r $ + + + +at_most + + +at_most tells if the amount of resources used for a machine should be less than the limit (at_most = true) or greater than the limit (at_most = false) + + + +icl + + +Supports value-consistency only (icl = ICL_VAL, default). + + + + +Int::ArgumentSizeMismatch + + +thrown if the sizes of the arguments representing tasks does not match. + + + +Int::OutOfLimits + + +thrown if any numerical argument is larger than Int::Limits::max or less than Int::Limits::min. + + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulatives + (Home home, const IntArgs &m, const IntVarArgs &s, const IntArgs &p, const IntVarArgs &e, const IntArgs &u, const IntArgs &c, bool at_most, IntConLevel icl=ICL_DEF) + cumulatives + + Home + home + + + const IntArgs & + m + + + const IntVarArgs & + s + + + const IntArgs & + p + + + const IntVarArgs & + e + + + const IntArgs & + u + + + const IntArgs & + c + + + bool + at_most + + + IntConLevel + icl + ICL_DEF + + +Post propagators for the cumulatives constraint. + +Post propagators for the cumulatives constraint. This function creates propagators for the cumulatives constraint presented in "A new multi-resource cumulatives constraint +with negative heights", Nicolas Beldiceanu and Mats Carlsson, Principles and Practice of Constraint Programming 2002.The constraint models a set of machines and a set of tasks that should be assigned to the machines. The machines have a positive resource limit and the tasks each have a resource usage that can be either positive, negative, or zero. The constraint is enforced over each point in time for a machine where there is at least one task assigned.The propagator does not enforce $s_i+p_i=e_i$, this constraint has to be posted in addition to ensure consistency of the task bounds.The limit for a machine is either the maximum amount available at any given time (at_most = true), or else the least amount to be used (at_most = false). + +home + + +current space + + + +m + + +$ m_i $ is the machine assigned to task $ i $ + + + +s + + +$ s_i $ is the start time assigned to task $ i $ + + + +p + + +$ p_i $ is the processing time of task $ i $ + + + +e + + +$ e_i $ is the end time assigned to task $ i $ + + + +u + + +$ u_i $ is the amount of resources consumed by task $ i $ + + + +c + + +$ c_r $ is the capacity, the amount of resource available for machine $ r $ + + + +at_most + + +at_most tells if the amount of resources used for a machine should be less than the limit (at_most = true) or greater than the limit (at_most = false) + + + +icl + + +Supports value-consistency only (icl = ICL_VAL, default). + + + + +Int::ArgumentSizeMismatch + + +thrown if the sizes of the arguments representing tasks does not match. + + + +Int::OutOfLimits + + +thrown if any numerical argument is larger than Int::Limits::max or less than Int::Limits::min. + + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::unary + (Home home, const IntVarArgs &s, const IntArgs &p, IntConLevel icl=ICL_DEF) + unary + + Home + home + + + const IntVarArgs & + s + + + const IntArgs & + p + + + IntConLevel + icl + ICL_DEF + + +Post propagators for scheduling tasks on unary resources. + +Schedule tasks with start times s and processing times p on a unary resource. The propagator uses the algorithms from: Petr Vilím, Global Constraints in Scheduling, PhD thesis, Charles University, Prague, Czech Republic, 2007.The propagator performs overload checking, detectable precendence propagation, not-first-not-last propagation, and edge finding. +Throws an exception of type Int::ArgumentSizeMismatch, if s and p are of different size.Throws an exception of type Int::ArgumentSame, if s contains the same unassigned variable multiply.Throws an exception of type Int::OutOfLimits, if p contains an integer that is negative or that could generate an overflow. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::unary + (Home home, const IntVarArgs &s, const IntArgs &p, const BoolVarArgs &m, IntConLevel icl=ICL_DEF) + unary + + Home + home + + + const IntVarArgs & + s + + + const IntArgs & + p + + + const BoolVarArgs & + m + + + IntConLevel + icl + ICL_DEF + + +Post propagators for scheduling optional tasks on unary resources. + +Schedule optional tasks with start times s, processing times p, and whether a task is mandatory m (a task is mandatory if the Boolean variable is 1) on a unary resource. The propagator uses the algorithms from: Petr Vilím, Global Constraints in Scheduling, PhD thesis, Charles University, Prague, Czech Republic, 2007.The propagator performs overload checking, detectable precendence propagation, not-first-not-last propagation, and edge finding. +Throws an exception of type Int::ArgumentSizeMismatch, if s, p, or m are of different size.Throws an exception of type Int::ArgumentSame, if s contains the same unassigned variable multiply.Throws an exception of type Int::OutOfLimits, if p contains an integer that is negative or that could generate an overflow. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::unary + (Home home, const TaskTypeArgs &t, const IntVarArgs &flex, const IntArgs &fix, IntConLevel icl=ICL_DEF) + unary + + Home + home + + + const TaskTypeArgs & + t + + + const IntVarArgs & + flex + + + const IntArgs & + fix + + + IntConLevel + icl + ICL_DEF + + +Post propagators for scheduling tasks on unary resources. + +Schedule tasks with flexible times flex and fixed times fix on a unary resource. For each task, it depends on t how the flexible and fix times are interpreted: +If t[i] is TT_FIXP, then flex[i] is the start time and fix[i] is the processing time.If t[i] is TT_FIXS, then flex[i] is the end time and fix[i] is the start time.If t[i] is TT_FIXE, then flex[i] is the start time and fix[i] is the end time. +The propagator uses the algorithms from: Petr Vilím, Global Constraints in Scheduling, PhD thesis, Charles University, Prague, Czech Republic, 2007.The propagator performs overload checking, detectable precendence propagation, not-first-not-last propagation, and edge finding. +Throws an exception of type Int::ArgumentSizeMismatch, if s and p are of different size.Throws an exception of type Int::OutOfLimits, if p contains an integer that is negative for a task with type TT_FIXP or that could generate an overflow. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::unary + (Home home, const TaskTypeArgs &t, const IntVarArgs &flex, const IntArgs &fix, const BoolVarArgs &m, IntConLevel icl=ICL_DEF) + unary + + Home + home + + + const TaskTypeArgs & + t + + + const IntVarArgs & + flex + + + const IntArgs & + fix + + + const BoolVarArgs & + m + + + IntConLevel + icl + ICL_DEF + + +Post propagators for scheduling optional tasks on unary resources. + +Schedule optional tasks with flexible times flex, fixed times fix, and whether a task is mandatory m (a task is mandatory if the Boolean variable is 1) on a unary resource. For each task, it depends on t how the flexible and fix times are interpreted: +If t[i] is TT_FIXP, then flex[i] is the start time and fix[i] is the processing time.If t[i] is TT_FIXS, then flex[i] is the end time and fix[i] is the start time.If t[i] is TT_FIXE, then flex[i] is the start time and fix[i] is the end time. +The propagator uses the algorithms from: Petr Vilím, Global Constraints in Scheduling, PhD thesis, Charles University, Prague, Czech Republic, 2007.The propagator performs overload checking, detectable precendence propagation, not-first-not-last propagation, and edge finding. +Throws an exception of type Int::ArgumentSizeMismatch, if s, p, or m are of different size.Throws an exception of type Int::OutOfLimits, if p contains an integer that is negative for a task with type TT_FIXP or that could generate an overflow. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::unary + (Home home, const IntVarArgs &s, const IntVarArgs &p, const IntVarArgs &e, IntConLevel icl=ICL_DEF) + unary + + Home + home + + + const IntVarArgs & + s + + + const IntVarArgs & + p + + + const IntVarArgs & + e + + + IntConLevel + icl + ICL_DEF + + +Post propagators for scheduling tasks on unary resources. + +Schedule tasks with start times s, processing times p, and end times e on a unary resource. The propagator uses the algorithms from: Petr Vilím, Global Constraints in Scheduling, PhD thesis, Charles University, Prague, Czech Republic, 2007.The propagator does not enforce $s_i+p_i=e_i$, this constraint has to be posted in addition to ensure consistency of the task bounds.The propagator performs overload checking, detectable precendence propagation, not-first-not-last propagation, and edge finding.The processing times are constrained to be non-negative.Throws an exception of type Int::ArgumentSizeMismatch, if s and p are of different size. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::unary + (Home home, const IntVarArgs &s, const IntVarArgs &p, const IntVarArgs &e, const BoolVarArgs &m, IntConLevel icl=ICL_DEF) + unary + + Home + home + + + const IntVarArgs & + s + + + const IntVarArgs & + p + + + const IntVarArgs & + e + + + const BoolVarArgs & + m + + + IntConLevel + icl + ICL_DEF + + +Post propagators for scheduling optional tasks on unary resources. + +Schedule optional tasks with start times s, processing times p, end times e, and whether a task is mandatory m (a task is mandatory if the Boolean variable is 1) on a unary resource. The propagator uses the algorithms from: Petr Vilím, Global Constraints in Scheduling, PhD thesis, Charles University, Prague, Czech Republic, 2007.The propagator does not enforce $s_i+p_i=e_i$, this constraint has to be posted in addition to ensure consistency of the task bounds.The processing times are constrained to be non-negative.The propagator performs overload checking, detectable precendence propagation, not-first-not-last propagation, and edge finding.Throws an exception of type Int::ArgumentSizeMismatch, if s, p, or m are of different size. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulative + (Home home, int c, const TaskTypeArgs &t, const IntVarArgs &flex, const IntArgs &fix, const IntArgs &u, IntConLevel icl=ICL_DEF) + cumulative + + Home + home + + + int + c + + + const TaskTypeArgs & + t + + + const IntVarArgs & + flex + + + const IntArgs & + fix + + + const IntArgs & + u + + + IntConLevel + icl + ICL_DEF + + +Post propagators for scheduling tasks on cumulative resources. + +Schedule tasks with flexible times flex, fixed times fix, and use capacity u on a cumulative resource with capacity c. For each task, it depends on t how the flexible and fix times are interpreted: +If t[i] is TT_FIXP, then flex[i] is the start time and fix[i] is the processing time.If t[i] is TT_FIXS, then flex[i] is the end time and fix[i] is the start time.If t[i] is TT_FIXE, then flex[i] is the start time and fix[i] is the end time. +The propagator performs time-tabling, overload checking, and edge-finding. It uses algorithms taken from:Petr Vilím, Max Energy Filtering Algorithm for Discrete Cumulative Resources, in W. J. van Hoeve and J. N. Hooker, editors, CPAIOR, volume 5547 of LNCS, pages 294-308. Springer, 2009.andPetr Vilím, Edge finding filtering algorithm for discrete cumulative resources in O(kn log n). In I. P. Gent, editor, CP, volume 5732 of LNCS, pages 802-816. Springer, 2009. +Throws an exception of type Int::ArgumentSizeMismatch, if t, s p, or u are of different size.Throws an exception of type Int::OutOfLimits, if p, u, or c contain an integer that is not nonnegative, or that could generate an overflow. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulative + (Home home, IntVar c, const TaskTypeArgs &t, const IntVarArgs &flex, const IntArgs &fix, const IntArgs &u, IntConLevel icl=ICL_DEF) + cumulative + + Home + home + + + IntVar + c + + + const TaskTypeArgs & + t + + + const IntVarArgs & + flex + + + const IntArgs & + fix + + + const IntArgs & + u + + + IntConLevel + icl + ICL_DEF + + +Post propagators for scheduling tasks on cumulative resources. + +Post propagators for scheduling tasks on cumulative resources. Schedule tasks with flexible times flex, fixed times fix, and use capacity u on a cumulative resource with capacity c. For each task, it depends on t how the flexible and fix times are interpreted: +If t[i] is TT_FIXP, then flex[i] is the start time and fix[i] is the processing time.If t[i] is TT_FIXS, then flex[i] is the end time and fix[i] is the start time.If t[i] is TT_FIXE, then flex[i] is the start time and fix[i] is the end time. +The propagator performs time-tabling, overload checking, and edge-finding. It uses algorithms taken from:Petr Vilím, Max Energy Filtering Algorithm for Discrete Cumulative Resources, in W. J. van Hoeve and J. N. Hooker, editors, CPAIOR, volume 5547 of LNCS, pages 294-308. Springer, 2009.andPetr Vilím, Edge finding filtering algorithm for discrete cumulative resources in O(kn log n). In I. P. Gent, editor, CP, volume 5732 of LNCS, pages 802-816. Springer, 2009. +Throws an exception of type Int::ArgumentSizeMismatch, if t, s p, or u are of different size.Throws an exception of type Int::OutOfLimits, if p, u, or c contain an integer that is not nonnegative, or that could generate an overflow. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulative + (Home home, int c, const TaskTypeArgs &t, const IntVarArgs &flex, const IntArgs &fix, const IntArgs &u, const BoolVarArgs &m, IntConLevel icl=ICL_DEF) + cumulative + + Home + home + + + int + c + + + const TaskTypeArgs & + t + + + const IntVarArgs & + flex + + + const IntArgs & + fix + + + const IntArgs & + u + + + const BoolVarArgs & + m + + + IntConLevel + icl + ICL_DEF + + +Post propagators for scheduling optional tasks on cumulative resources. + +Schedule tasks with flexible times flex, fixed times fix, use capacity u, and whether a task is mandatory m (a task is mandatory if the Boolean variable is 1) on a cumulative resource with capacity c. For each task, it depends on t how the flexible and fix times are interpreted: +If t[i] is TT_FIXP, then flex[i] is the start time and fix[i] is the processing time.If t[i] is TT_FIXS, then flex[i] is the end time and fix[i] is the start time.If t[i] is TT_FIXE, then flex[i] is the start time and fix[i] is the end time. +The propagator performs time-tabling, overload checking, and edge-finding. It uses algorithms taken from:Petr Vilím, Max Energy Filtering Algorithm for Discrete Cumulative Resources, in W. J. van Hoeve and J. N. Hooker, editors, CPAIOR, volume 5547 of LNCS, pages 294-308. Springer, 2009.andPetr Vilím, Edge finding filtering algorithm for discrete cumulative resources in O(kn log n). In I. P. Gent, editor, CP, volume 5732 of LNCS, pages 802-816. Springer, 2009. +Throws an exception of type Int::ArgumentSizeMismatch, if t, s p, or u are of different size.Throws an exception of type Int::OutOfLimits, if p, u, or c contain an integer that is not nonnegative, or that could generate an overflow. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulative + (Home home, IntVar c, const TaskTypeArgs &t, const IntVarArgs &flex, const IntArgs &fix, const IntArgs &u, const BoolVarArgs &m, IntConLevel icl=ICL_DEF) + cumulative + + Home + home + + + IntVar + c + + + const TaskTypeArgs & + t + + + const IntVarArgs & + flex + + + const IntArgs & + fix + + + const IntArgs & + u + + + const BoolVarArgs & + m + + + IntConLevel + icl + ICL_DEF + + +Post propagators for scheduling optional tasks on cumulative resources. + +Post propagators for scheduling optional tasks on cumulative resources. Schedule tasks with flexible times flex, fixed times fix, use capacity u, and whether a task is mandatory m (a task is mandatory if the Boolean variable is 1) on a cumulative resource with capacity c. For each task, it depends on t how the flexible and fix times are interpreted: +If t[i] is TT_FIXP, then flex[i] is the start time and fix[i] is the processing time.If t[i] is TT_FIXS, then flex[i] is the end time and fix[i] is the start time.If t[i] is TT_FIXE, then flex[i] is the start time and fix[i] is the end time. +The propagator performs time-tabling, overload checking, and edge-finding. It uses algorithms taken from:Petr Vilím, Max Energy Filtering Algorithm for Discrete Cumulative Resources, in W. J. van Hoeve and J. N. Hooker, editors, CPAIOR, volume 5547 of LNCS, pages 294-308. Springer, 2009.andPetr Vilím, Edge finding filtering algorithm for discrete cumulative resources in O(kn log n). In I. P. Gent, editor, CP, volume 5732 of LNCS, pages 802-816. Springer, 2009. +Throws an exception of type Int::ArgumentSizeMismatch, if t, s p, or u are of different size.Throws an exception of type Int::OutOfLimits, if p, u, or c contain an integer that is not nonnegative, or that could generate an overflow. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulative + (Home home, int c, const IntVarArgs &s, const IntArgs &p, const IntArgs &u, IntConLevel icl=ICL_DEF) + cumulative + + Home + home + + + int + c + + + const IntVarArgs & + s + + + const IntArgs & + p + + + const IntArgs & + u + + + IntConLevel + icl + ICL_DEF + + +Post propagators for scheduling tasks on cumulative resources. + +Schedule tasks with start times s, processing times p, and use capacity u on a cumulative resource with capacity c.The propagator performs time-tabling, overload checking, and edge-finding. It uses algorithms taken from:Petr Vilím, Max Energy Filtering Algorithm for Discrete Cumulative Resources, in W. J. van Hoeve and J. N. Hooker, editors, CPAIOR, volume 5547 of LNCS, pages 294-308. Springer, 2009.andPetr Vilím, Edge finding filtering algorithm for discrete cumulative resources in O(kn log n). In I. P. Gent, editor, CP, volume 5732 of LNCS, pages 802-816. Springer, 2009. +Throws an exception of type Int::ArgumentSizeMismatch, if s p, or u are of different size.Throws an exception of type Int::OutOfLimits, if p, u, or c contain an integer that is not nonnegative, or that could generate an overflow. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulative + (Home home, IntVar c, const IntVarArgs &s, const IntArgs &p, const IntArgs &u, IntConLevel icl=ICL_DEF) + cumulative + + Home + home + + + IntVar + c + + + const IntVarArgs & + s + + + const IntArgs & + p + + + const IntArgs & + u + + + IntConLevel + icl + ICL_DEF + + +Post propagators for scheduling tasks on cumulative resources. + +Post propagators for scheduling tasks on cumulative resources. Schedule tasks with start times s, processing times p, and use capacity u on a cumulative resource with capacity c.The propagator performs time-tabling, overload checking, and edge-finding. It uses algorithms taken from:Petr Vilím, Max Energy Filtering Algorithm for Discrete Cumulative Resources, in W. J. van Hoeve and J. N. Hooker, editors, CPAIOR, volume 5547 of LNCS, pages 294-308. Springer, 2009.andPetr Vilím, Edge finding filtering algorithm for discrete cumulative resources in O(kn log n). In I. P. Gent, editor, CP, volume 5732 of LNCS, pages 802-816. Springer, 2009. +Throws an exception of type Int::ArgumentSizeMismatch, if s p, or u are of different size.Throws an exception of type Int::OutOfLimits, if p, u, or c contain an integer that is not nonnegative, or that could generate an overflow. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulative + (Home home, int c, const IntVarArgs &s, const IntArgs &p, const IntArgs &u, const BoolVarArgs &m, IntConLevel icl=ICL_DEF) + cumulative + + Home + home + + + int + c + + + const IntVarArgs & + s + + + const IntArgs & + p + + + const IntArgs & + u + + + const BoolVarArgs & + m + + + IntConLevel + icl + ICL_DEF + + +Post propagators for scheduling optional tasks on cumulative resources. + +Schedule optional tasks with start times s, processing times p, used capacity u, and whether a task is mandatory m (a task is mandatory if the Boolean variable is 1) on a cumulative resource with capacity c.The propagator performs time-tabling, overload checking, and edge-finding. It uses algorithms taken from:Petr Vilím, Max Energy Filtering Algorithm for Discrete Cumulative Resources, in W. J. van Hoeve and J. N. Hooker, editors, CPAIOR, volume 5547 of LNCS, pages 294-308. Springer, 2009.andPetr Vilím, Edge finding filtering algorithm for discrete cumulative resources in O(kn log n). In I. P. Gent, editor, CP, volume 5732 of LNCS, pages 802-816. Springer, 2009. +Throws an exception of type Int::ArgumentSizeMismatch, if s, p, u, or m are of different size.Throws an exception of type Int::OutOfLimits, if p, u, or c contain an integer that is not nonnegative, or that could generate an overflow. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulative + (Home home, IntVar c, const IntVarArgs &s, const IntArgs &p, const IntArgs &u, const BoolVarArgs &m, IntConLevel icl=ICL_DEF) + cumulative + + Home + home + + + IntVar + c + + + const IntVarArgs & + s + + + const IntArgs & + p + + + const IntArgs & + u + + + const BoolVarArgs & + m + + + IntConLevel + icl + ICL_DEF + + +Post propagators for scheduling optional tasks on cumulative resources. + +Post propagators for scheduling optional tasks on cumulative resources. Schedule optional tasks with start times s, processing times p, used capacity u, and whether a task is mandatory m (a task is mandatory if the Boolean variable is 1) on a cumulative resource with capacity c.The propagator performs time-tabling, overload checking, and edge-finding. It uses algorithms taken from:Petr Vilím, Max Energy Filtering Algorithm for Discrete Cumulative Resources, in W. J. van Hoeve and J. N. Hooker, editors, CPAIOR, volume 5547 of LNCS, pages 294-308. Springer, 2009.andPetr Vilím, Edge finding filtering algorithm for discrete cumulative resources in O(kn log n). In I. P. Gent, editor, CP, volume 5732 of LNCS, pages 802-816. Springer, 2009. +Throws an exception of type Int::ArgumentSizeMismatch, if s, p, u, or m are of different size.Throws an exception of type Int::OutOfLimits, if p, u, or c contain an integer that is not nonnegative, or that could generate an overflow. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulative + (Home home, int c, const IntVarArgs &s, const IntVarArgs &p, const IntVarArgs &e, const IntArgs &u, IntConLevel icl=ICL_DEF) + cumulative + + Home + home + + + int + c + + + const IntVarArgs & + s + + + const IntVarArgs & + p + + + const IntVarArgs & + e + + + const IntArgs & + u + + + IntConLevel + icl + ICL_DEF + + +Post propagators for scheduling tasks on cumulative resources. + +Schedule tasks with start times s, processing times p, end times e, and use capacity u on a cumulative resource with capacity c.The propagator does not enforce $s_i+p_i=e_i$, this constraint has to be posted in addition to ensure consistency of the task bounds.The propagator performs time-tabling, overload checking, and edge-finding. It uses algorithms taken from:Petr Vilím, Max Energy Filtering Algorithm for Discrete Cumulative Resources, in W. J. van Hoeve and J. N. Hooker, editors, CPAIOR, volume 5547 of LNCS, pages 294-308. Springer, 2009.andPetr Vilím, Edge finding filtering algorithm for discrete cumulative resources in O(kn log n). In I. P. Gent, editor, CP, volume 5732 of LNCS, pages 802-816. Springer, 2009. +Throws an exception of type Int::ArgumentSizeMismatch, if s p, or u are of different size.Throws an exception of type Int::OutOfLimits, if u or c contain an integer that is not nonnegative, or that could generate an overflow. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulative + (Home home, IntVar c, const IntVarArgs &s, const IntVarArgs &p, const IntVarArgs &e, const IntArgs &u, IntConLevel icl=ICL_DEF) + cumulative + + Home + home + + + IntVar + c + + + const IntVarArgs & + s + + + const IntVarArgs & + p + + + const IntVarArgs & + e + + + const IntArgs & + u + + + IntConLevel + icl + ICL_DEF + + +Post propagators for scheduling tasks on cumulative resources. + +Post propagators for scheduling tasks on cumulative resources. Schedule tasks with start times s, processing times p, end times e, and use capacity u on a cumulative resource with capacity c.The propagator does not enforce $s_i+p_i=e_i$, this constraint has to be posted in addition to ensure consistency of the task bounds.The propagator performs time-tabling, overload checking, and edge-finding. It uses algorithms taken from:Petr Vilím, Max Energy Filtering Algorithm for Discrete Cumulative Resources, in W. J. van Hoeve and J. N. Hooker, editors, CPAIOR, volume 5547 of LNCS, pages 294-308. Springer, 2009.andPetr Vilím, Edge finding filtering algorithm for discrete cumulative resources in O(kn log n). In I. P. Gent, editor, CP, volume 5732 of LNCS, pages 802-816. Springer, 2009. +Throws an exception of type Int::ArgumentSizeMismatch, if s p, or u are of different size.Throws an exception of type Int::OutOfLimits, if u or c contain an integer that is not nonnegative, or that could generate an overflow. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulative + (Home home, int c, const IntVarArgs &s, const IntVarArgs &p, const IntVarArgs &e, const IntArgs &u, const BoolVarArgs &m, IntConLevel icl=ICL_DEF) + cumulative + + Home + home + + + int + c + + + const IntVarArgs & + s + + + const IntVarArgs & + p + + + const IntVarArgs & + e + + + const IntArgs & + u + + + const BoolVarArgs & + m + + + IntConLevel + icl + ICL_DEF + + +Post propagators for scheduling optional tasks on cumulative resources. + +Schedule optional tasks with start times s, processing times p, end times e, used capacity u, and whether a task is mandatory m (a task is mandatory if the Boolean variable is 1) on a cumulative resource with capacity c.The propagator does not enforce $s_i+p_i=e_i$, this constraint has to be posted in addition to ensure consistency of the task bounds.The propagator performs time-tabling, overload checking, and edge-finding. It uses algorithms taken from:Petr Vilím, Max Energy Filtering Algorithm for Discrete Cumulative Resources, in W. J. van Hoeve and J. N. Hooker, editors, CPAIOR, volume 5547 of LNCS, pages 294-308. Springer, 2009.andPetr Vilím, Edge finding filtering algorithm for discrete cumulative resources in O(kn log n). In I. P. Gent, editor, CP, volume 5732 of LNCS, pages 802-816. Springer, 2009. +Throws an exception of type Int::ArgumentSizeMismatch, if s, p, u, or m are of different size.Throws an exception of type Int::OutOfLimits, if u or c contain an integer that is not nonnegative, or that could generate an overflow. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulative + (Home home, IntVar c, const IntVarArgs &s, const IntVarArgs &p, const IntVarArgs &e, const IntArgs &u, const BoolVarArgs &m, IntConLevel icl=ICL_DEF) + cumulative + + Home + home + + + IntVar + c + + + const IntVarArgs & + s + + + const IntVarArgs & + p + + + const IntVarArgs & + e + + + const IntArgs & + u + + + const BoolVarArgs & + m + + + IntConLevel + icl + ICL_DEF + + +Post propagators for scheduling optional tasks on cumulative resources. + +Post propagators for scheduling optional tasks on cumulative resources. Schedule optional tasks with start times s, processing times p, end times e, used capacity u, and whether a task is mandatory m (a task is mandatory if the Boolean variable is 1) on a cumulative resource with capacity c.The propagator does not enforce $s_i+p_i=e_i$, this constraint has to be posted in addition to ensure consistency of the task bounds.The propagator performs time-tabling, overload checking, and edge-finding. It uses algorithms taken from:Petr Vilím, Max Energy Filtering Algorithm for Discrete Cumulative Resources, in W. J. van Hoeve and J. N. Hooker, editors, CPAIOR, volume 5547 of LNCS, pages 294-308. Springer, 2009.andPetr Vilím, Edge finding filtering algorithm for discrete cumulative resources in O(kn log n). In I. P. Gent, editor, CP, volume 5732 of LNCS, pages 802-816. Springer, 2009. +Throws an exception of type Int::ArgumentSizeMismatch, if s, p, u, or m are of different size.Throws an exception of type Int::OutOfLimits, if u or c contain an integer that is not nonnegative, or that could generate an overflow. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::circuit + (Home home, const IntVarArgs &x, IntConLevel icl=ICL_DEF) + circuit + + Home + home + + + const IntVarArgs & + x + + + IntConLevel + icl + ICL_DEF + + +Post propagator such that x forms a circuit. + +x forms a circuit if the graph with edges $i\to j$ where $x_i=j$ has a single cycle covering all nodes.Supports domain (icl = ICL_DOM) and value propagation (all other values for icl), where this refers to whether value or domain consistent distinct in enforced on x.Throws the following exceptions: +Int::ArgumentSame, if x contains the same unassigned variable multiply.Int::TooFewArguments, if x has no elements. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::circuit + (Home home, int offset, const IntVarArgs &x, IntConLevel icl=ICL_DEF) + circuit + + Home + home + + + int + offset + + + const IntVarArgs & + x + + + IntConLevel + icl + ICL_DEF + + +Post propagator such that x forms a circuit. + +x forms a circuit if the graph with edges $i\to j$ where $x_{i-\text{offset}}=j$ has a single cycle covering all nodes.Supports domain (icl = ICL_DOM) and value propagation (all other values for icl), where this refers to whether value or domain consistent distinct in enforced on x.Throws the following exceptions: +Int::ArgumentSame, if x contains the same unassigned variable multiply.Int::TooFewArguments, if x has no elements.Int::OutOfLimits, if offset is negative. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::circuit + (Home home, const IntArgs &c, const IntVarArgs &x, const IntVarArgs &y, IntVar z, IntConLevel icl=ICL_DEF) + circuit + + Home + home + + + const IntArgs & + c + + + const IntVarArgs & + x + + + const IntVarArgs & + y + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post propagator such that x forms a circuit with costs y and z. + +x forms a circuit if the graph with edges $i\to j$ where $x_i=j$ has a single cycle covering all nodes. The integer array c gives the costs of all possible edges where $c_{i*|x|+j}$ is the cost of the edge $i\to j$. The variable z is the cost of the entire circuit. The variables y define the cost of the edge in x: that is, if $x_i=j$ then $y_i=c_{i*n+j}$.Supports domain (icl = ICL_DOM) and value propagation (all other values for icl), where this refers to whether value or domain consistent distinct in enforced on x for circuit.Throws the following exceptions: +Int::ArgumentSame, if x contains the same unassigned variable multiply.Int::TooFewArguments, if x has no elements.Int::ArgumentSizeMismacth, if x and y do not have the same size or if $|x|\times|x|\neq|c|$. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::circuit + (Home home, const IntArgs &c, int offset, const IntVarArgs &x, const IntVarArgs &y, IntVar z, IntConLevel icl=ICL_DEF) + circuit + + Home + home + + + const IntArgs & + c + + + int + offset + + + const IntVarArgs & + x + + + const IntVarArgs & + y + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post propagator such that x forms a circuit with costs y and z. + +x forms a circuit if the graph with edges $i\to j$ where $x_{i-\text{offset}}=j$ has a single cycle covering all nodes. The integer array c gives the costs of all possible edges where $c_{i*|x|+j}$ is the cost of the edge $i\to j$. The variable z is the cost of the entire circuit. The variables y define the cost of the edge in x: that is, if $x_i=j$ then $y_i=c_{i*n+j}$.Supports domain (icl = ICL_DOM) and value propagation (all other values for icl), where this refers to whether value or domain consistent distinct in enforced on x for circuit.Throws the following exceptions: +Int::ArgumentSame, if x contains the same unassigned variable multiply.Int::TooFewArguments, if x has no elements.Int::ArgumentSizeMismacth, if x and y do not have the same size or if $|x|\times|x|\neq|c|$.Int::OutOfLimits, if offset is negative. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::circuit + (Home home, const IntArgs &c, const IntVarArgs &x, IntVar z, IntConLevel icl=ICL_DEF) + circuit + + Home + home + + + const IntArgs & + c + + + const IntVarArgs & + x + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post propagator such that x forms a circuit with cost z. + +x forms a circuit if the graph with edges $i\to j$ where $x_i=j$ has a single cycle covering all nodes. The integer array c gives the costs of all possible edges where $c_{i*|x|+j}$ is the cost of the edge $i\to j$. The variable z is the cost of the entire circuit.Supports domain (icl = ICL_DOM) and value propagation (all other values for icl), where this refers to whether value or domain consistent distinct in enforced on x for circuit.Throws the following exceptions: +Int::ArgumentSame, if x contains the same unassigned variable multiply.Int::TooFewArguments, if x has no elements.Int::ArgumentSizeMismacth, if $|x|\times|x|\neq|c|$. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::circuit + (Home home, const IntArgs &c, int offset, const IntVarArgs &x, IntVar z, IntConLevel icl=ICL_DEF) + circuit + + Home + home + + + const IntArgs & + c + + + int + offset + + + const IntVarArgs & + x + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post propagator such that x forms a circuit with cost z. + +x forms a circuit if the graph with edges $i\to j$ where $x_{i-\text{offset}}=j$ has a single cycle covering all nodes. The integer array c gives the costs of all possible edges where $c_{i*|x|+j}$ is the cost of the edge $i\to j$. The variable z is the cost of the entire circuit.Supports domain (icl = ICL_DOM) and value propagation (all other values for icl), where this refers to whether value or domain consistent distinct in enforced on x for circuit.Throws the following exceptions: +Int::ArgumentSame, if x contains the same unassigned variable multiply.Int::TooFewArguments, if x has no elements.Int::ArgumentSizeMismacth, if $|x|\times|x|\neq|c|$.Int::OutOfLimits, if offset is negative. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::path + (Home home, const IntVarArgs &x, IntVar s, IntVar e, IntConLevel icl=ICL_DEF) + path + + Home + home + + + const IntVarArgs & + x + + + IntVar + s + + + IntVar + e + + + IntConLevel + icl + ICL_DEF + + +Post propagator such that x forms a Hamiltonian path. + +x forms a Hamiltonian path if the graph with edges $i\to j$ where $x_i=j$ visits all nodes exactly once. The path starts at node s and the successor of the last node e is equal to $|x|$.Supports domain (icl = ICL_DOM) and value propagation (all other values for icl), where this refers to whether value or domain consistent distinct in enforced on x.Throws the following exceptions: +Int::ArgumentSame, if x contains the same unassigned variable multiply.Int::TooFewArguments, if x has no elements. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::path + (Home home, int offset, const IntVarArgs &x, IntVar s, IntVar e, IntConLevel icl=ICL_DEF) + path + + Home + home + + + int + offset + + + const IntVarArgs & + x + + + IntVar + s + + + IntVar + e + + + IntConLevel + icl + ICL_DEF + + +Post propagator such that x forms a Hamiltonian path. + +x forms a Hamiltonian path if the graph with edges $i\to j$ where $x_{i-\text{offset}}=j$ visits all nodes exactly once. The path starts at node s and the successor of the last node e is equal to $|x|+\text{offset}$.Supports domain (icl = ICL_DOM) and value propagation (all other values for icl), where this refers to whether value or domain consistent distinct in enforced on x.Throws the following exceptions: +Int::ArgumentSame, if x contains the same unassigned variable multiply.Int::TooFewArguments, if x has no elements.Int::OutOfLimits, if offset is negative. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::path + (Home home, const IntArgs &c, const IntVarArgs &x, IntVar s, IntVar e, const IntVarArgs &y, IntVar z, IntConLevel icl=ICL_DEF) + path + + Home + home + + + const IntArgs & + c + + + const IntVarArgs & + x + + + IntVar + s + + + IntVar + e + + + const IntVarArgs & + y + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post propagator such that x forms a Hamiltonian path with costs y and z. + +x forms a Hamiltonian path if the graph with edges $i\to j$ where $x_i=j$ visits all nodes exactly once. The path starts at node s and the successor of the last node e is equal to $|x|$. The integer array c gives the costs of all possible edges where $c_{i*|x|+j}$ is the cost of the edge $i\to j$. The variable z is the cost of the entire path. The variables y define the cost of the edge in x: that is, if $x_i=j$ then $y_i=c_{i*n+j}$.Supports domain (icl = ICL_DOM) and value propagation (all other values for icl), where this refers to whether value or domain consistent distinct in enforced on x for circuit.Throws the following exceptions: +Int::ArgumentSame, if x contains the same unassigned variable multiply.Int::TooFewArguments, if x has no elements.Int::ArgumentSizeMismacth, if x and y do not have the same size or if $|x|\times|x|\neq|c|$. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::path + (Home home, const IntArgs &c, int offset, const IntVarArgs &x, IntVar s, IntVar e, const IntVarArgs &y, IntVar z, IntConLevel icl=ICL_DEF) + path + + Home + home + + + const IntArgs & + c + + + int + offset + + + const IntVarArgs & + x + + + IntVar + s + + + IntVar + e + + + const IntVarArgs & + y + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post propagator such that x forms a Hamiltonian path with costs y and z. + +x forms a Hamiltonian path if the graph with edges $i\to j$ where $x_{i-\text{offset}}=j$ visits all nodes exactly once. The path starts at node s and the successor of the last node e is equal to $|x|+\text{offset}$. The integer array c gives the costs of all possible edges where $c_{i*|x|+j}$ is the cost of the edge $i\to j$. The variable z is the cost of the entire path. The variables y define the cost of the edge in x: that is, if $x_i=j$ then $y_i=c_{i*n+j}$.Supports domain (icl = ICL_DOM) and value propagation (all other values for icl), where this refers to whether value or domain consistent distinct in enforced on x for circuit.Throws the following exceptions: +Int::ArgumentSame, if x contains the same unassigned variable multiply.Int::TooFewArguments, if x has no elements.Int::ArgumentSizeMismacth, if x and y do not have the same size or if $|x|\times|x|\neq|c|$.Int::OutOfLimits, if offset is negative. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::path + (Home home, const IntArgs &c, const IntVarArgs &x, IntVar s, IntVar e, IntVar z, IntConLevel icl=ICL_DEF) + path + + Home + home + + + const IntArgs & + c + + + const IntVarArgs & + x + + + IntVar + s + + + IntVar + e + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post propagator such that x forms a Hamiltonian path with cost z. + +x forms a Hamiltonian path if the graph with edges $i\to j$ where $x_i=j$ visits all nodes exactly once. The path starts at node s and the successor of the last node e is equal to $|x|$. The integer array c gives the costs of all possible edges where $c_{i*|x|+j}$ is the cost of the edge $i\to j$. The variable z is the cost of the entire path.Supports domain (icl = ICL_DOM) and value propagation (all other values for icl), where this refers to whether value or domain consistent distinct in enforced on x for circuit.Throws the following exceptions: +Int::ArgumentSame, if x contains the same unassigned variable multiply.Int::TooFewArguments, if x has no elements.Int::ArgumentSizeMismacth, if $|x|\times|x|\neq|c|$. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::path + (Home home, const IntArgs &c, int offset, const IntVarArgs &x, IntVar s, IntVar e, IntVar z, IntConLevel icl=ICL_DEF) + path + + Home + home + + + const IntArgs & + c + + + int + offset + + + const IntVarArgs & + x + + + IntVar + s + + + IntVar + e + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post propagator such that x forms a Hamiltonian path with cost z. + +x forms a Hamiltonian path if the graph with edges $i\to j$ where $x_{i-\text{offset}}=j$ visits all nodes exactly once. The path starts at node s and the successor of the last node e is equal to $|x|+\text{offset}$. The integer array c gives the costs of all possible edges where $c_{i*|x|+j}$ is the cost of the edge $i\to j$. The variable z is the cost of the entire circuit.Supports domain (icl = ICL_DOM) and value propagation (all other values for icl), where this refers to whether value or domain consistent distinct in enforced on x for circuit.Throws the following exceptions: +Int::ArgumentSame, if x contains the same unassigned variable multiply.Int::TooFewArguments, if x has no elements.Int::ArgumentSizeMismacth, if $|x|\times|x|\neq|c|$.Int::OutOfLimits, if offset is negative. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::wait + (Home home, IntVar x, void(*c)(Space &home), IntConLevel icl=ICL_DEF) + wait + + Home + home + + + IntVar + x + + + void(*)(Space &home) + c + + + IntConLevel + icl + ICL_DEF + + +Execute c when x becomes assigned. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::wait + (Home home, BoolVar x, void(*c)(Space &home), IntConLevel icl=ICL_DEF) + wait + + Home + home + + + BoolVar + x + + + void(*)(Space &home) + c + + + IntConLevel + icl + ICL_DEF + + +Execute c when x becomes assigned. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::wait + (Home home, const IntVarArgs &x, void(*c)(Space &home), IntConLevel icl=ICL_DEF) + wait + + Home + home + + + const IntVarArgs & + x + + + void(*)(Space &home) + c + + + IntConLevel + icl + ICL_DEF + + +Execute c when all variables in x become assigned. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::wait + (Home home, const BoolVarArgs &x, void(*c)(Space &home), IntConLevel icl=ICL_DEF) + wait + + Home + home + + + const BoolVarArgs & + x + + + void(*)(Space &home) + c + + + IntConLevel + icl + ICL_DEF + + +Execute c when all variables in x become assigned. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::when + (Home home, BoolVar x, void(*t)(Space &home), void(*e)(Space &home)=NULL, IntConLevel icl=ICL_DEF) + when + + Home + home + + + BoolVar + x + + + void(*)(Space &home) + t + + + void(*)(Space &home) + e + NULL + + + IntConLevel + icl + ICL_DEF + + +Execute t (then) when x is assigned one, and e (else) otherwise. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::unshare + (Home home, IntVarArgs &x, IntConLevel icl=ICL_DEF) + unshare + + Home + home + + + IntVarArgs & + x + + + IntConLevel + icl + ICL_DEF + + +Replace multiple variable occurences in x by fresh variables. + +Supports domain consistency (icl = ICL_DOM, default) and bounds consistency (icl = ICL_BND). + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::unshare + (Home home, BoolVarArgs &x, IntConLevel icl=ICL_DEF) + unshare + + Home + home + + + BoolVarArgs & + x + + + IntConLevel + icl + ICL_DEF + + +Replace multiple variable occurences in x by fresh variables. + + + + + + + + GECODE_INT_EXPORT BrancherHandle + GECODE_INT_EXPORT BrancherHandle Gecode::branch + (Home home, const IntVarArgs &x, IntVarBranch vars, IntValBranch vals, IntBranchFilter bf=NULL, IntVarValPrint vvp=NULL) + branch + + Home + home + + + const IntVarArgs & + x + + + IntVarBranch + vars + + + IntValBranch + vals + + + IntBranchFilter + bf + NULL + + + IntVarValPrint + vvp + NULL + + +Branch over x with variable selection vars and value selection vals. + + + + + + + + GECODE_INT_EXPORT BrancherHandle + GECODE_INT_EXPORT BrancherHandle Gecode::branch + (Home home, const IntVarArgs &x, TieBreak< IntVarBranch > vars, IntValBranch vals, IntBranchFilter bf=NULL, IntVarValPrint vvp=NULL) + branch + + Home + home + + + const IntVarArgs & + x + + + TieBreak< IntVarBranch > + vars + + + IntValBranch + vals + + + IntBranchFilter + bf + NULL + + + IntVarValPrint + vvp + NULL + + +Branch over x with tie-breaking variable selection vars and value selection vals. + + + + + + + + GECODE_INT_EXPORT BrancherHandle + GECODE_INT_EXPORT BrancherHandle Gecode::branch + (Home home, IntVar x, IntValBranch vals, IntVarValPrint vvp=NULL) + branch + + Home + home + + + IntVar + x + + + IntValBranch + vals + + + IntVarValPrint + vvp + NULL + + +Branch over x with value selection vals. + + + + + + + + GECODE_INT_EXPORT BrancherHandle + GECODE_INT_EXPORT BrancherHandle Gecode::branch + (Home home, const BoolVarArgs &x, IntVarBranch vars, IntValBranch vals, BoolBranchFilter bf=NULL, BoolVarValPrint vvp=NULL) + branch + + Home + home + + + const BoolVarArgs & + x + + + IntVarBranch + vars + + + IntValBranch + vals + + + BoolBranchFilter + bf + NULL + + + BoolVarValPrint + vvp + NULL + + +Branch over x with variable selection vars and value selection vals. + + + + + + + + GECODE_INT_EXPORT BrancherHandle + GECODE_INT_EXPORT BrancherHandle Gecode::branch + (Home home, const BoolVarArgs &x, TieBreak< IntVarBranch > vars, IntValBranch vals, BoolBranchFilter bf=NULL, BoolVarValPrint vvp=NULL) + branch + + Home + home + + + const BoolVarArgs & + x + + + TieBreak< IntVarBranch > + vars + + + IntValBranch + vals + + + BoolBranchFilter + bf + NULL + + + BoolVarValPrint + vvp + NULL + + +Branch over x with tie-breaking variable selection vars and value selection vals. + + + + + + + + GECODE_INT_EXPORT BrancherHandle + GECODE_INT_EXPORT BrancherHandle Gecode::branch + (Home home, BoolVar x, IntValBranch vals, BoolVarValPrint vvp=NULL) + branch + + Home + home + + + BoolVar + x + + + IntValBranch + vals + + + BoolVarValPrint + vvp + NULL + + +Branch over x with value selection vals. + + + + + + + + GECODE_INT_EXPORT BrancherHandle + GECODE_INT_EXPORT BrancherHandle Gecode::assign + (Home home, const IntVarArgs &x, IntAssign vals, IntBranchFilter ibf=NULL, IntVarValPrint vvp=NULL) + assign + + Home + home + + + const IntVarArgs & + x + + + IntAssign + vals + + + IntBranchFilter + ibf + NULL + + + IntVarValPrint + vvp + NULL + + +Assign all x with value selection vals. + + + + + + + + GECODE_INT_EXPORT BrancherHandle + GECODE_INT_EXPORT BrancherHandle Gecode::assign + (Home home, IntVar x, IntAssign vals, IntVarValPrint vvp=NULL) + assign + + Home + home + + + IntVar + x + + + IntAssign + vals + + + IntVarValPrint + vvp + NULL + + +Assign x with value selection vals. + + + + + + + + GECODE_INT_EXPORT BrancherHandle + GECODE_INT_EXPORT BrancherHandle Gecode::assign + (Home home, const BoolVarArgs &x, IntAssign vals, BoolBranchFilter bbf=NULL, BoolVarValPrint vvp=NULL) + assign + + Home + home + + + const BoolVarArgs & + x + + + IntAssign + vals + + + BoolBranchFilter + bbf + NULL + + + BoolVarValPrint + vvp + NULL + + +Assign all x with value selection vals. + + + + + + + + GECODE_INT_EXPORT BrancherHandle + GECODE_INT_EXPORT BrancherHandle Gecode::assign + (Home home, BoolVar x, IntAssign vals, BoolVarValPrint vvp=NULL) + assign + + Home + home + + + BoolVar + x + + + IntAssign + vals + + + BoolVarValPrint + vvp + NULL + + +Assign x with value selection vals. + + + + + + + + GECODE_INT_EXPORT SymmetryHandle + GECODE_INT_EXPORT SymmetryHandle Gecode::VariableSymmetry + (const IntVarArgs &x) + VariableSymmetry + + const IntVarArgs & + x + + +Variables in x are interchangeable. + + + + + + + + GECODE_INT_EXPORT SymmetryHandle + GECODE_INT_EXPORT SymmetryHandle Gecode::VariableSymmetry + (const BoolVarArgs &x) + VariableSymmetry + + const BoolVarArgs & + x + + +Variables in x are interchangeable. + + + + + + + + GECODE_INT_EXPORT SymmetryHandle + GECODE_INT_EXPORT SymmetryHandle Gecode::VariableSymmetry + (const IntVarArgs &x, const IntArgs &indices) + VariableSymmetry + + const IntVarArgs & + x + + + const IntArgs & + indices + + +Specified variables in x are interchangeable. + + + + + + + + GECODE_INT_EXPORT SymmetryHandle + GECODE_INT_EXPORT SymmetryHandle Gecode::ValueSymmetry + (const IntArgs &v) + ValueSymmetry + + const IntArgs & + v + + +Values in v are interchangeable. + + + + + + + + GECODE_INT_EXPORT SymmetryHandle + GECODE_INT_EXPORT SymmetryHandle Gecode::ValueSymmetry + (const IntSet &v) + ValueSymmetry + + const IntSet & + v + + +Values in v are interchangeable. + + + + + + + + GECODE_INT_EXPORT SymmetryHandle + GECODE_INT_EXPORT SymmetryHandle Gecode::ValueSymmetry + (IntVar vars) + ValueSymmetry + + IntVar + vars + + +All values in the domain of the given variable are interchangeable. + + + + + + + + GECODE_INT_EXPORT SymmetryHandle + GECODE_INT_EXPORT SymmetryHandle Gecode::VariableSequenceSymmetry + (const IntVarArgs &x, int ss) + VariableSequenceSymmetry + + const IntVarArgs & + x + + + int + ss + + +Variable sequences in x of size ss are interchangeable. + +The size of x must be a multiple of ss. + + + + + + GECODE_INT_EXPORT SymmetryHandle + GECODE_INT_EXPORT SymmetryHandle Gecode::VariableSequenceSymmetry + (const BoolVarArgs &x, int ss) + VariableSequenceSymmetry + + const BoolVarArgs & + x + + + int + ss + + +Variable sequences in x of size ss are interchangeable. + +The size of x must be a multiple of ss. + + + + + + GECODE_INT_EXPORT SymmetryHandle + GECODE_INT_EXPORT SymmetryHandle Gecode::ValueSequenceSymmetry + (const IntArgs &v, int ss) + ValueSequenceSymmetry + + const IntArgs & + v + + + int + ss + + +Value sequences in v of size ss are interchangeable. + +The size of v must be a multiple of ss. + + + + + + GECODE_INT_EXPORT SymmetryHandle + GECODE_INT_EXPORT SymmetryHandle Gecode::values_reflect + (int lower, int upper) + values_reflect + + int + lower + + + int + upper + + +The values from lower to upper (inclusive) can be reflected. + + + + + + + + GECODE_INT_EXPORT SymmetryHandle + GECODE_INT_EXPORT SymmetryHandle Gecode::values_reflect + (IntVar x) + values_reflect + + IntVar + x + + +The values in the domain of can be reflected. + + + + + + + + GECODE_INT_EXPORT BrancherHandle + GECODE_INT_EXPORT BrancherHandle Gecode::branch + (Home home, const IntVarArgs &x, IntVarBranch vars, IntValBranch vals, const Symmetries &syms, IntBranchFilter bf=NULL, IntVarValPrint vvp=NULL) + branch + + Home + home + + + const IntVarArgs & + x + + + IntVarBranch + vars + + + IntValBranch + vals + + + const Symmetries & + syms + + + IntBranchFilter + bf + NULL + + + IntVarValPrint + vvp + NULL + + +Branch over x with variable selection vars and value selection vals with symmetry breaking. + +Throws LDSBBadValueSelection exception if vals is any of SEL_SPLIT_MIN, SEL_SPLIT_MAX, SEL_RANGE_MIN, SEL_RANGE_MAX, SEL_VALUES_MIN, and SEL_VALUES_MAX, or if vals is SEL_VAL_COMMIT with a custom commit function. + + + + + + GECODE_INT_EXPORT BrancherHandle + GECODE_INT_EXPORT BrancherHandle Gecode::branch + (Home home, const IntVarArgs &x, TieBreak< IntVarBranch > vars, IntValBranch vals, const Symmetries &syms, IntBranchFilter bf=NULL, IntVarValPrint vvp=NULL) + branch + + Home + home + + + const IntVarArgs & + x + + + TieBreak< IntVarBranch > + vars + + + IntValBranch + vals + + + const Symmetries & + syms + + + IntBranchFilter + bf + NULL + + + IntVarValPrint + vvp + NULL + + +Branch over x with tie-breaking variable selection vars and value selection vals with symmetry breaking. + +Throws LDSBBadValueSelection exception if vals is any of SEL_SPLIT_MIN, SEL_SPLIT_MAX, SEL_RANGE_MIN, SEL_RANGE_MAX, SEL_VALUES_MIN, and SEL_VALUES_MAX, or if vals is SEL_VAL_COMMIT with a custom commit function. + + + + + + GECODE_INT_EXPORT BrancherHandle + GECODE_INT_EXPORT BrancherHandle Gecode::branch + (Home home, const BoolVarArgs &x, IntVarBranch vars, IntValBranch vals, const Symmetries &syms, BoolBranchFilter bf=NULL, BoolVarValPrint vvp=NULL) + branch + + Home + home + + + const BoolVarArgs & + x + + + IntVarBranch + vars + + + IntValBranch + vals + + + const Symmetries & + syms + + + BoolBranchFilter + bf + NULL + + + BoolVarValPrint + vvp + NULL + + +Branch over x with variable selection vars and value selection vals with symmetry breaking. + +Throws LDSBBadValueSelection exception if vals is any of SEL_SPLIT_MIN, SEL_SPLIT_MAX, SEL_RANGE_MIN, SEL_RANGE_MAX, SEL_VALUES_MIN, and SEL_VALUES_MAX, or if vals is SEL_VAL_COMMIT with a custom commit function. + + + + + + GECODE_INT_EXPORT BrancherHandle + GECODE_INT_EXPORT BrancherHandle Gecode::branch + (Home home, const BoolVarArgs &x, TieBreak< IntVarBranch > vars, IntValBranch vals, const Symmetries &syms, BoolBranchFilter bf=NULL, BoolVarValPrint vvp=NULL) + branch + + Home + home + + + const BoolVarArgs & + x + + + TieBreak< IntVarBranch > + vars + + + IntValBranch + vals + + + const Symmetries & + syms + + + BoolBranchFilter + bf + NULL + + + BoolVarValPrint + vvp + NULL + + +Branch over x with tie-breaking variable selection vars and value selection vals with symmetry breaking. + +Throws LDSBBadValueSelection exception if vals is any of SEL_SPLIT_MIN, SEL_SPLIT_MAX, SEL_RANGE_MIN, SEL_RANGE_MAX, SEL_VALUES_MIN, and SEL_VALUES_MAX, or if vals is SEL_VAL_COMMIT with a custom commit function. + + + + + + + + class Char + + + class Traits + + + std::basic_ostream< Char, Traits > & + std::basic_ostream<Char,Traits>& Gecode::operator<< + (std::basic_ostream< Char, Traits > &os, const Activity &a) + operator<< + + std::basic_ostream< Char, Traits > & + os + + + const Activity & + a + + + + + + + + + + + + + class Char + + + class Traits + + + std::basic_ostream< Char, Traits > & + std::basic_ostream<Char,Traits>& Gecode::operator<< + (std::basic_ostream< Char, Traits > &os, const AFC &a) + operator<< + + std::basic_ostream< Char, Traits > & + os + + + const AFC & + a + + + + + + + + + + + + + class T1 + + + class T2 + + + bool + bool Gecode::operator== + (space_allocator< T1 > const &al1, space_allocator< T2 > const &al2) + operator== + + space_allocator< T1 > const & + al1 + + + space_allocator< T2 > const & + al2 + + throw () + +Tests two space allocators for equality. + +Two allocators are equal when each can release storage allocated from the other. + + + + + + + + class T1 + + + class T2 + + + bool + bool Gecode::operator!= + (space_allocator< T1 > const &al1, space_allocator< T2 > const &al2) + operator!= + + space_allocator< T1 > const & + al1 + + + space_allocator< T2 > const & + al2 + + throw () + +Tests two space allocators for inequality. + +Two allocators are equal when each can release storage allocated from the other. + + + + + + + + class T1 + + + class T2 + + + bool + bool Gecode::operator== + (region_allocator< T1 > const &al1, region_allocator< T2 > const &al2) + operator== + + region_allocator< T1 > const & + al1 + + + region_allocator< T2 > const & + al2 + + throw () + + + + + + + + + + + + class T1 + + + class T2 + + + bool + bool Gecode::operator!= + (region_allocator< T1 > const &al1, region_allocator< T2 > const &al2) + operator!= + + region_allocator< T1 > const & + al1 + + + region_allocator< T2 > const & + al2 + + throw () + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator<< + (Archive &e, unsigned int i) + operator<< + + Archive & + e + + + unsigned int + i + + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator<< + (Archive &e, int i) + operator<< + + Archive & + e + + + int + i + + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator<< + (Archive &e, unsigned short i) + operator<< + + Archive & + e + + + unsigned short + i + + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator<< + (Archive &e, short i) + operator<< + + Archive & + e + + + short + i + + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator<< + (Archive &e, unsigned char i) + operator<< + + Archive & + e + + + unsigned char + i + + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator<< + (Archive &e, char i) + operator<< + + Archive & + e + + + char + i + + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator<< + (Archive &e, bool i) + operator<< + + Archive & + e + + + bool + i + + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator<< + (Archive &e, float d) + operator<< + + Archive & + e + + + float + d + + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator<< + (Archive &e, double d) + operator<< + + Archive & + e + + + double + d + + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator>> + (Archive &e, unsigned int &i) + operator>> + + Archive & + e + + + unsigned int & + i + + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator>> + (Archive &e, int &i) + operator>> + + Archive & + e + + + int & + i + + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator>> + (Archive &e, unsigned short &i) + operator>> + + Archive & + e + + + unsigned short & + i + + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator>> + (Archive &e, short &i) + operator>> + + Archive & + e + + + short & + i + + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator>> + (Archive &e, unsigned char &i) + operator>> + + Archive & + e + + + unsigned char & + i + + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator>> + (Archive &e, char &i) + operator>> + + Archive & + e + + + char & + i + + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator>> + (Archive &e, bool &i) + operator>> + + Archive & + e + + + bool & + i + + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator>> + (Archive &e, float &d) + operator>> + + Archive & + e + + + float & + d + + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator>> + (Archive &e, double &d) + operator>> + + Archive & + e + + + double & + d + + + + + + + + + + + + + class Var + + + ArrayTraits< VarArray< Var > >::ArgsType + ArrayTraits<VarArray<Var> >::ArgsType Gecode::operator+ + (const VarArray< Var > &x, const VarArray< Var > &y) + operator+ + + const VarArray< Var > & + x + + + const VarArray< Var > & + y + + + + + + + + + + + + + class Var + + + ArrayTraits< VarArray< Var > >::ArgsType + ArrayTraits<VarArray<Var> >::ArgsType Gecode::operator+ + (const VarArray< Var > &x, const VarArgArray< Var > &y) + operator+ + + const VarArray< Var > & + x + + + const VarArgArray< Var > & + y + + + + + + + + + + + + + class Var + + + ArrayTraits< VarArray< Var > >::ArgsType + ArrayTraits<VarArray<Var> >::ArgsType Gecode::operator+ + (const VarArgArray< Var > &x, const VarArray< Var > &y) + operator+ + + const VarArgArray< Var > & + x + + + const VarArray< Var > & + y + + + + + + + + + + + + + class Var + + + ArrayTraits< VarArray< Var > >::ArgsType + ArrayTraits<VarArray<Var> >::ArgsType Gecode::operator+ + (const VarArray< Var > &x, const Var &y) + operator+ + + const VarArray< Var > & + x + + + const Var & + y + + + + + + + + + + + + + class Var + + + ArrayTraits< VarArray< Var > >::ArgsType + ArrayTraits<VarArray<Var> >::ArgsType Gecode::operator+ + (const Var &x, const VarArray< Var > &y) + operator+ + + const Var & + x + + + const VarArray< Var > & + y + + + + + + + + + + + + + class View + + + forceinline bool + forceinline bool Gecode::__before + (const View &x, const View &y) + __before + + const View & + x + + + const View & + y + + + + + + + + + + + + + class X + + + class Y + + + forceinline bool + forceinline bool Gecode::__same + (const X &x, const Y &y) + __same + + const X & + x + + + const Y & + y + + + + + + + + + + + + + class X + + + class Y + + + forceinline bool + forceinline bool Gecode::__shared + (const X &x, const Y &y) + __shared + + const X & + x + + + const Y & + y + + + + + + + + + + + + + class T + + + ArrayTraits< PrimArgArray< T > >::ArgsType + ArrayTraits<PrimArgArray<T> >::ArgsType Gecode::operator+ + (const PrimArgArray< T > &x, const PrimArgArray< T > &y) + operator+ + + const PrimArgArray< T > & + x + + + const PrimArgArray< T > & + y + + + + + + + + + + + + + class T + + + ArrayTraits< PrimArgArray< T > >::ArgsType + ArrayTraits<PrimArgArray<T> >::ArgsType Gecode::operator+ + (const PrimArgArray< T > &x, const T &y) + operator+ + + const PrimArgArray< T > & + x + + + const T & + y + + + + + + + + + + + + + class T + + + ArrayTraits< PrimArgArray< T > >::ArgsType + ArrayTraits<PrimArgArray<T> >::ArgsType Gecode::operator+ + (const T &x, const PrimArgArray< T > &y) + operator+ + + const T & + x + + + const PrimArgArray< T > & + y + + + + + + + + + + + + + class T + + + ArrayTraits< ArgArray< T > >::ArgsType + ArrayTraits<ArgArray<T> >::ArgsType Gecode::operator+ + (const ArgArray< T > &x, const ArgArray< T > &y) + operator+ + + const ArgArray< T > & + x + + + const ArgArray< T > & + y + + + + + + + + + + + + + class T + + + ArrayTraits< ArgArray< T > >::ArgsType + ArrayTraits<ArgArray<T> >::ArgsType Gecode::operator+ + (const ArgArray< T > &x, const T &y) + operator+ + + const ArgArray< T > & + x + + + const T & + y + + + + + + + + + + + + + class T + + + ArrayTraits< ArgArray< T > >::ArgsType + ArrayTraits<ArgArray<T> >::ArgsType Gecode::operator+ + (const T &x, const ArgArray< T > &y) + operator+ + + const T & + x + + + const ArgArray< T > & + y + + + + + + + + + + + + + class Var + + + ArrayTraits< VarArgArray< Var > >::ArgsType + ArrayTraits<VarArgArray<Var> >::ArgsType Gecode::operator+ + (const VarArgArray< Var > &x, const VarArgArray< Var > &y) + operator+ + + const VarArgArray< Var > & + x + + + const VarArgArray< Var > & + y + + + + + + + + + + + + + class Var + + + ArrayTraits< VarArgArray< Var > >::ArgsType + ArrayTraits<VarArgArray<Var> >::ArgsType Gecode::operator+ + (const VarArgArray< Var > &x, const Var &y) + operator+ + + const VarArgArray< Var > & + x + + + const Var & + y + + + + + + + + + + + + + class Var + + + ArrayTraits< VarArgArray< Var > >::ArgsType + ArrayTraits<VarArgArray<Var> >::ArgsType Gecode::operator+ + (const Var &x, const VarArgArray< Var > &y) + operator+ + + const Var & + x + + + const VarArgArray< Var > & + y + + + + + + + + + + + + + class Char + + + class Traits + + + class Var + + + std::basic_ostream< Char, Traits > & + std::basic_ostream<Char,Traits>& Gecode::operator<< + (std::basic_ostream< Char, Traits > &os, const VarArray< Var > &x) + operator<< + + std::basic_ostream< Char, Traits > & + os + + + const VarArray< Var > & + x + + + + + + + + + + + + + class Char + + + class Traits + + + class View + + + std::basic_ostream< Char, Traits > & + std::basic_ostream<Char,Traits>& Gecode::operator<< + (std::basic_ostream< Char, Traits > &os, const ViewArray< View > &x) + operator<< + + std::basic_ostream< Char, Traits > & + os + + + const ViewArray< View > & + x + + + + + + + + + + + + + class Char + + + class Traits + + + class T + + + std::basic_ostream< Char, Traits > & + std::basic_ostream<Char,Traits>& Gecode::operator<< + (std::basic_ostream< Char, Traits > &os, const ArgArrayBase< T > &x) + operator<< + + std::basic_ostream< Char, Traits > & + os + + + const ArgArrayBase< T > & + x + + + + + + + + + + + + + class VarBranch + + + TieBreak< VarBranch > + TieBreak<VarBranch> Gecode::tiebreak + (VarBranch a, VarBranch b) + tiebreak + + VarBranch + a + + + VarBranch + b + + +Combine variable selection criteria a and b for tie-breaking. + + + + + + + + + + class VarBranch + + + TieBreak< VarBranch > + TieBreak<VarBranch> Gecode::tiebreak + (VarBranch a, VarBranch b, VarBranch c) + tiebreak + + VarBranch + a + + + VarBranch + b + + + VarBranch + c + + +Combine variable selection criteria a, b, and c for tie-breaking. + + + + + + + + + + class VarBranch + + + TieBreak< VarBranch > + TieBreak<VarBranch> Gecode::tiebreak + (VarBranch a, VarBranch b, VarBranch c, VarBranch d) + tiebreak + + VarBranch + a + + + VarBranch + b + + + VarBranch + c + + + VarBranch + d + + +Combine variable selection criteria a, b, c, and d for tie-breaking. + + + + + + + + + + class VarBranch + + + forceinline TieBreak< VarBranch > + forceinline TieBreak<VarBranch> Gecode::tiebreak + (VarBranch a, VarBranch b) + tiebreak + + VarBranch + a + + + VarBranch + b + + +Combine variable selection criteria a and b for tie-breaking. + + + + + + + + + + class VarBranch + + + forceinline TieBreak< VarBranch > + forceinline TieBreak<VarBranch> Gecode::tiebreak + (VarBranch a, VarBranch b, VarBranch c) + tiebreak + + VarBranch + a + + + VarBranch + b + + + VarBranch + c + + +Combine variable selection criteria a, b, and c for tie-breaking. + + + + + + + + + + class VarBranch + + + forceinline TieBreak< VarBranch > + forceinline TieBreak<VarBranch> Gecode::tiebreak + (VarBranch a, VarBranch b, VarBranch c, VarBranch d) + tiebreak + + VarBranch + a + + + VarBranch + b + + + VarBranch + c + + + VarBranch + d + + +Combine variable selection criteria a, b, c, and d for tie-breaking. + + + + + + + + bool + forceinline bool Gecode::me_failed + (ModEvent me) + me_failed + + ModEvent + me + + +Check whether modification event me is failed. + + + + + + + + bool + forceinline bool Gecode::me_modified + (ModEvent me) + me_modified + + ModEvent + me + + +Check whether modification event me describes variable modification. + + + + + + + + + + class Char + + + class Traits + + + class T + + + std::basic_ostream< Char, Traits > & + std::basic_ostream<Char,Traits>& Gecode::operator<< + (std::basic_ostream< Char, Traits > &os, const SharedArray< T > &x) + operator<< + + std::basic_ostream< Char, Traits > & + os + + + const SharedArray< T > & + x + + + + + + + + + + + + + class ViewA + + + class ViewB + + + bool + bool Gecode::shared + (const ConstView< ViewA > &, const ConstView< ViewB > &) + shared + + const ConstView< ViewA > & + + + const ConstView< ViewB > & + + +Test whether views share same variable. + + + + + + + + + + class Var + + + class View + + + bool + bool Gecode::shared + (const VarImpView< Var > &, const ConstView< View > &) + shared + + const VarImpView< Var > & + + + const ConstView< View > & + + +Test whether views share same variable. + + + + + + + + + + class ViewA + + + class ViewB + + + bool + bool Gecode::shared + (const DerivedView< ViewA > &, const ConstView< ViewB > &) + shared + + const DerivedView< ViewA > & + + + const ConstView< ViewB > & + + +Test whether views share same variable. + + + + + + + + + + class View + + + class Var + + + bool + bool Gecode::shared + (const ConstView< View > &, const VarImpView< Var > &) + shared + + const ConstView< View > & + + + const VarImpView< Var > & + + +Test whether views share same variable. + + + + + + + + + + class ViewA + + + class ViewB + + + bool + bool Gecode::shared + (const ConstView< ViewA > &, const DerivedView< ViewB > &) + shared + + const ConstView< ViewA > & + + + const DerivedView< ViewB > & + + +Test whether views share same variable. + + + + + + + + + + class VarA + + + class VarB + + + bool + bool Gecode::shared + (const VarImpView< VarA > &, const VarImpView< VarB > &) + shared + + const VarImpView< VarA > & + + + const VarImpView< VarB > & + + +Test whether views share same variable. + + + + + + + + + + class Var + + + class View + + + bool + bool Gecode::shared + (const VarImpView< Var > &, const DerivedView< View > &) + shared + + const VarImpView< Var > & + + + const DerivedView< View > & + + +Test whether views share same variable. + + + + + + + + + + class View + + + class Var + + + bool + bool Gecode::shared + (const DerivedView< View > &, const VarImpView< Var > &) + shared + + const DerivedView< View > & + + + const VarImpView< Var > & + + +Test whether views share same variable. + + + + + + + + + + class ViewA + + + class ViewB + + + bool + bool Gecode::shared + (const DerivedView< ViewA > &, const DerivedView< ViewB > &) + shared + + const DerivedView< ViewA > & + + + const DerivedView< ViewB > & + + +Test whether views share same variable. + + + + + + + + + + class ViewA + + + class ViewB + + + forceinline bool + forceinline bool Gecode::same + (const ConstView< ViewA > &, const ConstView< ViewB > &) + same + + const ConstView< ViewA > & + + + const ConstView< ViewB > & + + +Test whether two views are the same. + + + + + + + + + + class Var + + + class View + + + forceinline bool + forceinline bool Gecode::same + (const VarImpView< Var > &, const ConstView< View > &) + same + + const VarImpView< Var > & + + + const ConstView< View > & + + +Test whether two views are the same. + + + + + + + + + + class ViewA + + + class ViewB + + + forceinline bool + forceinline bool Gecode::same + (const ConstView< ViewA > &, const DerivedView< ViewB > &) + same + + const ConstView< ViewA > & + + + const DerivedView< ViewB > & + + +Test whether two views are the same. + + + + + + + + + + class Var + + + class View + + + forceinline bool + forceinline bool Gecode::same + (const VarImpView< Var > &, const DerivedView< View > &) + same + + const VarImpView< Var > & + + + const DerivedView< View > & + + +Test whether two views are the same. + + + + + + + + + + class View + + + class Var + + + forceinline bool + forceinline bool Gecode::same + (const DerivedView< View > &, const VarImpView< Var > &) + same + + const DerivedView< View > & + + + const VarImpView< Var > & + + +Test whether two views are the same. + + + + + + + + + + class Var + + + forceinline bool + forceinline bool Gecode::same + (const VarImpView< Var > &x, const VarImpView< Var > &y) + same + + const VarImpView< Var > & + x + + + const VarImpView< Var > & + y + + +Test whether two views are the same. + + + + + + + + + + class ViewA + + + class ViewB + + + forceinline bool + forceinline bool Gecode::same + (const DerivedView< ViewA > &x, const DerivedView< ViewB > &y) + same + + const DerivedView< ViewA > & + x + + + const DerivedView< ViewB > & + y + + +Test whether two views are the same. + + + + + + + + + + class ViewA + + + class ViewB + + + forceinline bool + forceinline bool Gecode::before + (const ViewA &x, const ViewB &y) + before + + const ViewA & + x + + + const ViewB & + y + + + + + + + + + + + + + class ViewA + + + class ViewB + + + forceinline bool + forceinline bool Gecode::shared + (const ConstView< ViewA > &, const ConstView< ViewB > &) + shared + + const ConstView< ViewA > & + + + const ConstView< ViewB > & + + +Test whether views share same variable. + + + + + + + + + + class Var + + + class View + + + forceinline bool + forceinline bool Gecode::shared + (const VarImpView< Var > &, const ConstView< View > &) + shared + + const VarImpView< Var > & + + + const ConstView< View > & + + +Test whether views share same variable. + + + + + + + + + + class ViewA + + + class ViewB + + + forceinline bool + forceinline bool Gecode::shared + (const DerivedView< ViewA > &, const ConstView< ViewB > &) + shared + + const DerivedView< ViewA > & + + + const ConstView< ViewB > & + + +Test whether views share same variable. + + + + + + + + + + class View + + + class Var + + + forceinline bool + forceinline bool Gecode::shared + (const ConstView< View > &, const VarImpView< Var > &) + shared + + const ConstView< View > & + + + const VarImpView< Var > & + + +Test whether views share same variable. + + + + + + + + + + class ViewA + + + class ViewB + + + forceinline bool + forceinline bool Gecode::shared + (const ConstView< ViewA > &, const DerivedView< ViewB > &) + shared + + const ConstView< ViewA > & + + + const DerivedView< ViewB > & + + +Test whether views share same variable. + + + + + + + + + + class VarA + + + class VarB + + + forceinline bool + forceinline bool Gecode::shared + (const VarImpView< VarA > &x, const VarImpView< VarB > &y) + shared + + const VarImpView< VarA > & + x + + + const VarImpView< VarB > & + y + + +Test whether views share same variable. + + + + + + + + + + class Var + + + class View + + + forceinline bool + forceinline bool Gecode::shared + (const VarImpView< Var > &x, const DerivedView< View > &y) + shared + + const VarImpView< Var > & + x + + + const DerivedView< View > & + y + + +Test whether views share same variable. + + + + + + + + + + class View + + + class Var + + + forceinline bool + forceinline bool Gecode::shared + (const DerivedView< View > &x, const VarImpView< Var > &y) + shared + + const DerivedView< View > & + x + + + const VarImpView< Var > & + y + + +Test whether views share same variable. + + + + + + + + + + class ViewA + + + class ViewB + + + forceinline bool + forceinline bool Gecode::shared + (const DerivedView< ViewA > &x, const DerivedView< ViewB > &y) + shared + + const DerivedView< ViewA > & + x + + + const DerivedView< ViewB > & + y + + +Test whether views share same variable. + + + + + + + + GECODE_KERNEL_EXPORT BrancherHandle + GECODE_KERNEL_EXPORT BrancherHandle Gecode::branch + (Home home, void(*f)(Space &home)) + branch + + Home + home + + + void(*)(Space &home) + f + + +Call the function f (with the current space as argument) for branching. + + + + + + + + + + class A + + + SymmetryHandle + SymmetryHandle Gecode::rows_interchange + (const Matrix< A > &m) + rows_interchange + + const Matrix< A > & + m + + +Interchangeable rows symmetry specification. + + + + + + + + + + class A + + + SymmetryHandle + SymmetryHandle Gecode::columns_interchange + (const Matrix< A > &m) + columns_interchange + + const Matrix< A > & + m + + +Interchangeable columns symmetry specification. + + + + + + + + + + class A + + + SymmetryHandle + SymmetryHandle Gecode::rows_reflect + (const Matrix< A > &m) + rows_reflect + + const Matrix< A > & + m + + +Reflect rows symmetry specification. + + + + + + + + + + class A + + + SymmetryHandle + SymmetryHandle Gecode::columns_reflect + (const Matrix< A > &m) + columns_reflect + + const Matrix< A > & + m + + +Reflect columns symmetry specification. + + + + + + + + + + class A + + + SymmetryHandle + SymmetryHandle Gecode::diagonal_reflect + (const Matrix< A > &m) + diagonal_reflect + + const Matrix< A > & + m + + +Reflect around main diagonal symmetry specification. + + + + + + + + + + class A + + + Slice< A >::ArgsType + Slice< A >::ArgsType Gecode::operator+ + (const Slice< A > &x, const Slice< A > &y) + operator+ + + const Slice< A > & + x + + + const Slice< A > & + y + + +Concatenate x and y. + + + + + + + + + + class A + + + Slice< A >::ArgsType + Slice< A >::ArgsType Gecode::operator+ + (const Slice< A > &x, const typename ArrayTraits< A >::ArgsType &y) + operator+ + + const Slice< A > & + x + + + const typename ArrayTraits< A >::ArgsType & + y + + +Concatenate x and y. + + + + + + + + + + class A + + + Slice< A >::ArgsType + Slice< A >::ArgsType Gecode::operator+ + (const typename ArrayTraits< A >::ArgsType &x, const Slice< A > &y) + operator+ + + const typename ArrayTraits< A >::ArgsType & + x + + + const Slice< A > & + y + + +Concatenate x and y. + + + + + + + + + + class A + + + Slice< A >::ArgsType + Slice< A >::ArgsType Gecode::operator+ + (const Slice< A > &x, const typename ArrayTraits< A >::ValueType &y) + operator+ + + const Slice< A > & + x + + + const typename ArrayTraits< A >::ValueType & + y + + +Concatenate x and y. + + + + + + + + + + class A + + + Slice< A >::ArgsType + Slice< A >::ArgsType Gecode::operator+ + (const typename ArrayTraits< A >::ValueType &x, const Slice< A > &y) + operator+ + + const typename ArrayTraits< A >::ValueType & + x + + + const Slice< A > & + y + + +Concatenate x and y. + + + + + + + + + + class Char + + + class Traits + + + class A + + + std::basic_ostream< Char, Traits > & + std::basic_ostream<Char,Traits>& Gecode::operator<< + (std::basic_ostream< Char, Traits > &os, const Matrix< A > &m) + operator<< + + std::basic_ostream< Char, Traits > & + os + + + const Matrix< A > & + m + + + + + + + + + + + + + class Char + + + class Traits + + + class A + + + std::basic_ostream< Char, Traits > & + std::basic_ostream<Char,Traits>& Gecode::operator<< + (std::basic_ostream< Char, Traits > &os, const Slice< A > &s) + operator<< + + std::basic_ostream< Char, Traits > & + os + + + const Slice< A > & + s + + + + + + + + + + + forceinline void + forceinline void Gecode::element + (Home home, const Matrix< IntArgs > &m, IntVar x, IntVar y, IntVar z, IntConLevel icl) + element + + Home + home + + + const Matrix< IntArgs > & + m + + + IntVar + x + + + IntVar + y + + + IntVar + z + + + IntConLevel + icl + + + + + + + + + + + forceinline void + forceinline void Gecode::element + (Home home, const Matrix< IntArgs > &m, IntVar x, IntVar y, BoolVar z, IntConLevel icl) + element + + Home + home + + + const Matrix< IntArgs > & + m + + + IntVar + x + + + IntVar + y + + + BoolVar + z + + + IntConLevel + icl + + + + + + + + + + + forceinline void + forceinline void Gecode::element + (Home home, const Matrix< IntVarArgs > &m, IntVar x, IntVar y, IntVar z, IntConLevel icl) + element + + Home + home + + + const Matrix< IntVarArgs > & + m + + + IntVar + x + + + IntVar + y + + + IntVar + z + + + IntConLevel + icl + + + + + + + + + + + forceinline void + forceinline void Gecode::element + (Home home, const Matrix< BoolVarArgs > &m, IntVar x, IntVar y, BoolVar z, IntConLevel icl) + element + + Home + home + + + const Matrix< BoolVarArgs > & + m + + + IntVar + x + + + IntVar + y + + + BoolVar + z + + + IntConLevel + icl + + + + + + + + + + + + + class Char + + + class Traits + + + std::basic_ostream< Char, Traits > & + std::basic_ostream<Char,Traits>& Gecode::operator<< + (std::basic_ostream< Char, Traits > &os, const REG &r) + operator<< + + std::basic_ostream< Char, Traits > & + os + + + const REG & + r + + + + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator+ + (int, const IntVar &) + operator+ + + int + + + const IntVar & + + +Construct linear expression as sum of integer variable and integer. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator+ + (int, const BoolVar &) + operator+ + + int + + + const BoolVar & + + +Construct linear expression as sum of Boolean variable and integer. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator+ + (int, const LinIntExpr &) + operator+ + + int + + + const LinIntExpr & + + +Construct linear expression as sum of linear expression and integer. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator+ + (const IntVar &, int) + operator+ + + const IntVar & + + + int + + +Construct linear expression as sum of integer variable and integer. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator+ + (const BoolVar &, int) + operator+ + + const BoolVar & + + + int + + +Construct linear expression as sum of Boolean variable and integer. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator+ + (const LinIntExpr &, int) + operator+ + + const LinIntExpr & + + + int + + +Construct linear expression as sum of linear expression and integer. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator+ + (const IntVar &, const IntVar &) + operator+ + + const IntVar & + + + const IntVar & + + +Construct linear expression as sum of integer variables. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator+ + (const IntVar &, const BoolVar &) + operator+ + + const IntVar & + + + const BoolVar & + + +Construct linear expression as sum of integer and Boolean variable. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator+ + (const BoolVar &, const IntVar &) + operator+ + + const BoolVar & + + + const IntVar & + + +Construct linear expression as sum of Boolean and integer variable. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator+ + (const BoolVar &, const BoolVar &) + operator+ + + const BoolVar & + + + const BoolVar & + + +Construct linear expression as sum of Boolean variables. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator+ + (const IntVar &, const LinIntExpr &) + operator+ + + const IntVar & + + + const LinIntExpr & + + +Construct linear expression as sum of integer variable and linear expression. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator+ + (const BoolVar &, const LinIntExpr &) + operator+ + + const BoolVar & + + + const LinIntExpr & + + +Construct linear expression as sum of Boolean variable and linear expression. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator+ + (const LinIntExpr &, const IntVar &) + operator+ + + const LinIntExpr & + + + const IntVar & + + +Construct linear expression as sum of linear expression and integer variable. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator+ + (const LinIntExpr &, const BoolVar &) + operator+ + + const LinIntExpr & + + + const BoolVar & + + +Construct linear expression as sum of linear expression and Boolean variable. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator+ + (const LinIntExpr &, const LinIntExpr &) + operator+ + + const LinIntExpr & + + + const LinIntExpr & + + +Construct linear expression as sum of linear expressions. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator- + (int, const IntVar &) + operator- + + int + + + const IntVar & + + +Construct linear expression as sum of integer variable and integer. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator- + (int, const BoolVar &) + operator- + + int + + + const BoolVar & + + +Construct linear expression as sum of Boolean variable and integer. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator- + (int, const LinIntExpr &) + operator- + + int + + + const LinIntExpr & + + +Construct linear expression as sum of integer and linear expression. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator- + (const IntVar &, int) + operator- + + const IntVar & + + + int + + +Construct linear expression as sum of integer variable and integer. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator- + (const BoolVar &, int) + operator- + + const BoolVar & + + + int + + +Construct linear expression as sum of Boolean variable and integer. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator- + (const LinIntExpr &, int) + operator- + + const LinIntExpr & + + + int + + +Construct linear expression as sum of linear expression and integer. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator- + (const IntVar &, const IntVar &) + operator- + + const IntVar & + + + const IntVar & + + +Construct linear expression as sum of integer variables. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator- + (const IntVar &, const BoolVar &) + operator- + + const IntVar & + + + const BoolVar & + + +Construct linear expression as sum of integer and Boolean variable. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator- + (const BoolVar &, const IntVar &) + operator- + + const BoolVar & + + + const IntVar & + + +Construct linear expression as sum of Boolean and integer variable. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator- + (const BoolVar &, const BoolVar &) + operator- + + const BoolVar & + + + const BoolVar & + + +Construct linear expression as sum of Boolean variables. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator- + (const IntVar &, const LinIntExpr &) + operator- + + const IntVar & + + + const LinIntExpr & + + +Construct linear expression as sum of integer variable and linear expression. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator- + (const BoolVar &, const LinIntExpr &) + operator- + + const BoolVar & + + + const LinIntExpr & + + +Construct linear expression as sum of Boolean variable and linear expression. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator- + (const LinIntExpr &, const IntVar &) + operator- + + const LinIntExpr & + + + const IntVar & + + +Construct linear expression as sum of linear expression and integer variable. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator- + (const LinIntExpr &, const BoolVar &) + operator- + + const LinIntExpr & + + + const BoolVar & + + +Construct linear expression as sum of linear expression and Boolean variable. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator- + (const LinIntExpr &, const LinIntExpr &) + operator- + + const LinIntExpr & + + + const LinIntExpr & + + +Construct linear expression as sum of linear expressions. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator- + (const IntVar &) + operator- + + const IntVar & + + +Construct linear expression as negative of integer variable. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator- + (const BoolVar &) + operator- + + const BoolVar & + + +Construct linear expression as negative of Boolean variable. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator- + (const LinIntExpr &) + operator- + + const LinIntExpr & + + +Construct linear expression as negative of linear expression. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator* + (int, const IntVar &) + operator* + + int + + + const IntVar & + + +Construct linear expression as product of integer coefficient and integer variable. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator* + (int, const BoolVar &) + operator* + + int + + + const BoolVar & + + +Construct linear expression as product of integer coefficient and Boolean variable. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator* + (const IntVar &, int) + operator* + + const IntVar & + + + int + + +Construct linear expression as product of integer coefficient and integer variable. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator* + (const BoolVar &, int) + operator* + + const BoolVar & + + + int + + +Construct linear expression as product of integer coefficient and Boolean variable. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator* + (const LinIntExpr &, int) + operator* + + const LinIntExpr & + + + int + + +Construct linear expression as product of integer coefficient and linear expression. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator* + (int, const LinIntExpr &) + operator* + + int + + + const LinIntExpr & + + +Construct linear expression as product of integer coefficient and linear expression. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::sum + (const IntVarArgs &x) + sum + + const IntVarArgs & + x + + +Construct linear expression as sum of integer variables. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::sum + (const IntArgs &a, const IntVarArgs &x) + sum + + const IntArgs & + a + + + const IntVarArgs & + x + + +Construct linear expression as sum of integer variables with coefficients. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::sum + (const BoolVarArgs &x) + sum + + const BoolVarArgs & + x + + +Construct linear expression as sum of Boolean variables. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::sum + (const IntArgs &a, const BoolVarArgs &x) + sum + + const IntArgs & + a + + + const BoolVarArgs & + x + + +Construct linear expression as sum of Boolean variables with coefficients. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::sum + (const IntArgs &args) + sum + + const IntArgs & + args + + +Construct linear expression as sum of IntArgs. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator== + (int l, const IntVar &r) + operator== + + int + l + + + const IntVar & + r + + +Construct linear equality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator== + (int l, const BoolVar &r) + operator== + + int + l + + + const BoolVar & + r + + +Construct linear equality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator== + (int l, const LinIntExpr &r) + operator== + + int + l + + + const LinIntExpr & + r + + +Construct linear equality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator== + (const IntVar &l, int r) + operator== + + const IntVar & + l + + + int + r + + +Construct linear equality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator== + (const BoolVar &l, int r) + operator== + + const BoolVar & + l + + + int + r + + +Construct linear equality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator== + (const LinIntExpr &l, int r) + operator== + + const LinIntExpr & + l + + + int + r + + +Construct linear equality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator== + (const IntVar &l, const IntVar &r) + operator== + + const IntVar & + l + + + const IntVar & + r + + +Construct linear equality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator== + (const IntVar &l, const BoolVar &r) + operator== + + const IntVar & + l + + + const BoolVar & + r + + +Construct linear equality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator== + (const BoolVar &l, const IntVar &r) + operator== + + const BoolVar & + l + + + const IntVar & + r + + +Construct linear equality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator== + (const BoolVar &l, const BoolVar &r) + operator== + + const BoolVar & + l + + + const BoolVar & + r + + +Construct linear equality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator== + (const IntVar &l, const LinIntExpr &r) + operator== + + const IntVar & + l + + + const LinIntExpr & + r + + +Construct linear equality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator== + (const BoolVar &l, const LinIntExpr &r) + operator== + + const BoolVar & + l + + + const LinIntExpr & + r + + +Construct linear equality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator== + (const LinIntExpr &l, const IntVar &r) + operator== + + const LinIntExpr & + l + + + const IntVar & + r + + +Construct linear equality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator== + (const LinIntExpr &l, const BoolVar &r) + operator== + + const LinIntExpr & + l + + + const BoolVar & + r + + +Construct linear equality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator== + (const LinIntExpr &l, const LinIntExpr &r) + operator== + + const LinIntExpr & + l + + + const LinIntExpr & + r + + +Construct linear equality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator!= + (int l, const IntVar &r) + operator!= + + int + l + + + const IntVar & + r + + +Construct linear disequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator!= + (int l, const BoolVar &r) + operator!= + + int + l + + + const BoolVar & + r + + +Construct linear disequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator!= + (int l, const LinIntExpr &r) + operator!= + + int + l + + + const LinIntExpr & + r + + +Construct linear disequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator!= + (const IntVar &l, int r) + operator!= + + const IntVar & + l + + + int + r + + +Construct linear disequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator!= + (const BoolVar &l, int r) + operator!= + + const BoolVar & + l + + + int + r + + +Construct linear disequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator!= + (const LinIntExpr &l, int r) + operator!= + + const LinIntExpr & + l + + + int + r + + +Construct linear disequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator!= + (const IntVar &l, const IntVar &r) + operator!= + + const IntVar & + l + + + const IntVar & + r + + +Construct linear disequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator!= + (const IntVar &l, const BoolVar &r) + operator!= + + const IntVar & + l + + + const BoolVar & + r + + +Construct linear disequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator!= + (const BoolVar &l, const IntVar &r) + operator!= + + const BoolVar & + l + + + const IntVar & + r + + +Construct linear disequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator!= + (const BoolVar &l, const BoolVar &r) + operator!= + + const BoolVar & + l + + + const BoolVar & + r + + +Construct linear disequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator!= + (const IntVar &l, const LinIntExpr &r) + operator!= + + const IntVar & + l + + + const LinIntExpr & + r + + +Construct linear disequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator!= + (const BoolVar &l, const LinIntExpr &r) + operator!= + + const BoolVar & + l + + + const LinIntExpr & + r + + +Construct linear disequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator!= + (const LinIntExpr &l, const IntVar &r) + operator!= + + const LinIntExpr & + l + + + const IntVar & + r + + +Construct linear disequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator!= + (const LinIntExpr &l, const BoolVar &r) + operator!= + + const LinIntExpr & + l + + + const BoolVar & + r + + +Construct linear disequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator!= + (const LinIntExpr &l, const LinIntExpr &r) + operator!= + + const LinIntExpr & + l + + + const LinIntExpr & + r + + +Construct linear disequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator< + (int l, const IntVar &r) + operator< + + int + l + + + const IntVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator< + (int l, const BoolVar &r) + operator< + + int + l + + + const BoolVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator< + (int l, const LinIntExpr &r) + operator< + + int + l + + + const LinIntExpr & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator< + (const IntVar &l, int r) + operator< + + const IntVar & + l + + + int + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator< + (const BoolVar &l, int r) + operator< + + const BoolVar & + l + + + int + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator< + (const LinIntExpr &l, int r) + operator< + + const LinIntExpr & + l + + + int + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator< + (const IntVar &l, const IntVar &r) + operator< + + const IntVar & + l + + + const IntVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator< + (const IntVar &l, const BoolVar &r) + operator< + + const IntVar & + l + + + const BoolVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator< + (const BoolVar &l, const IntVar &r) + operator< + + const BoolVar & + l + + + const IntVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator< + (const BoolVar &l, const BoolVar &r) + operator< + + const BoolVar & + l + + + const BoolVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator< + (const IntVar &l, const LinIntExpr &r) + operator< + + const IntVar & + l + + + const LinIntExpr & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator< + (const BoolVar &l, const LinIntExpr &r) + operator< + + const BoolVar & + l + + + const LinIntExpr & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator< + (const LinIntExpr &l, const IntVar &r) + operator< + + const LinIntExpr & + l + + + const IntVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator< + (const LinIntExpr &l, const BoolVar &r) + operator< + + const LinIntExpr & + l + + + const BoolVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator< + (const LinIntExpr &l, const LinIntExpr &r) + operator< + + const LinIntExpr & + l + + + const LinIntExpr & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator<= + (int l, const IntVar &r) + operator<= + + int + l + + + const IntVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator<= + (int l, const BoolVar &r) + operator<= + + int + l + + + const BoolVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator<= + (int l, const LinIntExpr &r) + operator<= + + int + l + + + const LinIntExpr & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator<= + (const IntVar &l, int r) + operator<= + + const IntVar & + l + + + int + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator<= + (const BoolVar &l, int r) + operator<= + + const BoolVar & + l + + + int + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator<= + (const LinIntExpr &l, int r) + operator<= + + const LinIntExpr & + l + + + int + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator<= + (const IntVar &l, const IntVar &r) + operator<= + + const IntVar & + l + + + const IntVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator<= + (const IntVar &l, const BoolVar &r) + operator<= + + const IntVar & + l + + + const BoolVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator<= + (const BoolVar &l, const IntVar &r) + operator<= + + const BoolVar & + l + + + const IntVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator<= + (const BoolVar &l, const BoolVar &r) + operator<= + + const BoolVar & + l + + + const BoolVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator<= + (const IntVar &l, const LinIntExpr &r) + operator<= + + const IntVar & + l + + + const LinIntExpr & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator<= + (const BoolVar &l, const LinIntExpr &r) + operator<= + + const BoolVar & + l + + + const LinIntExpr & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator<= + (const LinIntExpr &l, const IntVar &r) + operator<= + + const LinIntExpr & + l + + + const IntVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator<= + (const LinIntExpr &l, const BoolVar &r) + operator<= + + const LinIntExpr & + l + + + const BoolVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator<= + (const LinIntExpr &l, const LinIntExpr &r) + operator<= + + const LinIntExpr & + l + + + const LinIntExpr & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator> + (int l, const IntVar &r) + operator> + + int + l + + + const IntVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator> + (int l, const BoolVar &r) + operator> + + int + l + + + const BoolVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator> + (int l, const LinIntExpr &r) + operator> + + int + l + + + const LinIntExpr & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator> + (const IntVar &l, int r) + operator> + + const IntVar & + l + + + int + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator> + (const BoolVar &l, int r) + operator> + + const BoolVar & + l + + + int + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator> + (const LinIntExpr &l, int r) + operator> + + const LinIntExpr & + l + + + int + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator> + (const IntVar &l, const IntVar &r) + operator> + + const IntVar & + l + + + const IntVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator> + (const IntVar &l, const BoolVar &r) + operator> + + const IntVar & + l + + + const BoolVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator> + (const BoolVar &l, const IntVar &r) + operator> + + const BoolVar & + l + + + const IntVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator> + (const BoolVar &l, const BoolVar &r) + operator> + + const BoolVar & + l + + + const BoolVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator> + (const IntVar &l, const LinIntExpr &r) + operator> + + const IntVar & + l + + + const LinIntExpr & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator> + (const BoolVar &l, const LinIntExpr &r) + operator> + + const BoolVar & + l + + + const LinIntExpr & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator> + (const LinIntExpr &l, const IntVar &r) + operator> + + const LinIntExpr & + l + + + const IntVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator> + (const LinIntExpr &l, const BoolVar &r) + operator> + + const LinIntExpr & + l + + + const BoolVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator> + (const LinIntExpr &l, const LinIntExpr &r) + operator> + + const LinIntExpr & + l + + + const LinIntExpr & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator>= + (int l, const IntVar &r) + operator>= + + int + l + + + const IntVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator>= + (int l, const BoolVar &r) + operator>= + + int + l + + + const BoolVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator>= + (int l, const LinIntExpr &r) + operator>= + + int + l + + + const LinIntExpr & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator>= + (const IntVar &l, int r) + operator>= + + const IntVar & + l + + + int + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator>= + (const BoolVar &l, int r) + operator>= + + const BoolVar & + l + + + int + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator>= + (const LinIntExpr &l, int r) + operator>= + + const LinIntExpr & + l + + + int + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator>= + (const IntVar &l, const IntVar &r) + operator>= + + const IntVar & + l + + + const IntVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator>= + (const IntVar &l, const BoolVar &r) + operator>= + + const IntVar & + l + + + const BoolVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator>= + (const BoolVar &l, const IntVar &r) + operator>= + + const BoolVar & + l + + + const IntVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator>= + (const BoolVar &l, const BoolVar &r) + operator>= + + const BoolVar & + l + + + const BoolVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator>= + (const IntVar &l, const LinIntExpr &r) + operator>= + + const IntVar & + l + + + const LinIntExpr & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator>= + (const BoolVar &l, const LinIntExpr &r) + operator>= + + const BoolVar & + l + + + const LinIntExpr & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator>= + (const LinIntExpr &l, const IntVar &r) + operator>= + + const LinIntExpr & + l + + + const IntVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator>= + (const LinIntExpr &l, const BoolVar &r) + operator>= + + const LinIntExpr & + l + + + const BoolVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator>= + (const LinIntExpr &l, const LinIntExpr &r) + operator>= + + const LinIntExpr & + l + + + const LinIntExpr & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT BoolExpr + GECODE_MINIMODEL_EXPORT BoolExpr Gecode::operator! + (const BoolExpr &) + operator! + + const BoolExpr & + + +Negated Boolean expression. + + + + + + + + GECODE_MINIMODEL_EXPORT BoolExpr + GECODE_MINIMODEL_EXPORT BoolExpr Gecode::operator&& + (const BoolExpr &, const BoolExpr &) + operator&& + + const BoolExpr & + + + const BoolExpr & + + +Conjunction of Boolean expressions. + + + + + + + + GECODE_MINIMODEL_EXPORT BoolExpr + GECODE_MINIMODEL_EXPORT BoolExpr Gecode::operator|| + (const BoolExpr &, const BoolExpr &) + operator|| + + const BoolExpr & + + + const BoolExpr & + + +Disjunction of Boolean expressions. + + + + + + + + GECODE_MINIMODEL_EXPORT BoolExpr + GECODE_MINIMODEL_EXPORT BoolExpr Gecode::operator^ + (const BoolExpr &, const BoolExpr &) + operator^ + + const BoolExpr & + + + const BoolExpr & + + +Exclusive-or of Boolean expressions. + + + + + + + + GECODE_MINIMODEL_EXPORT BoolExpr + GECODE_MINIMODEL_EXPORT BoolExpr Gecode::operator!= + (const BoolExpr &, const BoolExpr &) + operator!= + + const BoolExpr & + + + const BoolExpr & + + +Non-equivalence of Boolean expressions. + + + + + + + + GECODE_MINIMODEL_EXPORT BoolExpr + GECODE_MINIMODEL_EXPORT BoolExpr Gecode::operator== + (const BoolExpr &, const BoolExpr &) + operator== + + const BoolExpr & + + + const BoolExpr & + + +Equivalence of Boolean expressions. + + + + + + + + GECODE_MINIMODEL_EXPORT BoolExpr + GECODE_MINIMODEL_EXPORT BoolExpr Gecode::operator>> + (const BoolExpr &, const BoolExpr &) + operator>> + + const BoolExpr & + + + const BoolExpr & + + +Implication of Boolean expressions. + + + + + + + + GECODE_MINIMODEL_EXPORT BoolExpr + GECODE_MINIMODEL_EXPORT BoolExpr Gecode::operator<< + (const BoolExpr &, const BoolExpr &) + operator<< + + const BoolExpr & + + + const BoolExpr & + + +Reverse implication of Boolean expressions. + + + + + + + + GECODE_MINIMODEL_EXPORT IntVar + GECODE_MINIMODEL_EXPORT IntVar Gecode::expr + (Home home, const LinIntExpr &e, IntConLevel icl=ICL_DEF) + expr + + Home + home + + + const LinIntExpr & + e + + + IntConLevel + icl + ICL_DEF + + +Post linear expression and return its value. + + + + + + + + GECODE_MINIMODEL_EXPORT BoolVar + GECODE_MINIMODEL_EXPORT BoolVar Gecode::expr + (Home home, const BoolExpr &e, IntConLevel icl=ICL_DEF) + expr + + Home + home + + + const BoolExpr & + e + + + IntConLevel + icl + ICL_DEF + + +Post Boolean expression and return its value. + + + + + + + + GECODE_MINIMODEL_EXPORT void + GECODE_MINIMODEL_EXPORT void Gecode::rel + (Home home, const BoolExpr &e, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + const BoolExpr & + e + + + IntConLevel + icl + ICL_DEF + + +Post Boolean relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::abs + (const LinIntExpr &e) + abs + + const LinIntExpr & + e + + +Return expression for $|e|$. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::min + (const LinIntExpr &x, const LinIntExpr &y) + min + + const LinIntExpr & + x + + + const LinIntExpr & + y + + +Return expression for $\min(x,y)$. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::min + (const IntVarArgs &x) + min + + const IntVarArgs & + x + + +Return expression for $\min(x)$. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::max + (const LinIntExpr &x, const LinIntExpr &y) + max + + const LinIntExpr & + x + + + const LinIntExpr & + y + + +Return expression for $\max(x,y)$. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::max + (const IntVarArgs &x) + max + + const IntVarArgs & + x + + +Return expression for $\max(x)$. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator* + (const LinIntExpr &x, const LinIntExpr &y) + operator* + + const LinIntExpr & + x + + + const LinIntExpr & + y + + +Return expression for $x\cdot y$. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator/ + (const LinIntExpr &x, const LinIntExpr &y) + operator/ + + const LinIntExpr & + x + + + const LinIntExpr & + y + + +Return expression for $x\ \mathrm{div}\ y$. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator% + (const LinIntExpr &x, const LinIntExpr &y) + operator% + + const LinIntExpr & + x + + + const LinIntExpr & + y + + +Return expression for $x\ \mathrm{mod}\ y$. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::sqr + (const LinIntExpr &x) + sqr + + const LinIntExpr & + x + + +Return expression for $x^2$. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::sqrt + (const LinIntExpr &x) + sqrt + + const LinIntExpr & + x + + +Return expression for $\lfloor\sqrt{x}\rfloor$. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::pow + (const LinIntExpr &x, int n) + pow + + const LinIntExpr & + x + + + int + n + + +Return expression for $x^n$. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::nroot + (const LinIntExpr &x, int n) + nroot + + const LinIntExpr & + x + + + int + n + + +Return expression for $\lfloor\sqrt[n]{x}\rfloor$. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::element + (const IntVarArgs &x, const LinIntExpr &y) + element + + const IntVarArgs & + x + + + const LinIntExpr & + y + + +Return expression for $x[y]$. + + + + + + + + GECODE_MINIMODEL_EXPORT BoolExpr + GECODE_MINIMODEL_EXPORT BoolExpr Gecode::element + (const BoolVarArgs &x, const LinIntExpr &y) + element + + const BoolVarArgs & + x + + + const LinIntExpr & + y + + +Return expression for $x[y]$. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::element + (const IntArgs &x, const LinIntExpr &y) + element + + const IntArgs & + x + + + const LinIntExpr & + y + + +Return expression for $x[y]$. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::ite + (const BoolExpr &b, const LinIntExpr &x, const LinIntExpr &y) + ite + + const BoolExpr & + b + + + const LinIntExpr & + x + + + const LinIntExpr & + y + + +Return expression for if-then-else $b?x:y$. + + + + + + + + BoolVar + BoolVar Gecode::channel + (Home home, IntVar x, IntConLevel icl=ICL_DEF) + channel + + Home + home + + + IntVar + x + + + IntConLevel + icl + ICL_DEF + + +Return Boolean variable equal to $x$. + + + + + + + + IntVar + IntVar Gecode::channel + (Home home, BoolVar b, IntConLevel icl=ICL_DEF) + channel + + Home + home + + + BoolVar + b + + + IntConLevel + icl + ICL_DEF + + +Return integer variable equal to $b$. + + + + + + + + void + void Gecode::atmost + (Home home, const IntVarArgs &x, int n, int m, IntConLevel icl=ICL_DEF) + atmost + + Home + home + + + const IntVarArgs & + x + + + int + n + + + int + m + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=n\}\leq m$. + +Supports domain consistent propagation only. + + + + + + void + void Gecode::atmost + (Home home, const IntVarArgs &x, IntVar y, int m, IntConLevel icl=ICL_DEF) + atmost + + Home + home + + + const IntVarArgs & + x + + + IntVar + y + + + int + m + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y\}\leq m$. + +Supports domain consistent propagation only. + + + + + + void + void Gecode::atmost + (Home home, const IntVarArgs &x, const IntArgs &y, int m, IntConLevel icl=ICL_DEF) + atmost + + Home + home + + + const IntVarArgs & + x + + + const IntArgs & + y + + + int + m + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y_i\}\leq m$. + +Supports domain consistent propagation only.Throws an exception of type Int::ArgumentSizeMismatch, if x and y are of different size. + + + + + + void + void Gecode::atmost + (Home home, const IntVarArgs &x, int n, IntVar z, IntConLevel icl=ICL_DEF) + atmost + + Home + home + + + const IntVarArgs & + x + + + int + n + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=n\}\leq z$. + +Supports domain consistent propagation only. + + + + + + void + void Gecode::atmost + (Home home, const IntVarArgs &x, IntVar y, IntVar z, IntConLevel icl=ICL_DEF) + atmost + + Home + home + + + const IntVarArgs & + x + + + IntVar + y + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y\}\leq z$. + +Supports domain consistent propagation only. + + + + + + void + void Gecode::atmost + (Home home, const IntVarArgs &x, const IntArgs &y, IntVar z, IntConLevel icl=ICL_DEF) + atmost + + Home + home + + + const IntVarArgs & + x + + + const IntArgs & + y + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y_i\}\leq z$. + +Supports domain consistent propagation only.Throws an exception of type Int::ArgumentSizeMismatch, if x and y are of different size. + + + + + + void + void Gecode::atleast + (Home home, const IntVarArgs &x, int n, int m, IntConLevel icl=ICL_DEF) + atleast + + Home + home + + + const IntVarArgs & + x + + + int + n + + + int + m + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=n\}\geq m$. + +Supports domain consistent propagation only. + + + + + + void + void Gecode::atleast + (Home home, const IntVarArgs &x, IntVar y, int m, IntConLevel icl=ICL_DEF) + atleast + + Home + home + + + const IntVarArgs & + x + + + IntVar + y + + + int + m + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y\}\geq m$. + +Supports domain consistent propagation only. + + + + + + void + void Gecode::atleast + (Home home, const IntVarArgs &x, const IntArgs &y, int m, IntConLevel icl=ICL_DEF) + atleast + + Home + home + + + const IntVarArgs & + x + + + const IntArgs & + y + + + int + m + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y_i\}\geq m$. + +Supports domain consistent propagation only.Throws an exception of type Int::ArgumentSizeMismatch, if x and y are of different size. + + + + + + void + void Gecode::atleast + (Home home, const IntVarArgs &x, int n, IntVar z, IntConLevel icl=ICL_DEF) + atleast + + Home + home + + + const IntVarArgs & + x + + + int + n + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=n\}\geq z$. + +Supports domain consistent propagation only. + + + + + + void + void Gecode::atleast + (Home home, const IntVarArgs &x, IntVar y, IntVar z, IntConLevel icl=ICL_DEF) + atleast + + Home + home + + + const IntVarArgs & + x + + + IntVar + y + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y\}\geq z$. + +Supports domain consistent propagation only. + + + + + + void + void Gecode::atleast + (Home home, const IntVarArgs &x, const IntArgs &y, IntVar z, IntConLevel icl=ICL_DEF) + atleast + + Home + home + + + const IntVarArgs & + x + + + const IntArgs & + y + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y_i\}\geq z$. + +Supports domain consistent propagation only.Throws an exception of type Int::ArgumentSizeMismatch, if x and y are of different size. + + + + + + void + void Gecode::exactly + (Home home, const IntVarArgs &x, int n, int m, IntConLevel icl=ICL_DEF) + exactly + + Home + home + + + const IntVarArgs & + x + + + int + n + + + int + m + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=n\}=m$. + +Supports domain consistent propagation only. + + + + + + void + void Gecode::exactly + (Home home, const IntVarArgs &x, IntVar y, int m, IntConLevel icl=ICL_DEF) + exactly + + Home + home + + + const IntVarArgs & + x + + + IntVar + y + + + int + m + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y\}=m$. + +Supports domain consistent propagation only. + + + + + + void + void Gecode::exactly + (Home home, const IntVarArgs &x, const IntArgs &y, int m, IntConLevel icl=ICL_DEF) + exactly + + Home + home + + + const IntVarArgs & + x + + + const IntArgs & + y + + + int + m + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y_i\}=m$. + +Supports domain consistent propagation only.Throws an exception of type Int::ArgumentSizeMismatch, if x and y are of different size. + + + + + + void + void Gecode::exactly + (Home home, const IntVarArgs &x, int n, IntVar z, IntConLevel icl=ICL_DEF) + exactly + + Home + home + + + const IntVarArgs & + x + + + int + n + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=n\}=z$. + +Supports domain consistent propagation only. + + + + + + void + void Gecode::exactly + (Home home, const IntVarArgs &x, IntVar y, IntVar z, IntConLevel icl=ICL_DEF) + exactly + + Home + home + + + const IntVarArgs & + x + + + IntVar + y + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y\}=z$. + +Supports domain consistent propagation only. + + + + + + void + void Gecode::exactly + (Home home, const IntVarArgs &x, const IntArgs &y, IntVar z, IntConLevel icl=ICL_DEF) + exactly + + Home + home + + + const IntVarArgs & + x + + + const IntArgs & + y + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y_i\}=z$. + +Supports domain consistent propagation only.Throws an exception of type Int::ArgumentSizeMismatch, if x and y are of different size. + + + + + + void + void Gecode::lex + (Home home, const IntVarArgs &x, IntRelType r, const IntVarArgs &y, IntConLevel icl=ICL_DEF) + lex + + Home + home + + + const IntVarArgs & + x + + + IntRelType + r + + + const IntVarArgs & + y + + + IntConLevel + icl + ICL_DEF + + +Post lexical order between x and y. + + + + + + + + void + void Gecode::lex + (Home home, const BoolVarArgs &x, IntRelType r, const BoolVarArgs &y, IntConLevel icl=ICL_DEF) + lex + + Home + home + + + const BoolVarArgs & + x + + + IntRelType + r + + + const BoolVarArgs & + y + + + IntConLevel + icl + ICL_DEF + + +Post lexical order between x and y. + + + + + + + + void + void Gecode::values + (Home home, const IntVarArgs &x, IntSet y, IntConLevel icl=ICL_DEF) + values + + Home + home + + + const IntVarArgs & + x + + + IntSet + y + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\{x_0,\dots,x_{n-1}\}=y$. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::sum + (const Slice< IntArgs > &slice) + sum + + const Slice< IntArgs > & + slice + + +Construct linear expression as sum of IntArgs Slice elements. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::sum + (const Matrix< IntArgs > &matrix) + sum + + const Matrix< IntArgs > & + matrix + + +Construct linear expression as sum of IntArgs Matrix elements. + + + + + + + + + + class T + + + T * + T * Gecode::bab + (T *s, const Search::Options &o=Search::Options::def) + bab + + T * + s + + + const Search::Options & + o + Search::Options::def + + +Perform depth-first branch-and-bound search for subclass T of space s and options o. + +Additionally, s must implement a member function virtualvoidconstrain(constT&t) + Whenever exploration requires to add a constraint to the space c currently being explored, the engine executes c.constrain(t) where t is the so-far best solution. + + + + + + + + class T + + + forceinline T * + forceinline T* Gecode::dfs + (T *s, const Search::Options &o) + dfs + + T * + s + + + const Search::Options & + o + + +Invoke depth-first search engine for subclass T of space s with options o. + + + + + + + + + + template< class > class + E + E + + + class T + + + forceinline T * + forceinline T* Gecode::rbs + (T *s, const Search::Options &o) + rbs + + T * + s + + + const Search::Options & + o + + +Perform restart-based search. + +The engine uses the Cutoff sequence supplied in the options o to periodically restart the search of engine E.The class T can implement member functions virtualboolmaster(constCRI&cri) + and virtualboolslave(constCRI&cri) +Whenever exploration restarts or a solution is found, the engine executes the functions on the master and slave space. For more details, consult "Modeling and Programming +with Gecode". + + + + + + + + class T + + + T * + T* Gecode::dfs + (T *s, const Search::Options &o=Search::Options::def) + dfs + + T * + s + + + const Search::Options & + o + Search::Options::def + + +Invoke depth-first search engine for subclass T of space s with options o. + + + + + + + + + + template< class > class + E + E + + + class T + + + T * + T* Gecode::rbs + (T *s, const Search::Options &o) + rbs + + T * + s + + + const Search::Options & + o + + +Perform restart-based search. + +The engine uses the Cutoff sequence supplied in the options o to periodically restart the search of engine E.The class T can implement member functions virtualboolmaster(constCRI&cri) + and virtualboolslave(constCRI&cri) +Whenever exploration restarts or a solution is found, the engine executes the functions on the master and slave space. For more details, consult "Modeling and Programming +with Gecode". + + + + + + SetAssign + SetAssign Gecode::SET_ASSIGN_MIN_INC + (void) + SET_ASSIGN_MIN_INC + + void + + +Include smallest element. + + + + + + + + SetAssign + SetAssign Gecode::SET_ASSIGN_MIN_EXC + (void) + SET_ASSIGN_MIN_EXC + + void + + +Exclude smallest element. + + + + + + + + SetAssign + SetAssign Gecode::SET_ASSIGN_MED_INC + (void) + SET_ASSIGN_MED_INC + + void + + +Include median element (rounding downwards) + + + + + + + + SetAssign + SetAssign Gecode::SET_ASSIGN_MED_EXC + (void) + SET_ASSIGN_MED_EXC + + void + + +Exclude median element (rounding downwards) + + + + + + + + SetAssign + SetAssign Gecode::SET_ASSIGN_MAX_INC + (void) + SET_ASSIGN_MAX_INC + + void + + +Include largest element. + + + + + + + + SetAssign + SetAssign Gecode::SET_ASSIGN_MAX_EXC + (void) + SET_ASSIGN_MAX_EXC + + void + + +Exclude largest element. + + + + + + + + SetAssign + SetAssign Gecode::SET_ASSIGN_RND_INC + (Rnd r) + SET_ASSIGN_RND_INC + + Rnd + r + + +Include random element. + + + + + + + + SetAssign + SetAssign Gecode::SET_ASSIGN_RND_EXC + (Rnd r) + SET_ASSIGN_RND_EXC + + Rnd + r + + +Exclude random element. + + + + + + + + SetAssign + SetAssign Gecode::SET_ASSIGN + (SetBranchVal v, SetBranchCommit c=NULL) + SET_ASSIGN + + SetBranchVal + v + + + SetBranchCommit + c + NULL + + +Select value as defined by the value function v and commit function c. + +The default commit function posts the constraint that the value n must be included in the set variable x. + + + + + + SetValBranch + SetValBranch Gecode::SET_VAL_MIN_INC + (void) + SET_VAL_MIN_INC + + void + + +Include smallest element. + + + + + + + + SetValBranch + SetValBranch Gecode::SET_VAL_MIN_EXC + (void) + SET_VAL_MIN_EXC + + void + + +Exclude smallest element. + + + + + + + + SetValBranch + SetValBranch Gecode::SET_VAL_MED_INC + (void) + SET_VAL_MED_INC + + void + + +Include median element (rounding downwards) + + + + + + + + SetValBranch + SetValBranch Gecode::SET_VAL_MED_EXC + (void) + SET_VAL_MED_EXC + + void + + +Exclude median element (rounding downwards) + + + + + + + + SetValBranch + SetValBranch Gecode::SET_VAL_MAX_INC + (void) + SET_VAL_MAX_INC + + void + + +Include largest element. + + + + + + + + SetValBranch + SetValBranch Gecode::SET_VAL_MAX_EXC + (void) + SET_VAL_MAX_EXC + + void + + +Exclude largest element. + + + + + + + + SetValBranch + SetValBranch Gecode::SET_VAL_RND_INC + (Rnd r) + SET_VAL_RND_INC + + Rnd + r + + +Include random element. + + + + + + + + SetValBranch + SetValBranch Gecode::SET_VAL_RND_EXC + (Rnd r) + SET_VAL_RND_EXC + + Rnd + r + + +Exclude random element. + + + + + + + + SetValBranch + SetValBranch Gecode::SET_VAL + (SetBranchVal v, SetBranchCommit c=NULL) + SET_VAL + + SetBranchVal + v + + + SetBranchCommit + c + NULL + + +Select value as defined by the value function v and commit function c. + +The default commit function posts the constraint that the value n must be included in the set variable x for the first alternative, and that n must be excluded from x otherwise. + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_NONE + (void) + SET_VAR_NONE + + void + + +Select first unassigned variable. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_RND + (Rnd r) + SET_VAR_RND + + Rnd + r + + +Select random variable (uniform distribution, for tie breaking) + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_MERIT_MIN + (SetBranchMerit bm, BranchTbl tbl=NULL) + SET_VAR_MERIT_MIN + + SetBranchMerit + bm + + + BranchTbl + tbl + + +Select variable with least merit according to branch merit function bm. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_MERIT_MAX + (SetBranchMerit bm, BranchTbl tbl=NULL) + SET_VAR_MERIT_MAX + + SetBranchMerit + bm + + + BranchTbl + tbl + + +Select variable with highest merit according to branch merit function bm. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_DEGREE_MIN + (BranchTbl tbl=NULL) + SET_VAR_DEGREE_MIN + + BranchTbl + tbl + + +Select variable with smallest degree. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_DEGREE_MAX + (BranchTbl tbl=NULL) + SET_VAR_DEGREE_MAX + + BranchTbl + tbl + + +Select variable with largest degree. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_AFC_MIN + (double d=1.0, BranchTbl tbl=NULL) + SET_VAR_AFC_MIN + + double + d + + + BranchTbl + tbl + + +Select variable with smallest accumulated failure count with decay factor d. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_AFC_MIN + (SetAFC a, BranchTbl tbl=NULL) + SET_VAR_AFC_MIN + + SetAFC + a + + + BranchTbl + tbl + + +Select variable with smallest accumulated failure count. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_AFC_MAX + (double d=1.0, BranchTbl tbl=NULL) + SET_VAR_AFC_MAX + + double + d + + + BranchTbl + tbl + + +Select variable with largest accumulated failure count with decay factor d. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_AFC_MAX + (SetAFC a, BranchTbl tbl=NULL) + SET_VAR_AFC_MAX + + SetAFC + a + + + BranchTbl + tbl + + +Select variable with largest accumulated failure count. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_ACTIVITY_MIN + (double d=1.0, BranchTbl tbl=NULL) + SET_VAR_ACTIVITY_MIN + + double + d + + + BranchTbl + tbl + + +Select variable with lowest activity with decay factor d. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_ACTIVITY_MIN + (SetActivity a, BranchTbl tbl=NULL) + SET_VAR_ACTIVITY_MIN + + SetActivity + a + + + BranchTbl + tbl + + +Select variable with lowest activity. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_ACTIVITY_MAX + (double d=1.0, BranchTbl tbl=NULL) + SET_VAR_ACTIVITY_MAX + + double + d + + + BranchTbl + tbl + + +Select variable with highest activity with decay factor d. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_ACTIVITY_MAX + (SetActivity a, BranchTbl tbl=NULL) + SET_VAR_ACTIVITY_MAX + + SetActivity + a + + + BranchTbl + tbl + + +Select variable with highest activity. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_MIN_MIN + (BranchTbl tbl=NULL) + SET_VAR_MIN_MIN + + BranchTbl + tbl + + +Select variable with smallest minimum unknown element. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_MIN_MAX + (BranchTbl tbl=NULL) + SET_VAR_MIN_MAX + + BranchTbl + tbl + + +Select variable with largest minimum unknown element. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_MAX_MIN + (BranchTbl tbl=NULL) + SET_VAR_MAX_MIN + + BranchTbl + tbl + + +Select variable with smallest maximum unknown element. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_MAX_MAX + (BranchTbl tbl=NULL) + SET_VAR_MAX_MAX + + BranchTbl + tbl + + +Select variable with largest maximum unknown element. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_SIZE_MIN + (BranchTbl tbl=NULL) + SET_VAR_SIZE_MIN + + BranchTbl + tbl + + +Select variable with smallest unknown set. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_SIZE_MAX + (BranchTbl tbl=NULL) + SET_VAR_SIZE_MAX + + BranchTbl + tbl + + +Select variable with largest unknown set. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_DEGREE_SIZE_MIN + (BranchTbl tbl=NULL) + SET_VAR_DEGREE_SIZE_MIN + + BranchTbl + tbl + + +Select variable with smallest degree divided by domain size. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_DEGREE_SIZE_MAX + (BranchTbl tbl=NULL) + SET_VAR_DEGREE_SIZE_MAX + + BranchTbl + tbl + + +Select variable with largest degree divided by domain size. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_AFC_SIZE_MIN + (double d=1.0, BranchTbl tbl=NULL) + SET_VAR_AFC_SIZE_MIN + + double + d + + + BranchTbl + tbl + + +Select variable with smallest accumulated failure count divided by domain size with decay factor d. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_AFC_SIZE_MIN + (SetAFC a, BranchTbl tbl=NULL) + SET_VAR_AFC_SIZE_MIN + + SetAFC + a + + + BranchTbl + tbl + + +Select variable with smallest accumulated failure count divided by domain size. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_AFC_SIZE_MAX + (double d=1.0, BranchTbl tbl=NULL) + SET_VAR_AFC_SIZE_MAX + + double + d + + + BranchTbl + tbl + + +Select variable with largest accumulated failure count divided by domain size with decay factor d. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_AFC_SIZE_MAX + (SetAFC a, BranchTbl tbl=NULL) + SET_VAR_AFC_SIZE_MAX + + SetAFC + a + + + BranchTbl + tbl + + +Select variable with largest accumulated failure count divided by domain size. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_ACTIVITY_SIZE_MIN + (double d=1.0, BranchTbl tbl=NULL) + SET_VAR_ACTIVITY_SIZE_MIN + + double + d + + + BranchTbl + tbl + + +Select variable with smallest activity divided by domain size with decay factor d. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_ACTIVITY_SIZE_MIN + (SetActivity a, BranchTbl tbl=NULL) + SET_VAR_ACTIVITY_SIZE_MIN + + SetActivity + a + + + BranchTbl + tbl + + +Select variable with smallest activity divided by domain size. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_ACTIVITY_SIZE_MAX + (double d=1.0, BranchTbl tbl=NULL) + SET_VAR_ACTIVITY_SIZE_MAX + + double + d + + + BranchTbl + tbl + + +Select variable with largest activity divided by domain size with decay factor d. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_ACTIVITY_SIZE_MAX + (SetActivity a, BranchTbl tbl=NULL) + SET_VAR_ACTIVITY_SIZE_MAX + + SetActivity + a + + + BranchTbl + tbl + + +Select variable with largest activity divided by domain size. + + + + + + + + + + class View0 + + + class View1 + + + forceinline bool + forceinline bool Gecode::viewarrayshared + (const Space &home, const ViewArray< View0 > &va, const View1 &y) + viewarrayshared + + const Space & + home + + + const ViewArray< View0 > & + va + + + const View1 & + y + + + + + + + + + + + + + forceinline bool + forceinline bool Gecode::viewarrayshared< Set::SingletonView, Set::SetView > + (const Space &, const ViewArray< Set::SingletonView > &, const Set::SetView &) + viewarrayshared< Set::SingletonView, Set::SetView > + + const Space & + + + const ViewArray< Set::SingletonView > & + + + const Set::SetView & + + + + + + + + + + + + + class Char + + + class Traits + + + std::basic_ostream< Char, Traits > & + std::basic_ostream<Char,Traits>& Gecode::operator<< + (std::basic_ostream< Char, Traits > &os, const SetVar &x) + operator<< + + std::basic_ostream< Char, Traits > & + os + + + const SetVar & + x + + + + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::dom + (Home home, SetVar x, SetRelType r, int i) + dom + + Home + home + + + SetVar + x + + + SetRelType + r + + + int + i + + +Propagates $ x \sim_r \{i\}$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::dom + (Home home, const SetVarArgs &x, SetRelType r, int i) + dom + + Home + home + + + const SetVarArgs & + x + + + SetRelType + r + + + int + i + + +Propagates $ x_i \sim_r \{i\}$ for all $0\leq i<|x|$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::dom + (Home home, SetVar x, SetRelType r, int i, int j) + dom + + Home + home + + + SetVar + x + + + SetRelType + r + + + int + i + + + int + j + + +Propagates $ x \sim_r \{i,\dots,j\}$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::dom + (Home home, const SetVarArgs &x, SetRelType r, int i, int j) + dom + + Home + home + + + const SetVarArgs & + x + + + SetRelType + r + + + int + i + + + int + j + + +Propagates $ x \sim_r \{i,\dots,j\}$ for all $0\leq i<|x|$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::dom + (Home home, SetVar x, SetRelType r, const IntSet &s) + dom + + Home + home + + + SetVar + x + + + SetRelType + r + + + const IntSet & + s + + +Propagates $ x \sim_r s$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::dom + (Home home, const SetVarArgs &x, SetRelType r, const IntSet &s) + dom + + Home + home + + + const SetVarArgs & + x + + + SetRelType + r + + + const IntSet & + s + + +Propagates $ x \sim_r s$ for all $0\leq i<|x|$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::cardinality + (Home home, SetVar x, unsigned int i, unsigned int j) + cardinality + + Home + home + + + SetVar + x + + + unsigned int + i + + + unsigned int + j + + +Propagates $ i \leq |s| \leq j $. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::cardinality + (Home home, const SetVarArgs &x, unsigned int i, unsigned int j) + cardinality + + Home + home + + + const SetVarArgs & + x + + + unsigned int + i + + + unsigned int + j + + +Propagates $ i \leq |s| \leq j $ for all $0\leq i<|x|$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::dom + (Home home, SetVar x, SetRelType rt, int i, Reify r) + dom + + Home + home + + + SetVar + x + + + SetRelType + rt + + + int + i + + + Reify + r + + +Post propagator for $ (x \sim_{rt} \{i\}) \equiv r $. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::dom + (Home home, SetVar x, SetRelType rt, int i, int j, Reify r) + dom + + Home + home + + + SetVar + x + + + SetRelType + rt + + + int + i + + + int + j + + + Reify + r + + +Post propagator for $ (x \sim_{rt} \{i,\dots,j\}) \equiv r $. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::dom + (Home home, SetVar x, SetRelType rt, const IntSet &s, Reify r) + dom + + Home + home + + + SetVar + x + + + SetRelType + rt + + + const IntSet & + s + + + Reify + r + + +Post propagator for $ (x \sim_{rt} s) \equiv r $. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::dom + (Home home, SetVar x, SetVar d) + dom + + Home + home + + + SetVar + x + + + SetVar + d + + +Constrain domain of x according to domain of d. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::dom + (Home home, const SetVarArgs &x, const SetVarArgs &d) + dom + + Home + home + + + const SetVarArgs & + x + + + const SetVarArgs & + d + + +Constrain domain of $ x_i $ according to domain of $ d_i $ for all $0\leq i<|x|$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::rel + (Home home, SetVar x, SetRelType r, SetVar y) + rel + + Home + home + + + SetVar + x + + + SetRelType + r + + + SetVar + y + + +Post propagator for $ x \sim_r y$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::rel + (Home home, SetVar x, SetRelType rt, SetVar y, Reify r) + rel + + Home + home + + + SetVar + x + + + SetRelType + rt + + + SetVar + y + + + Reify + r + + +Post propagator for $ (x \sim_{rt} y) \equiv r$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::rel + (Home home, SetVar s, SetRelType r, IntVar x) + rel + + Home + home + + + SetVar + s + + + SetRelType + r + + + IntVar + x + + +Post propagator for $ s \sim_r \{x\}$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::rel + (Home home, IntVar x, SetRelType r, SetVar s) + rel + + Home + home + + + IntVar + x + + + SetRelType + r + + + SetVar + s + + +Post propagator for $ \{x\} \sim_r s$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::rel + (Home home, SetVar s, SetRelType rt, IntVar x, Reify r) + rel + + Home + home + + + SetVar + s + + + SetRelType + rt + + + IntVar + x + + + Reify + r + + +Post propagator for $ (s \sim_{rt} \{x\}) \equiv r$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::rel + (Home home, IntVar x, SetRelType rt, SetVar s, Reify r) + rel + + Home + home + + + IntVar + x + + + SetRelType + rt + + + SetVar + s + + + Reify + r + + +Post propagator for $ (\{x\} \sim_{rt} s) \equiv r $. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::rel + (Home home, SetVar s, IntRelType r, IntVar x) + rel + + Home + home + + + SetVar + s + + + IntRelType + r + + + IntVar + x + + +Post propagator for $|s|\geq 1 \land \forall i\in s:\ i \sim_r x$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::rel + (Home home, IntVar x, IntRelType r, SetVar s) + rel + + Home + home + + + IntVar + x + + + IntRelType + r + + + SetVar + s + + +Post propagator for $|s|\geq 1 \land \forall i\in s:\ x \sim_r i$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::rel + (Home home, SetVar x, SetOpType op, SetVar y, SetRelType r, SetVar z) + rel + + Home + home + + + SetVar + x + + + SetOpType + op + + + SetVar + y + + + SetRelType + r + + + SetVar + z + + +Post propagator for $ (x \diamond_{\mathit{op}} y) \sim_r z $. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::rel + (Home home, SetOpType op, const SetVarArgs &x, SetVar y) + rel + + Home + home + + + SetOpType + op + + + const SetVarArgs & + x + + + SetVar + y + + +Post propagator for $ y = \diamond_{\mathit{op}} x$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::rel + (Home home, SetOpType op, const SetVarArgs &x, const IntSet &z, SetVar y) + rel + + Home + home + + + SetOpType + op + + + const SetVarArgs & + x + + + const IntSet & + z + + + SetVar + y + + +Post propagator for $ y = \diamond_{\mathit{op}} x \diamond_{\mathit{op}} z$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::rel + (Home home, SetOpType op, const IntVarArgs &x, const IntSet &z, SetVar y) + rel + + Home + home + + + SetOpType + op + + + const IntVarArgs & + x + + + const IntSet & + z + + + SetVar + y + + +Post propagator for $ y = \diamond_{\mathit{op}} x \diamond_{\mathit{op}} z$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::rel + (Home home, SetOpType op, const IntVarArgs &x, SetVar y) + rel + + Home + home + + + SetOpType + op + + + const IntVarArgs & + x + + + SetVar + y + + +Post propagator for $ y = \diamond_{\mathit{op}} x$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::rel + (Home home, const IntSet &x, SetOpType op, SetVar y, SetRelType r, SetVar z) + rel + + Home + home + + + const IntSet & + x + + + SetOpType + op + + + SetVar + y + + + SetRelType + r + + + SetVar + z + + +Post propagator for $ (x \diamond_{\mathit{op}} y) \sim_r z $. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::rel + (Home home, SetVar x, SetOpType op, const IntSet &y, SetRelType r, SetVar z) + rel + + Home + home + + + SetVar + x + + + SetOpType + op + + + const IntSet & + y + + + SetRelType + r + + + SetVar + z + + +Post propagator for $ (x \diamond_{\mathit{op}} y) \sim_r z $. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::rel + (Home home, SetVar x, SetOpType op, SetVar y, SetRelType r, const IntSet &z) + rel + + Home + home + + + SetVar + x + + + SetOpType + op + + + SetVar + y + + + SetRelType + r + + + const IntSet & + z + + +Post propagator for $ (x \diamond_{\mathit{op}} y) \sim_r z $. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::rel + (Home home, const IntSet &x, SetOpType op, SetVar y, SetRelType r, const IntSet &z) + rel + + Home + home + + + const IntSet & + x + + + SetOpType + op + + + SetVar + y + + + SetRelType + r + + + const IntSet & + z + + +Post propagator for $ (x \diamond_{\mathit{op}} y) \sim_r z $. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::rel + (Home home, SetVar x, SetOpType op, const IntSet &y, SetRelType r, const IntSet &z) + rel + + Home + home + + + SetVar + x + + + SetOpType + op + + + const IntSet & + y + + + SetRelType + r + + + const IntSet & + z + + +Post propagator for $ (x \diamond_{\mathit{op}} y) \sim_r z $. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::convex + (Home home, SetVar x) + convex + + Home + home + + + SetVar + x + + +Post propagator that propagates that x is convex. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::convex + (Home home, SetVar x, SetVar y) + convex + + Home + home + + + SetVar + x + + + SetVar + y + + +Post propagator that propagates that y is the convex hull of x. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::sequence + (Home home, const SetVarArgs &x) + sequence + + Home + home + + + const SetVarArgs & + x + + +Post propagator for $\forall 0\leq i< |x|-1 : \max(x_i)<\min(x_{i+1})$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::sequence + (Home home, const SetVarArgs &y, SetVar x) + sequence + + Home + home + + + const SetVarArgs & + y + + + SetVar + x + + +Post propagator for $\forall 0\leq i< |x|-1 : \max(x_i)<\min(x_{i+1})$ and $ x = \bigcup_{i\in\{0,\dots,n-1\}} y_i $. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::atmostOne + (Home home, const SetVarArgs &x, unsigned int c) + atmostOne + + Home + home + + + const SetVarArgs & + x + + + unsigned int + c + + +Post propagator for $\forall 0\leq i\leq |x| : |x_i|=c$ and $\forall 0\leq i<j\leq |x| : |x_i\cap x_j|\leq 1$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::min + (Home home, SetVar s, IntVar x) + min + + Home + home + + + SetVar + s + + + IntVar + x + + +Post propagator that propagates that x is the minimal element of s, and that s is not empty. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::notMin + (Home home, SetVar s, IntVar x) + notMin + + Home + home + + + SetVar + s + + + IntVar + x + + +Post propagator that propagates that x is not the minimal element of s. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::min + (Home home, SetVar s, IntVar x, Reify r) + min + + Home + home + + + SetVar + s + + + IntVar + x + + + Reify + r + + +Post reified propagator for b iff x is the minimal element of s. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::max + (Home home, SetVar s, IntVar x) + max + + Home + home + + + SetVar + s + + + IntVar + x + + +Post propagator that propagates that x is the maximal element of s, and that s is not empty. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::notMax + (Home home, SetVar s, IntVar x) + notMax + + Home + home + + + SetVar + s + + + IntVar + x + + +Post propagator that propagates that x is not the maximal element of s. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::max + (Home home, SetVar s, IntVar x, Reify r) + max + + Home + home + + + SetVar + s + + + IntVar + x + + + Reify + r + + +Post reified propagator for b iff x is the maximal element of s. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::cardinality + (Home home, SetVar s, IntVar x) + cardinality + + Home + home + + + SetVar + s + + + IntVar + x + + +Post propagator for $ |s|=x $. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::weights + (Home home, IntSharedArray elements, IntSharedArray weights, SetVar x, IntVar y) + weights + + Home + home + + + IntSharedArray + elements + + + IntSharedArray + weights + + + SetVar + x + + + IntVar + y + + +Post propagator for $y = \mathrm{weight}(x)$. + +The weights are given as pairs of elements and their weight: $\mathrm{weight}(\mathrm{elements}_i) = \mathrm{weights}_i$The upper bound of x is constrained to contain only elements from elements. The weight of a set is the sum of the weights of its elements. + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::channel + (Home home, const IntVarArgs &x, const SetVarArgs &y) + channel + + Home + home + + + const IntVarArgs & + x + + + const SetVarArgs & + y + + +Post propagator for $x_i=j \Leftrightarrow i\in y_j$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::channelSorted + (Home home, const IntVarArgs &x, SetVar y) + channelSorted + + Home + home + + + const IntVarArgs & + x + + + SetVar + y + + +Post propagator for $\{x_0,\dots,x_{n-1}\}=y$ and $x_i<x_{i+1}$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::channel + (Home home, const BoolVarArgs &x, SetVar y) + channel + + Home + home + + + const BoolVarArgs & + x + + + SetVar + y + + +Post propagator for $x_i=1 \Leftrightarrow i\in y$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::channel + (Home home, const SetVarArgs &x, const SetVarArgs &y) + channel + + Home + home + + + const SetVarArgs & + x + + + const SetVarArgs & + y + + +Post propagator for $j\in x_i \Leftrightarrow i\in y_j$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::precede + (Home home, const SetVarArgs &x, int s, int t) + precede + + Home + home + + + const SetVarArgs & + x + + + int + s + + + int + t + + +Post propagator that s precedes t in x. + +This constraint enforces that if there exists $j$ such that $s\notin x_j\land t\in x_j$, then there exists $i<j$ such that $s\in x_i\land t\notin x_i$. + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::precede + (Home home, const SetVarArgs &x, const IntArgs &c) + precede + + Home + home + + + const SetVarArgs & + x + + + const IntArgs & + c + + +Post propagator that successive values in c precede each other in x. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::element + (Home home, SetOpType op, const SetVarArgs &x, SetVar y, SetVar z, const IntSet &u=IntSet(Set::Limits::min, Set::Limits::max)) + element + + Home + home + + + SetOpType + op + + + const SetVarArgs & + x + + + SetVar + y + + + SetVar + z + + + const IntSet & + u + IntSet(Set::Limits::min, Set::Limits::max) + + +Post propagator for $ z=\diamond_{\mathit{op}}\langle x_0,\dots,x_{n-1}\rangle[y] $. + +If y is the empty set, the usual conventions for set operations apply: an empty union is empty, while an empty intersection is the universe, which can be given as the optional parameter u.The indices for y start at 0. + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::element + (Home home, SetOpType op, const IntVarArgs &x, SetVar y, SetVar z, const IntSet &u=IntSet(Set::Limits::min, Set::Limits::max)) + element + + Home + home + + + SetOpType + op + + + const IntVarArgs & + x + + + SetVar + y + + + SetVar + z + + + const IntSet & + u + IntSet(Set::Limits::min, Set::Limits::max) + + +Post propagator for $ z=\diamond_{\mathit{op}}\langle \{x_0\},\dots,\{x_{n-1}\}\rangle[y] $. + +If y is the empty set, the usual conventions for set operations apply: an empty union is empty, while an empty intersection is the universe, which can be given as the optional parameter u.The indices for y start at 0. + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::element + (Home home, SetOpType op, const IntSetArgs &x, SetVar y, SetVar z, const IntSet &u=IntSet(Set::Limits::min, Set::Limits::max)) + element + + Home + home + + + SetOpType + op + + + const IntSetArgs & + x + + + SetVar + y + + + SetVar + z + + + const IntSet & + u + IntSet(Set::Limits::min, Set::Limits::max) + + +Post propagator for $ z=\diamond_{\mathit{op}}\langle x_0,\dots,x_{n-1}\rangle[y] $. + +If y is the empty set, the usual conventions for set operations apply: an empty union is empty, while an empty intersection is the universe, which can be given as the optional parameter u.The indices for y start at 0. + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::element + (Home home, SetOpType op, const IntArgs &x, SetVar y, SetVar z, const IntSet &u=IntSet(Set::Limits::min, Set::Limits::max)) + element + + Home + home + + + SetOpType + op + + + const IntArgs & + x + + + SetVar + y + + + SetVar + z + + + const IntSet & + u + IntSet(Set::Limits::min, Set::Limits::max) + + +Post propagator for $ z=\diamond_{\mathit{op}}\langle \{x_0\},\dots,\{x_{n-1}\}\rangle[y] $. + +If y is the empty set, the usual conventions for set operations apply: an empty union is empty, while an empty intersection is the universe, which can be given as the optional parameter u.The indices for y start at 0. + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::element + (Home home, const SetVarArgs &x, IntVar y, SetVar z) + element + + Home + home + + + const SetVarArgs & + x + + + IntVar + y + + + SetVar + z + + +Post propagator for $ z=\langle x_0,\dots,x_{n-1}\rangle[y] $. + +The indices for y start at 0. + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::element + (Home home, const IntSetArgs &s, IntVar y, SetVar z) + element + + Home + home + + + const IntSetArgs & + s + + + IntVar + y + + + SetVar + z + + +Post propagator for $ z=\langle s_0,\dots,s_{n-1}\rangle[y] $. + +The indices for y start at 0. + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::element + (Home home, const IntSetArgs &a, IntVar x, int w, IntVar y, int h, SetVar z) + element + + Home + home + + + const IntSetArgs & + a + + + IntVar + x + + + int + w + + + IntVar + y + + + int + h + + + SetVar + z + + +Post propagator for $ a_{x+w\cdot y}=z$. + +Throws an exception of type Set::ArgumentSizeMismatch, if $ w\cdot h\neq|a|$. + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::element + (Home home, const SetVarArgs &a, IntVar x, int w, IntVar y, int h, SetVar z) + element + + Home + home + + + const SetVarArgs & + a + + + IntVar + x + + + int + w + + + IntVar + y + + + int + h + + + SetVar + z + + +Post propagator for $ a_{x+w\cdot y}=z$. + +Throws an exception of type Set::ArgumentSizeMismatch, if $ w\cdot h\neq|a|$. + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::wait + (Home home, SetVar x, void(*c)(Space &home)) + wait + + Home + home + + + SetVar + x + + + void(*)(Space &home) + c + + +Execute c when x becomes assigned. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::wait + (Home home, const SetVarArgs &x, void(*c)(Space &home)) + wait + + Home + home + + + const SetVarArgs & + x + + + void(*)(Space &home) + c + + +Execute c when all variables in x become assigned. + + + + + + + + GECODE_SET_EXPORT BrancherHandle + GECODE_SET_EXPORT BrancherHandle Gecode::branch + (Home home, const SetVarArgs &x, SetVarBranch vars, SetValBranch vals, SetBranchFilter bf=NULL, SetVarValPrint vvp=NULL) + branch + + Home + home + + + const SetVarArgs & + x + + + SetVarBranch + vars + + + SetValBranch + vals + + + SetBranchFilter + bf + NULL + + + SetVarValPrint + vvp + NULL + + +Branch over x with variable selection vars and value selection vals. + + + + + + + + GECODE_SET_EXPORT BrancherHandle + GECODE_SET_EXPORT BrancherHandle Gecode::branch + (Home home, const SetVarArgs &x, TieBreak< SetVarBranch > vars, SetValBranch vals, SetBranchFilter bf=NULL, SetVarValPrint vvp=NULL) + branch + + Home + home + + + const SetVarArgs & + x + + + TieBreak< SetVarBranch > + vars + + + SetValBranch + vals + + + SetBranchFilter + bf + NULL + + + SetVarValPrint + vvp + NULL + + +Branch over x with tie-breaking variable selection vars and value selection vals. + + + + + + + + GECODE_SET_EXPORT BrancherHandle + GECODE_SET_EXPORT BrancherHandle Gecode::branch + (Home home, SetVar x, SetValBranch vals, SetVarValPrint vvp=NULL) + branch + + Home + home + + + SetVar + x + + + SetValBranch + vals + + + SetVarValPrint + vvp + NULL + + +Branch over x with value selection vals. + + + + + + + + GECODE_SET_EXPORT BrancherHandle + GECODE_SET_EXPORT BrancherHandle Gecode::assign + (Home home, const SetVarArgs &x, SetAssign vals, SetBranchFilter bf=NULL, SetVarValPrint vvp=NULL) + assign + + Home + home + + + const SetVarArgs & + x + + + SetAssign + vals + + + SetBranchFilter + bf + NULL + + + SetVarValPrint + vvp + NULL + + +Assign all x with value selection vals. + + + + + + + + GECODE_SET_EXPORT BrancherHandle + GECODE_SET_EXPORT BrancherHandle Gecode::assign + (Home home, SetVar x, SetAssign vals, SetVarValPrint vvp=NULL) + assign + + Home + home + + + SetVar + x + + + SetAssign + vals + + + SetVarValPrint + vvp + NULL + + +Assign x with value selection vals. + + + + + + + + GECODE_SET_EXPORT SymmetryHandle + GECODE_SET_EXPORT SymmetryHandle Gecode::VariableSymmetry + (const SetVarArgs &x) + VariableSymmetry + + const SetVarArgs & + x + + +Variables in x are interchangeable. + + + + + + + + GECODE_SET_EXPORT SymmetryHandle + GECODE_SET_EXPORT SymmetryHandle Gecode::VariableSequenceSymmetry + (const SetVarArgs &x, int ss) + VariableSequenceSymmetry + + const SetVarArgs & + x + + + int + ss + + +Variable sequences in x of size ss are interchangeable. + +The size of x must be a multiple of ss. + + + + + + GECODE_SET_EXPORT BrancherHandle + GECODE_SET_EXPORT BrancherHandle Gecode::branch + (Home home, const SetVarArgs &x, SetVarBranch vars, SetValBranch vals, const Symmetries &syms, SetBranchFilter bf=NULL, SetVarValPrint vvp=NULL) + branch + + Home + home + + + const SetVarArgs & + x + + + SetVarBranch + vars + + + SetValBranch + vals + + + const Symmetries & + syms + + + SetBranchFilter + bf + NULL + + + SetVarValPrint + vvp + NULL + + +Branch over x with variable selection vars and value selection vals with symmetry breaking. + + + + + + + + GECODE_SET_EXPORT BrancherHandle + GECODE_SET_EXPORT BrancherHandle Gecode::branch + (Home home, const SetVarArgs &x, TieBreak< SetVarBranch > vars, SetValBranch vals, const Symmetries &syms, SetBranchFilter bf=NULL, SetVarValPrint vvp=NULL) + branch + + Home + home + + + const SetVarArgs & + x + + + TieBreak< SetVarBranch > + vars + + + SetValBranch + vals + + + const Symmetries & + syms + + + SetBranchFilter + bf + NULL + + + SetVarValPrint + vvp + NULL + + +Branch over x with tie-breaking variable selection vars and value selection vals with symmetry breaking. + + + + + + + + + + class T + + + T + T Gecode::ptr_cast + (void *p) + ptr_cast + + void * + p + + +Cast p into pointer of type T. + + + + + + + + + + class F1 + + + class F2 + + + F1 + F1 Gecode::function_cast + (F2 f) + function_cast + + F2 + f + + +Cast function pointer. + + + + + + + + + + class T + + + forceinline T + forceinline T Gecode::ptr_cast + (void *p) + ptr_cast + + void * + p + + +Cast p into pointer of type T. + + + + + + + + + + class F1 + + + class F2 + + + forceinline F1 + forceinline F1 Gecode::function_cast + (F2 f) + function_cast + + F2 + f + + +Cast function pointer. + + + + + + + + +Gecode toplevel namespace + +The Gecode namespace contains nested namespaces for the various submodules (for example Int for the definition of integer propagator classes). Functionality that is used for interfacing (search engines, variables, and so on) or belongs to the Gecode Kernel is contained directly in the Gecode namespace. + + + diff --git a/packages/python/CMakeLists.txt b/packages/python/CMakeLists.txt index 3f8924a1a..54955ac55 100644 --- a/packages/python/CMakeLists.txt +++ b/packages/python/CMakeLists.txt @@ -1,3 +1,4 @@ + #CHECK: PythonLibs set (PYTHON_SOURCES @@ -6,8 +7,8 @@ set (PYTHON_SOURCES #try to use Brew first #set ( PYTHON_LIBRARY /Anaconda/lib/libpython2.7.dylib ) #set ( PYTHON_INCLUDE_DIR /Anaconda/include/python2.7 ) -set( PYTHON_LIBRARY /usr/local/opt/python/Frameworks/Python.framework/Versions/Current/lib/libpython2.7.dylib) # - path to the python library -set( PYTHON_INCLUDE_DIR /usr/local/opt/python/Frameworks/Python.framework/Versions/Current/include/python2.7 ) # - path to where Python.h is found +#set( PYTHON_LIBRARY /usr/local/opt/python/Frameworks/Python.framework/Versions/Current/lib/libpython2.7.dylib) # - path to the python library +#set( PYTHON_INCLUDE_DIR /usr/local/opt/python/Frameworks/Python.framework/Versions/Current/include/python2.7 ) # - path to where Python.h is found macro_optional_find_package(PythonInterp ON) macro_optional_find_package (PythonLibs ON) diff --git a/packages/udi/CMakeLists.txt b/packages/udi/CMakeLists.txt index c09fa337a..498f6f3bb 100644 --- a/packages/udi/CMakeLists.txt +++ b/packages/udi/CMakeLists.txt @@ -13,9 +13,16 @@ INCLUDE_DIRECTORIES( ${YAP_INCLUDE_DIR} ${CMAKE_CURRENT_BINARY_DIR} . -) + ) + #indexers ADD_SUBDIRECTORY(rtree) ADD_SUBDIRECTORY(b+tree) ADD_SUBDIRECTORY(uthash) + +disallow_intree_builds() + +#project (utf8proc C) + +# Be sure to also update these in Makefile! diff --git a/packages/udi/cmake/FindJudy.cmake b/packages/udi/cmake/FindJudy.cmake new file mode 100644 index 000000000..bdd916bb4 --- /dev/null +++ b/packages/udi/cmake/FindJudy.cmake @@ -0,0 +1,21 @@ +# +# Judy +# + +FIND_PATH(JUDY_INCLUDE_DIR Judy.h ${JUDY_ROOT}/include) +FIND_LIBRARY(JUDY_LIBRARY Judy ${JUDY_ROOT}/lib) + +IF (JUDY_INCLUDE_DIR AND JUDY_LIBRARY) + SET(JUDY_FOUND TRUE) +ENDIF (JUDY_INCLUDE_DIR AND JUDY_LIBRARY) + + +IF (JUDY_FOUND) + IF (NOT JUDY_FIND_QUIETLY) + MESSAGE(STATUS "Found Judy: ${JUDY_LIBRARY}") + ENDIF (NOT JUDY_FIND_QUIETLY) +ELSE (JUDY_FOUND) + IF (JUDY_FIND_REQUIRED) + MESSAGE(FATAL_ERROR "Could not find Judy") + ENDIF (JUDY_FIND_REQUIRED) +ENDIF (JUDY_FOUND) diff --git a/packages/udi/judy.c b/packages/udi/judy.c new file mode 100644 index 000000000..f26c96d26 --- /dev/null +++ b/packages/udi/judy.c @@ -0,0 +1,129 @@ +// needs to e cleaned up + +#if JUDY_FOUND +#include +/* Judy1 integer sparse set intersection */ +static inline int j1_callback(void *key, void *data, void *arg) +{ + int r; + Pvoid_t *arrayP = (Pvoid_t *) arg; + J1S(r, *arrayP, (Word_t) data); + if (r == JERR) + return FALSE; + return TRUE; +} +#endif + +yamop * +Yap_udi_join(struct ClauseList *clauselist. UdiPArg parg. UdiInfo info) +{ +#if JUDY_FOUND + /*TODO: do more tests to this algorithm*/ + int i; + Pvoid_t tmp = (Pvoid_t) NULL; + Pvoid_t result = (Pvoid_t) NULL; + Word_t count = 0L; + Word_t idx_r = 0L; + Word_t idx_tmp = 0L; + int rc = 0; + yamop **x; + + /* + * I will start with the simplest approach + * for each index create a set and intersect it with the + * next + * + * In the future it could pay to sort according to index type + * to improve intersection part + */ + for (i = 0; i < utarray_len(info->args) ; i++) { + parg = (UdiPArg) utarray_eltptr(info->args,i); + r = parg->control->search(parg->idxstr, parg->arg, j1_callback, &tmp); + if (r == -1) /*this arg does not prune search*/ + continue; + rc ++; + J1C(count, result, 0, -1); + if (r == 0) /* this arg gave 0 results -> FAIL*/ + { + if (count > 0) // clear previous result if they exists + J1FA(count, result); + return Yap_FAILCODE(); + } + + if (count == 0) // first result_set + { + result = tmp; + tmp = (Pvoid_t) NULL; + } + else /*intersection*/ + { + idx_tmp = 0L; + idx_r = 0L; + J1F(count, result, idx_r); //succeeds one time at least + assert(count > 0); + J1F(count, tmp, idx_tmp); //succeeds one time at least + assert(count > 0); + while (count) + { + while (idx_r < idx_tmp) + { + J1U(count, result, idx_r); //does not belong + J1N(count, result, idx_r); //next + if (! count) break; //end result set + } + if(idx_r == idx_tmp) + { + J1N(count, result, idx_r); //next + if (! count) break; //end result set + J1N(count, tmp, idx_tmp); //next tmp + //if (! count) break; //end tmp set will break while + } + else // (idx_r > idx_tmp) + { + idx_tmp = idx_r; // fast forward + J1F(count, tmp, idx_tmp); // first starting in idx_r + //if (! count) break; //end tmp set will break while + } + } + J1F(count, result, idx_r); // first starting in idx_r + //clear up the rest + while (idx_r > idx_tmp && count) //result has more setted values + { + J1U(count, result, idx_r); //does not belong + J1N(count, result, idx_r); //next + } + J1FA(count, tmp); //free tmp + } + } + if (rc == 0) /*no search performed*/ + return NULL; + + J1C(count, result, 0, -1); + if (count == 0) { /*result set empty -> FAIL */ + J1FA(count, result); + return Yap_FAILCODE(); + } + + /*convert Juddy1 to clauselist*/ + Yap_ClauseListInit(clauselistp); + idx_r = 0L; + J1F(count, result, idx_r); + while (count) + { + x = (yamop **) utarray_eltptr(info->clauselist, idx_r - 1); + Yap_ClauseListExtend( + clauselist, + *x, + info->p); + J1N(count, result, idx_r); + } + J1FA(count,result); + fprintf(stderr,"J1 used space %ld bytes for %d clausules\n", + count, Yap_ClauseListCount(clauselist)); + Yap_ClauseListClose(clauselist); +#else + fprintf(stderr,"Without libJudy only one argument indexed is allowed." + "Falling back to Yap Indexing\n"); + return NULL; //NO Judy Available +#endif +} diff --git a/pl/chtypes.yap b/pl/chtypes.yap index da1f9e1c5..0f85b4f8b 100644 --- a/pl/chtypes.yap +++ b/pl/chtypes.yap @@ -21,6 +21,11 @@ * @defgroup YAPChars Sequences of Characters: atoms, strings, lists of codes. * @ingroup builtins * + * The Prolog library includes a set of built-in predicates designed to +support manipulation of sequences of text, represented either as +lists, atoms or strings. + + */ /* diff --git a/pl/init.yap b/pl/init.yap index c4cf4b76a..9fd6e7a5a 100644 --- a/pl/init.yap +++ b/pl/init.yap @@ -250,6 +250,7 @@ rules. :- use_module('../swi/library/predopts.pl'). :- use_module('../swi/library/menu.pl'). :- use_module('../library/ypp.yap'). +:- use_module('../os/chartypes.yap'). yap_hacks:cut_by(CP) :- '$$cut_by'(CP). @@ -258,8 +259,6 @@ yap_hacks:cut_by(CP) :- '$$cut_by'(CP). :- set_prolog_flag(generate_debug_info,true). -% grep:- recorda('$dialect',yap,_). - % % cleanup ensure loaded and recover some data-base space. %