distributed config && float library

packages/gecode/dev/Makefile

@@ -0,0 +1,5 @@
+all:
+	python code-generator.py
+
+clean:
+	-rm -f *~ *.pyc

packages/gecode/dev/code-generator.py

@@ -0,0 +1,717 @@
+# -*- python -*-
+#==============================================================================
+# 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 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 General Public License along with
+# this program.  If not, see <http://www.gnu.org/licenses/>.
+#==============================================================================
+
+import re
+
+NOTICE_CC = """// -*- 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 <http://www.gnu.org/licenses/>.
+//=============================================================================
+"""
+
+NOTICE_PROLOG="""%% -*- 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 <http://www.gnu.org/licenses/>.
+%%=============================================================================
+"""
+
+def prolog_print_notice():
+    print NOTICE_PROLOG
+
+def cc_print_notice():
+    print NOTICE_CC
+
+class Type(object):
+
+    DEFAULT   = re.compile("""^(.+)=(.+)$""")
+    CONST     = re.compile("""^const\\b(.+)$""")
+    UNSIGNED  = re.compile("""^unsigned\\b(.+)$""")
+    REFERENCE = re.compile("""^(.+)&$""")
+
+    def __init__(self, text):
+        if isinstance(text, Type):
+            self.clone_from(text)
+            return
+        text = text.strip()
+        m = self.DEFAULT.match(text)
+        if m:
+            self.default = m.group(2).strip()
+            text = m.group(1).strip()
+        else:
+            self.default = None
+        m = self.CONST.match(text)
+        if m:
+            self.const = True
+            text = m.group(1).strip()
+        else:
+            self.const = False
+        m = self.UNSIGNED.match(text)
+        if m:
+            self.unsigned = True
+            text = m.group(1).strip()
+        else:
+            self.unsigned = False
+        m = self.REFERENCE.match(text)
+        if m:
+            self.reference = True
+            text = m.group(1).strip()
+        else:
+            self.reference = False
+        self.type = text
+
+    def __str__(self):
+        l = []
+        if self.const: l.append("const ")
+        if self.unsigned: l.append("unsigned ")
+        l.append(self.type)
+        if self.reference: l.append("&")
+        if self.default is not None:
+            l.append("=")
+            l.append(self.default)
+        return ''.join(l)
+
+    def clone_from(self, other):
+        self.const = other.const
+        self.unsigned = other.unsigned
+        self.type = other.type
+        self.reference = other.reference
+        self.default = other.default
+
+    def clone(self):
+        return type(self)(self)
+        
+
+class Constraint(object):
+
+    DECL = re.compile("""^([^(]+)\\b(\w+)\((.*)\);$""")
+    ARG  = re.compile("""((?:[^,<(]|<[^>]*>|\([^)]*\))+),?""")
+
+    def __init__(self, line):
+        if isinstance(line, Constraint):
+            self.clone_from(line)
+            return
+        line = line.strip()
+        m = self.DECL.match(line)
+        self.rettype = Type(m.group(1).strip())
+        self.name = m.group(2)
+        argtypes = []
+        for x in self.ARG.finditer(m.group(3).strip()):
+            argtypes.append(Type(x.group(1)))
+        self.argtypes = tuple(argtypes)
+        self.api = None
+
+    def __str__(self):
+        l = []
+        l.append(str(self.rettype))
+        l.append(" ")
+        l.append(self.name)
+        sep = "("
+        for x in self.argtypes:
+            l.append(sep)
+            sep = ", "
+            l.append(str(x))
+        l.append(")")
+        if self.api is not None:
+            l.append(" -> ")
+            l.append(self.api)
+        l.append(";")
+        return ''.join(l)
+
+    def clone_from(self, other):
+        self.rettype = other.rettype.clone()
+        self.name = other.name
+        self.argtypes = tuple(t.clone() for t in other.argtypes)
+
+    def clone(self):
+        return type(self)(self)
+    
+
+COMMENT = re.compile("""^\\s*//.*$""")
+
+def load_decls(filename):
+    decls = []
+    for line in open(filename):
+        line = line.strip()
+        if not line: continue
+        m = COMMENT.match(line)
+        if m: continue
+        decls.append(Constraint(line))
+    return decls
+
+class DeclsLoader(object):
+
+    def __init__(self, filename):
+        self.decls = load_decls(filename)
+
+    def print_decls(self):
+        for con in self.decls:
+            print str(con)
+
+class PredGenerator(DeclsLoader):
+
+    OMIT = ("VarBranchOptions",
+            "ValBranchOptions",
+            "TieBreakVarBranch<IntVarBranch>",
+            "TieBreak<IntVarBranch>",
+            "TieBreak<FloatVarBranch>",
+            "TieBreak<SetVarBranch>",
+            "TieBreakVarBranchOptions",
+            "TieBreakVarBranch<SetVarBranch>")
+
+    def __init__(self, filename):
+        super(PredGenerator, self).__init__(filename)
+        self._change_home_to_space()
+        self._change_intsharedarray_to_intargs()
+        self._generate()
+        self._number()
+
+    def _change_home_to_space(self):
+        for p in self.decls:
+            for t in p.argtypes:
+                if t.type=="Home":
+                    t.type="Space"
+
+    def _change_intsharedarray_to_intargs(self):
+        for p in self.decls:
+            for t in p.argtypes:
+                if t.type=="IntSharedArray":
+                    t.type="IntArgs"
+
+    def _generate(self):
+        # drop the constraints and optional arguments we can't handle
+        preds = []
+        for con in self.decls:
+            if self._con_ok(con):
+                con = con.clone()
+                con.argtypes = tuple(self._drop_deco(t) for t in con.argtypes
+                                     if t.type not in self.OMIT)
+                preds.append(con)
+        # for each pred that has an argument with a default produce
+        # 2 preds (1 without, 1 with).  repeat until all defaults have
+        # been removed.
+        again = True
+        while again:
+            preds_ = []
+            again = False
+            for con in preds:
+                i = self._defaulted(con.argtypes)
+                if i is None:
+                    preds_.append(con)
+                else:
+                    again = True
+                    before = con.argtypes[:i]
+                    # without the default argument
+                    # and therefore without the args that follow
+                    con1 = con.clone()
+                    con1.argtypes = before
+                    preds_.append(con1)
+                    # with the default argument (not default anymore)
+                    con2 = con.clone()
+                    arg = con.argtypes[i].clone()
+                    arg.default=None
+                    after = con.argtypes[i+1:]
+                    con2.argtypes = before + (arg,) + after
+                    preds_.append(con2)
+            preds = preds_
+        self.preds = preds
+
+    def _con_ok(self, con):
+        for t in con.argtypes:
+            if (t.type in self.OMIT) and (t.default is None):
+                return False
+        return True
+
+    def _drop_deco(self, t):
+        # drop const, ref, and unsigned indications
+        t.const = False
+        t.reference = False
+        t.unsigned = False
+        return t
+
+    def _defaulted(self, argtypes):
+        i = 0
+        for x in argtypes:
+            if x.default is not None:
+                return i
+            i += 1
+        return None
+
+    def _number(self):
+        i = 1
+        for x in self.preds:
+            x.api = "%s_%d" % (x.name,i)
+            i += 1
+
+    def print_preds(self):
+        for p in self.preds:
+            print str(p)
+
+class Cluster(object):
+
+    def __init__(self, name, arity):
+        self.name = name
+        self.arity = arity
+        self.preds = []
+
+# discriminating tree based on argument types
+class DTree(object):
+
+    def __init__(self, i, preds, cluster):
+        self.index = i
+        self.cluster = cluster
+        if len(preds) == 1 and len(preds[0].argtypes) == i:
+            self.is_leaf = True
+            self.pred = preds[0]
+            return
+        self.is_leaf = False
+        # i is the index of the current arg
+        # preds are the predicates to be indexed under this tree node
+        dispatch = {}
+        for p in preds:
+            t = p.argtypes[i]
+            d = dispatch.get(t.type, None)
+            if d is None:
+                d = []
+                dispatch[t.type] = d
+            d.append(p)
+        self.subtrees = tuple((t2,DTree(i+1,p2,cluster))
+                              for t2,p2 in dispatch.iteritems())
+
+    def _generate_body(self, user_vars, lib_vars):
+        if self.is_leaf:
+            return PrologLiteral("gecode_constraint_%s(%s)" % (self.pred.api, ",".join(lib_vars)))
+        X = user_vars[self.index]
+        Y = lib_vars[self.index]
+        return self._generate_dispatch(0, user_vars, lib_vars)
+
+    def _generate_dispatch(self, i, user_vars, lib_vars):
+        if i == len(self.subtrees):
+            return PrologLiteral("throw(gecode_argument_error(%s(%s),arg=%d))" \
+                                     % (self.cluster.name, ",".join(user_vars),
+                                        self.index+1))
+        typ, dtree = self.subtrees[i]
+        idx = self.index
+        X = user_vars[idx]
+        Y = lib_vars[idx]
+        # hack for disjunctor support
+        if typ=="Space":
+            typ = "Space_or_Clause"
+        return PrologIF(
+            PrologLiteral("is_%s(%s,%s)" % (typ,X,Y)),
+            dtree._generate_body(user_vars, lib_vars),
+            self._generate_dispatch(i+1, user_vars, lib_vars))
+
+    def _cc_descriptors(self, name, argtypes):
+        if self.is_leaf:
+            return (CCDescriptor(name, argtypes, self.pred.api),)
+        descriptors = []
+        for typ,dtree in self.subtrees:
+            descriptors.extend(dtree._cc_descriptors(name,(argtypes+(typ,))))
+        return descriptors
+
+class YAPConstraintGeneratorBase(PredGenerator):
+
+    def __init__(self, filename):
+        super(YAPConstraintGeneratorBase, self).__init__(filename)
+        self._classify()
+        self._dtreefy()
+
+    # create clusters (predicate,arity)
+    def _classify(self):
+        clusters = {}
+        for pred in self.preds:
+            name = pred.name
+            arity = len(pred.argtypes)
+            key = (name,arity)
+            cluster = clusters.get(key, None)
+            if cluster is None:
+                cluster = Cluster(name, arity)
+                clusters[key] = cluster
+            cluster.preds.append(pred)
+        self.clusters = clusters
+
+    # for each cluster, create a dtree
+    def _dtreefy(self):
+        dtrees = {}
+        for key, cluster in self.clusters.iteritems():
+            dtree = DTree(0, cluster.preds, cluster)
+            dtrees[key] = dtree
+        self.dtrees = dtrees
+
+    def _user_vars(self, arity):
+        return tuple(("X%d" % i) for i in range(arity))
+
+    def _lib_vars(self, arity):
+        return tuple(("Y%d" % i) for i in range(arity))
+
+class YAPConstraintPrologGenerator(YAPConstraintGeneratorBase):
+
+    def __init__(self, filename):
+        super(YAPConstraintPrologGenerator, self).__init__(filename)
+
+    def _prolog_clauses(self):
+        clauses = []
+        for (name, arity), dtree in self.dtrees.iteritems():
+            user_vars = self._user_vars(arity)
+            lib_vars = self._lib_vars(arity)
+            head = "%s(%s)" % (name, ",".join(user_vars))
+            body = dtree._generate_body(user_vars, lib_vars)
+            clause = PrologClause(head, body)
+            clauses.append(clause)
+        return clauses
+
+    def generate(self):
+        out = OStream(sys.stdout)
+        for clause in self._prolog_clauses():
+            clause.pp(out, 0)
+
+class YAPConstraintCCGenerator(YAPConstraintGeneratorBase):
+
+    def __init__(self, filename):
+        super(YAPConstraintCCGenerator, self).__init__(filename)
+
+    def _cc_descriptors(self):
+        descriptors = []
+        for (name, arity), dtree in self.dtrees.iteritems():
+            descriptors.extend(dtree._cc_descriptors(name,()))
+        return descriptors
+
+    def generate_impl(self):
+        for d in self._cc_descriptors():
+            d.generate_impl()
+
+    def generate_init(self):
+        for d in self._cc_descriptors():
+            d.generate_init()
+
+# output stream that keeps track of the current column
+# to facilitate proper indentation
+
+import sys
+
+class OStream(object):
+
+    def __init__(self, fd=sys.stdout):
+        self.file = fd
+        self.column = 0
+
+    def write(self, s):
+        reset = False
+        for x in s.split('\n'):
+            if reset:
+                self.newline()
+            else:
+                reset = True
+            self.file.write(x)
+            self.column += len(x)
+
+    def newline(self):
+        self.file.write("\n")
+        self.column = 0
+
+    def writeln(self, s=None):
+        if s is not None:
+            self.write(s)
+        self.newline()
+
+    def indent_to(self, n):
+        if n<self.column:
+            self.newline()
+        n = n - self.column
+        while n>0:
+            self.write(' ')
+            n -= 1
+
+# representation of prolog code that automatically supports proper indentation
+
+class PrologObject(object):
+    pass
+
+class PrologClause(PrologObject):
+
+    def __init__(self, head, body):
+        self.head = head
+        self.body = body
+
+    def pp(self, out, offset):
+        out.indent_to(offset)
+        out.write(self.head)
+        out.writeln(" :-")
+        self.body.pp(out, offset+8)
+        out.writeln(".")
+        out.writeln()
+
+class PrologLiteral(PrologObject):
+
+    def __init__(self, lit):
+        self.literal = lit
+
+    def pp(self, out, offset):
+        out.indent_to(offset)
+        out.write(self.literal)
+
+class PrologIF(PrologObject):
+
+    def __init__(self, cond, left, right):
+        self.cond = cond
+        self.left = left
+        self.right = right
+
+    def pp(self, out, offset):
+        out.indent_to(offset)
+        out.write("("),
+        indent = offset+1
+        self.cond.pp(out, indent)
+        out.writeln()
+        out.indent_to(indent)
+        out.write("-> ")
+        self.left.pp(out, indent+3)
+        out.writeln()
+        out.indent_to(indent)
+        out.write(";  ")
+        self.right.pp(out, indent+3)
+        out.write(")")
+
+ENUM_CLASSES = None
+ENUM_CLASSES_AVOID = ('ScriptMode','ViewSelStatus','ExecStatus',
+                      'ActorProperty','SpaceStatus')
+
+def enum_classes():
+    global ENUM_CLASSES
+    if ENUM_CLASSES is None:
+        filename = "gecode-enums-%s.py" % gecode_version()
+        import imp
+        ENUM_CLASSES = imp.load_source(
+            "gecode_enums",
+            filename).ENUM_CLASSES
+        ENUM_CLASSES = tuple(x for x in ENUM_CLASSES if x.TYPE not in ENUM_CLASSES_AVOID)
+    return ENUM_CLASSES
+
+class YAPEnumImpl(object):
+
+    def generate(self):
+        self._generate_atoms()
+        self._generate_from_term()
+
+    def _generate_atoms(self):
+        for x in self.ENUM:
+            print "static YAP_Term gecode_%s;" % x
+        print
+
+    def _generate_from_term(self):
+        print "static %s gecode_%s_from_term(YAP_Term X)" % (self.TYPE,self.TYPE)
+        print "{"
+        for x in self.ENUM:
+            print "  if (X==gecode_%s) return %s;" % (x,x)
+        print '  cerr << "this should never happen" << endl; exit(1);'
+        print "}"
+        print
+
+    def _generate_from_term_forward_decl(self):
+        print "static %s gecode_%s_from_term(YAP_Term);" % (self.TYPE,self.TYPE)
+
+class YAPEnumImplGenerator(object):
+
+    def generate(self):
+        for c in enum_classes():
+            class C(c,YAPEnumImpl): pass
+            o = C()
+            o.generate()
+
+class YAPEnumForwardGenerator(object):
+
+    def generate(self):
+        for c in enum_classes():
+            class C(c,YAPEnumImpl): pass
+            o = C()
+            o._generate_from_term_forward_decl()
+
+class YAPEnumInit(object):
+
+    def generate(self):
+        for x in self.ENUM:
+            print '{ YAP_Atom X= YAP_LookupAtom("%s");' % x
+            print '  gecode_%s = YAP_MkAtomTerm(X);' % x
+            print '  YAP_AtomGetHold(X); }'
+        print
+
+class YAPEnumInitGenerator(object):
+
+    def generate(self):
+        for c in enum_classes():
+            class C(c,YAPEnumInit): pass
+            o = C()
+            o.generate()
+
+class YAPEnumProlog(object):
+
+    def generate(self):
+        for x in self.ENUM:
+            print "is_%s_('%s')." % (self.TYPE, x)
+        print
+        for x in self.ENUM:
+            print "is_%s_('%s','%s')." % (self.TYPE, x, x)
+        print
+        print "is_%s(X,Y) :- nonvar(X), is_%s_(X,Y)." % (self.TYPE,self.TYPE)
+        print "is_%s(X) :- is_%s(X,_)." % (self.TYPE,self.TYPE)
+        print
+
+class YAPEnumPrologGenerator(object):
+    
+    def generate(self):
+        for c in enum_classes():
+            class C(c,YAPEnumProlog): pass
+            o = C()
+            o.generate()
+
+class CCDescriptor(object):
+
+    def __init__(self, name, argtypes, api):
+        self.name = name
+        self.argtypes = argtypes
+        self.api = api
+
+    def generate_impl(self):
+        print "static int gecode_constraint_%s(void)" % self.api
+        print "{"
+        i = 1
+        args = []
+        has_space = False
+        for t in self.argtypes:
+            v = "X%d" % i
+            a = "YAP_ARG%d" % i
+            if t=="Space":
+                v = "*space"
+                print "  GenericSpace* space = gecode_Space_from_term(%s);" % a
+                has_space = True
+            else:
+                extra = ""
+                if t in ("IntVar","BoolVar","SetVar","FloatVar","IntVarArgs","BoolVarArgs","SetVarArgs","FloatVarArgs"):
+                    extra = "space,"
+                    if has_space == False:
+                        print "  GenericSpace* space = gecode_Space_from_term(%s);" % a
+                        has_space = True
+                print "  %s %s = gecode_%s_from_term(%s%s);" % (t,v,t,extra,a)
+            args.append(v)
+            i += 1
+        print "  %s(%s);" % (self.name, ",".join(args))
+        print "  return TRUE;"
+        print "}"
+        print
+
+    def generate_init(self):
+        print 'YAP_UserCPredicate("gecode_constraint_%s", gecode_constraint_%s, %d);' \
+            % (self.api, self.api, len(self.argtypes))
+
+GECODE_VERSION = None
+
+def gecode_version():
+    global GECODE_VERSION
+    if GECODE_VERSION is not None:
+        return GECODE_VERSION
+    from distutils.ccompiler import new_compiler
+    try:
+        from distutils.ccompiler import customize_compiler
+    except:
+        from distutils.sysconfig import customize_compiler
+    import os
+    cxx = new_compiler()
+    customize_compiler(cxx)
+    pid = os.getpid()
+    file_hh = "_gecode_version_%d.hh" % pid
+    file_txt = "_gecode_version_%d.txt" % pid
+    f = file(file_hh,"w")
+    f.write("""#include "gecode/support/config.hpp"
+@@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)
+    GECODE_VERSION = version
+    return version
+
+def generate_files():
+    DIR = "../%s" % gecode_version()
+    import os, os.path
+    DIR = os.path.abspath(DIR)
+    if not os.path.exists(DIR):
+        os.mkdir(DIR)
+    filename = "gecode-prototypes-%s.hh" % gecode_version()
+    import sys
+    stdout = sys.stdout
+    try:
+        sys.stdout = file(os.path.join(DIR,"gecode-version.txt"),"w")
+        print gecode_version()
+        sys.stdout.close()
+        sys.stdout = file(os.path.join(DIR,"gecode_yap_auto_generated.yap"),"w")
+        prolog_print_notice()
+        YAPEnumPrologGenerator().generate()
+        YAPConstraintPrologGenerator(filename).generate()
+        sys.stdout.close()
+        sys.stdout = file(os.path.join(DIR,"gecode_yap_cc_impl_auto_generated.icc"),"w")
+        cc_print_notice()
+        YAPEnumImplGenerator().generate()
+        YAPConstraintCCGenerator(filename).generate_impl()
+        sys.stdout.close()
+        sys.stdout = file(os.path.join(DIR,"gecode_yap_cc_init_auto_generated.icc"),"w")
+        cc_print_notice()
+        YAPEnumInitGenerator().generate()
+        YAPConstraintCCGenerator(filename).generate_init()
+        sys.stdout.close()
+        sys.stdout = file(os.path.join(DIR,"gecode_yap_cc_forward_auto_generated.icc"),"w")
+        cc_print_notice()
+        YAPEnumForwardGenerator().generate()
+        sys.stdout.close()
+    finally:
+        sys.stdout = stdout
+
+if __name__ == '__main__':
+    generate_files()

packages/gecode/dev/extractor/Makefile

@@ -0,0 +1,36 @@
+GECODEDIR := $(shell g++ $(CPPFLAGS) $(CXXFLAGS) -H -E gecodedir.hh 2>&1 >/dev/null | grep gecode/kernel.hh | awk '{print $$2}' | sed 's|/kernel.hh||')
+GECODECONFIG := $(GECODEDIR)/support/config.hpp
+GECODEVERSION := $(shell cat $(GECODECONFIG) | egrep '\<GECODE_VERSION\>' | awk '{print $$3}' | sed 's/"//g')
+PROTOTYPES = ../gecode-prototypes-$(GECODEVERSION).hh
+ENUMS = ../gecode-enums-$(GECODEVERSION).py
+
+all: $(PROTOTYPES) $(ENUMS)
+
+$(PROTOTYPES): % : xml/namespaceGecode.xml extract-prototypes.xsl
+	cat notice.hh > $@ || { rm -f $@; exit 1; }
+	xsltproc extract-prototypes.xsl $<  \
+	| grep EXPORT \
+	| grep -v Symmetry \
+	| sed 's/Gecode:://g' \
+	| sed 's/< /</g' \
+	| sed 's/ >/>/g' \
+	| sed 's/ \&/\&/g' \
+	| sed 's/, /,/g' \
+	| sed 's/forceinline //g' \
+	| sed 's/GECODE_INT_EXPORT //g' \
+	| sed 's/GECODE_FLOAT_EXPORT //g' \
+	| sed 's/GECODE_SET_EXPORT //g' \
+	| grep -v '*' | sort >> $@ || { rm -f $@; exit 1; }
+
+$(ENUMS): % : xml/namespaceGecode.xml extract-enums.xsl
+	cat notice.py > $@ || { rm -f $@; exit 1; }
+	xsltproc extract-enums.xsl $< >> $@ || { rm -f $@; exit 1; }
+
+xml/namespaceGecode.xml: Doxyfile
+	doxygen Doxyfile
+
+Doxyfile: Doxyfile.in
+	cat $< | sed "s#@GECODEDIR@#$(GECODEDIR)#" > $@ || { rm -f $@; exit 1; }
+
+clean:
+	-rm -rf *~ gecode-prototypes-*.hh gecode-enums-*.py Doxyfile xml

packages/gecode/dev/extractor/README

@@ -0,0 +1,2 @@
+This directory contains support code for automatically extracting
+prototypes from the local Gecode installation.

packages/gecode/dev/extractor/extract-enums.xsl

@@ -0,0 +1,31 @@
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
+  <xsl:output method="text" version="1.0"/>
+  <xsl:template match="/">
+    <xsl:text>ENUM_CLASSES = []
+
+</xsl:text>
+    <xsl:for-each select="/doxygen/compounddef/sectiondef[@kind='enum']/memberdef">
+      <xsl:text>class </xsl:text>
+      <xsl:value-of select="name"/>
+      <xsl:text>(object):
+</xsl:text>
+      <xsl:text>    TYPE = '</xsl:text>
+      <xsl:value-of select="name"/>
+      <xsl:text>'
+    ENUM = [</xsl:text>
+      <xsl:for-each select="enumvalue">
+	<xsl:if test="position()!=1"><xsl:text>,</xsl:text></xsl:if>
+	<xsl:text>'</xsl:text>
+	<xsl:value-of select="name"/>
+	<xsl:text>'</xsl:text>
+      </xsl:for-each>
+      <xsl:text>]
+
+ENUM_CLASSES.append(</xsl:text>
+    <xsl:value-of select="name"/>
+    <xsl:text>)
+
+</xsl:text>
+    </xsl:for-each>
+  </xsl:template>
+</xsl:stylesheet>

packages/gecode/dev/extractor/extract-prototypes.xsl

@@ -0,0 +1,21 @@
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
+  <xsl:output method="text" version="1.0"/>
+  <xsl:template match="/">
+    <xsl:for-each select="/doxygen/compounddef/sectiondef[@kind='func']/memberdef[starts-with(@id,'group__TaskModel') and not(starts-with(name,'operator')) and name!='tiebreak' and name!='wait' and not(starts-with(@id,'group__TaskModelMiniModel'))]">
+      <xsl:value-of select="type"/>
+      <xsl:text> </xsl:text>
+      <xsl:value-of select="name"/>
+      <xsl:for-each select="param">
+	<xsl:if test="position()=1"><xsl:text>(</xsl:text></xsl:if>
+	<xsl:if test="position()!=1"><xsl:text>,</xsl:text></xsl:if>
+	<xsl:value-of select="type"/>
+	<xsl:for-each select="defval">
+	  <xsl:text>=</xsl:text>
+	  <xsl:value-of select="."/>
+	</xsl:for-each>
+      </xsl:for-each>
+      <xsl:text>);
+</xsl:text>
+    </xsl:for-each>
+  </xsl:template>
+</xsl:stylesheet>

packages/gecode/dev/extractor/gecodedir.hh

@@ -0,0 +1 @@
+#include "gecode/kernel.hh"

packages/gecode/dev/extractor/notice.hh

@@ -0,0 +1,3 @@
+// This file was automatically extracted from Gecode source files.
+// It is subject to the same Copyright as the source files from which
+// it is derived, and is distributed under the same Licensing conditions.

packages/gecode/dev/extractor/notice.py

@@ -0,0 +1,3 @@
+# This file was automatically extracted from Gecode source files.
+# It is subject to the same Copyright as the source files from which
+# it is derived, and is distributed under the same Licensing conditions.

packages/gecode/dev/gecode-enums-3.6.0.py

@@ -0,0 +1,113 @@
+# This file was automatically extracted from Gecode source files.
+# It is subject to the same Copyright as the source files from which
+# it is derived, and is distributed under the same Licensing conditions.
+ENUM_CLASSES = []
+
+class ScriptMode(object):
+    TYPE = 'ScriptMode'
+    ENUM = ['SM_SOLUTION','SM_TIME','SM_STAT','SM_GIST']
+
+ENUM_CLASSES.append(ScriptMode)
+
+class IntRelType(object):
+    TYPE = 'IntRelType'
+    ENUM = ['IRT_EQ','IRT_NQ','IRT_LQ','IRT_LE','IRT_GQ','IRT_GR']
+
+ENUM_CLASSES.append(IntRelType)
+
+class BoolOpType(object):
+    TYPE = 'BoolOpType'
+    ENUM = ['BOT_AND','BOT_OR','BOT_IMP','BOT_EQV','BOT_XOR']
+
+ENUM_CLASSES.append(BoolOpType)
+
+class IntConLevel(object):
+    TYPE = 'IntConLevel'
+    ENUM = ['ICL_VAL','ICL_BND','ICL_DOM','ICL_DEF']
+
+ENUM_CLASSES.append(IntConLevel)
+
+class TaskType(object):
+    TYPE = 'TaskType'
+    ENUM = ['TT_FIXP','TT_FIXS','TT_FIXE']
+
+ENUM_CLASSES.append(TaskType)
+
+class ExtensionalPropKind(object):
+    TYPE = 'ExtensionalPropKind'
+    ENUM = ['EPK_DEF','EPK_SPEED','EPK_MEMORY']
+
+ENUM_CLASSES.append(ExtensionalPropKind)
+
+class IntVarBranch(object):
+    TYPE = 'IntVarBranch'
+    ENUM = ['INT_VAR_NONE','INT_VAR_RND','INT_VAR_DEGREE_MIN','INT_VAR_DEGREE_MAX','INT_VAR_AFC_MIN','INT_VAR_AFC_MAX','INT_VAR_MIN_MIN','INT_VAR_MIN_MAX','INT_VAR_MAX_MIN','INT_VAR_MAX_MAX','INT_VAR_SIZE_MIN','INT_VAR_SIZE_MAX','INT_VAR_SIZE_DEGREE_MIN','INT_VAR_SIZE_DEGREE_MAX','INT_VAR_SIZE_AFC_MIN','INT_VAR_SIZE_AFC_MAX','INT_VAR_REGRET_MIN_MIN','INT_VAR_REGRET_MIN_MAX','INT_VAR_REGRET_MAX_MIN','INT_VAR_REGRET_MAX_MAX']
+
+ENUM_CLASSES.append(IntVarBranch)
+
+class IntValBranch(object):
+    TYPE = 'IntValBranch'
+    ENUM = ['INT_VAL_MIN','INT_VAL_MED','INT_VAL_MAX','INT_VAL_RND','INT_VAL_SPLIT_MIN','INT_VAL_SPLIT_MAX','INT_VAL_RANGE_MIN','INT_VAL_RANGE_MAX','INT_VALUES_MIN','INT_VALUES_MAX']
+
+ENUM_CLASSES.append(IntValBranch)
+
+class IntAssign(object):
+    TYPE = 'IntAssign'
+    ENUM = ['INT_ASSIGN_MIN','INT_ASSIGN_MED','INT_ASSIGN_MAX','INT_ASSIGN_RND']
+
+ENUM_CLASSES.append(IntAssign)
+
+class ViewSelStatus(object):
+    TYPE = 'ViewSelStatus'
+    ENUM = ['VSS_BEST','VSS_BETTER','VSS_TIE','VSS_WORSE']
+
+ENUM_CLASSES.append(ViewSelStatus)
+
+class ExecStatus(object):
+    TYPE = 'ExecStatus'
+    ENUM = ['__ES_SUBSUMED','ES_FAILED','ES_NOFIX','ES_OK','ES_FIX','ES_NOFIX_FORCE','__ES_PARTIAL']
+
+ENUM_CLASSES.append(ExecStatus)
+
+class ActorProperty(object):
+    TYPE = 'ActorProperty'
+    ENUM = ['AP_DISPOSE','AP_WEAKLY']
+
+ENUM_CLASSES.append(ActorProperty)
+
+class SpaceStatus(object):
+    TYPE = 'SpaceStatus'
+    ENUM = ['SS_FAILED','SS_SOLVED','SS_BRANCH']
+
+ENUM_CLASSES.append(SpaceStatus)
+
+class SetRelType(object):
+    TYPE = 'SetRelType'
+    ENUM = ['SRT_EQ','SRT_NQ','SRT_SUB','SRT_SUP','SRT_DISJ','SRT_CMPL']
+
+ENUM_CLASSES.append(SetRelType)
+
+class SetOpType(object):
+    TYPE = 'SetOpType'
+    ENUM = ['SOT_UNION','SOT_DUNION','SOT_INTER','SOT_MINUS']
+
+ENUM_CLASSES.append(SetOpType)
+
+class SetVarBranch(object):
+    TYPE = 'SetVarBranch'
+    ENUM = ['SET_VAR_NONE','SET_VAR_RND','SET_VAR_DEGREE_MIN','SET_VAR_DEGREE_MAX','SET_VAR_AFC_MIN','SET_VAR_AFC_MAX','SET_VAR_MIN_MIN','SET_VAR_MIN_MAX','SET_VAR_MAX_MIN','SET_VAR_MAX_MAX','SET_VAR_SIZE_MIN','SET_VAR_SIZE_MAX','SET_VAR_SIZE_DEGREE_MIN','SET_VAR_SIZE_DEGREE_MAX','SET_VAR_SIZE_AFC_MIN','SET_VAR_SIZE_AFC_MAX']
+
+ENUM_CLASSES.append(SetVarBranch)
+
+class SetValBranch(object):
+    TYPE = 'SetValBranch'
+    ENUM = ['SET_VAL_MIN_INC','SET_VAL_MIN_EXC','SET_VAL_MED_INC','SET_VAL_MED_EXC','SET_VAL_MAX_INC','SET_VAL_MAX_EXC','SET_VAL_RND_INC','SET_VAL_RND_EXC']
+
+ENUM_CLASSES.append(SetValBranch)
+
+class SetAssign(object):
+    TYPE = 'SetAssign'
+    ENUM = ['SET_ASSIGN_MIN_INC','SET_ASSIGN_MIN_EXC','SET_ASSIGN_MED_INC','SET_ASSIGN_MED_EXC','SET_ASSIGN_MAX_INC','SET_ASSIGN_MAX_EXC','SET_ASSIGN_RND_INC','SET_ASSIGN_RND_EXC']
+
+ENUM_CLASSES.append(SetAssign)
+

packages/gecode/dev/gecode-enums-3.7.0.py

@@ -0,0 +1,113 @@
+# This file was automatically extracted from Gecode source files.
+# It is subject to the same Copyright as the source files from which
+# it is derived, and is distributed under the same Licensing conditions.
+ENUM_CLASSES = []
+
+class ScriptMode(object):
+    TYPE = 'ScriptMode'
+    ENUM = ['SM_SOLUTION','SM_TIME','SM_STAT','SM_GIST']
+
+ENUM_CLASSES.append(ScriptMode)
+
+class IntRelType(object):
+    TYPE = 'IntRelType'
+    ENUM = ['IRT_EQ','IRT_NQ','IRT_LQ','IRT_LE','IRT_GQ','IRT_GR']
+
+ENUM_CLASSES.append(IntRelType)
+
+class BoolOpType(object):
+    TYPE = 'BoolOpType'
+    ENUM = ['BOT_AND','BOT_OR','BOT_IMP','BOT_EQV','BOT_XOR']
+
+ENUM_CLASSES.append(BoolOpType)
+
+class IntConLevel(object):
+    TYPE = 'IntConLevel'
+    ENUM = ['ICL_VAL','ICL_BND','ICL_DOM','ICL_DEF']
+
+ENUM_CLASSES.append(IntConLevel)
+
+class TaskType(object):
+    TYPE = 'TaskType'
+    ENUM = ['TT_FIXP','TT_FIXS','TT_FIXE']
+
+ENUM_CLASSES.append(TaskType)
+
+class ExtensionalPropKind(object):
+    TYPE = 'ExtensionalPropKind'
+    ENUM = ['EPK_DEF','EPK_SPEED','EPK_MEMORY']
+
+ENUM_CLASSES.append(ExtensionalPropKind)
+
+class IntVarBranch(object):
+    TYPE = 'IntVarBranch'
+    ENUM = ['INT_VAR_NONE','INT_VAR_RND','INT_VAR_DEGREE_MIN','INT_VAR_DEGREE_MAX','INT_VAR_AFC_MIN','INT_VAR_AFC_MAX','INT_VAR_MIN_MIN','INT_VAR_MIN_MAX','INT_VAR_MAX_MIN','INT_VAR_MAX_MAX','INT_VAR_SIZE_MIN','INT_VAR_SIZE_MAX','INT_VAR_SIZE_DEGREE_MIN','INT_VAR_SIZE_DEGREE_MAX','INT_VAR_SIZE_AFC_MIN','INT_VAR_SIZE_AFC_MAX','INT_VAR_REGRET_MIN_MIN','INT_VAR_REGRET_MIN_MAX','INT_VAR_REGRET_MAX_MIN','INT_VAR_REGRET_MAX_MAX']
+
+ENUM_CLASSES.append(IntVarBranch)
+
+class IntValBranch(object):
+    TYPE = 'IntValBranch'
+    ENUM = ['INT_VAL_MIN','INT_VAL_MED','INT_VAL_MAX','INT_VAL_RND','INT_VAL_SPLIT_MIN','INT_VAL_SPLIT_MAX','INT_VAL_RANGE_MIN','INT_VAL_RANGE_MAX','INT_VALUES_MIN','INT_VALUES_MAX']
+
+ENUM_CLASSES.append(IntValBranch)
+
+class IntAssign(object):
+    TYPE = 'IntAssign'
+    ENUM = ['INT_ASSIGN_MIN','INT_ASSIGN_MED','INT_ASSIGN_MAX','INT_ASSIGN_RND']
+
+ENUM_CLASSES.append(IntAssign)
+
+class ViewSelStatus(object):
+    TYPE = 'ViewSelStatus'
+    ENUM = ['VSS_BEST','VSS_BETTER','VSS_TIE','VSS_WORSE']
+
+ENUM_CLASSES.append(ViewSelStatus)
+
+class ExecStatus(object):
+    TYPE = 'ExecStatus'
+    ENUM = ['__ES_SUBSUMED','ES_FAILED','ES_NOFIX','ES_OK','ES_FIX','ES_NOFIX_FORCE','__ES_PARTIAL']
+
+ENUM_CLASSES.append(ExecStatus)
+
+class ActorProperty(object):
+    TYPE = 'ActorProperty'
+    ENUM = ['AP_DISPOSE','AP_WEAKLY']
+
+ENUM_CLASSES.append(ActorProperty)
+
+class SpaceStatus(object):
+    TYPE = 'SpaceStatus'
+    ENUM = ['SS_FAILED','SS_SOLVED','SS_BRANCH']
+
+ENUM_CLASSES.append(SpaceStatus)
+
+class SetRelType(object):
+    TYPE = 'SetRelType'
+    ENUM = ['SRT_EQ','SRT_NQ','SRT_SUB','SRT_SUP','SRT_DISJ','SRT_CMPL','SRT_LQ','SRT_LE','SRT_GQ','SRT_GR']
+
+ENUM_CLASSES.append(SetRelType)
+
+class SetOpType(object):
+    TYPE = 'SetOpType'
+    ENUM = ['SOT_UNION','SOT_DUNION','SOT_INTER','SOT_MINUS']
+
+ENUM_CLASSES.append(SetOpType)
+
+class SetVarBranch(object):
+    TYPE = 'SetVarBranch'
+    ENUM = ['SET_VAR_NONE','SET_VAR_RND','SET_VAR_DEGREE_MIN','SET_VAR_DEGREE_MAX','SET_VAR_AFC_MIN','SET_VAR_AFC_MAX','SET_VAR_MIN_MIN','SET_VAR_MIN_MAX','SET_VAR_MAX_MIN','SET_VAR_MAX_MAX','SET_VAR_SIZE_MIN','SET_VAR_SIZE_MAX','SET_VAR_SIZE_DEGREE_MIN','SET_VAR_SIZE_DEGREE_MAX','SET_VAR_SIZE_AFC_MIN','SET_VAR_SIZE_AFC_MAX']
+
+ENUM_CLASSES.append(SetVarBranch)
+
+class SetValBranch(object):
+    TYPE = 'SetValBranch'
+    ENUM = ['SET_VAL_MIN_INC','SET_VAL_MIN_EXC','SET_VAL_MED_INC','SET_VAL_MED_EXC','SET_VAL_MAX_INC','SET_VAL_MAX_EXC','SET_VAL_RND_INC','SET_VAL_RND_EXC']
+
+ENUM_CLASSES.append(SetValBranch)
+
+class SetAssign(object):
+    TYPE = 'SetAssign'
+    ENUM = ['SET_ASSIGN_MIN_INC','SET_ASSIGN_MIN_EXC','SET_ASSIGN_MED_INC','SET_ASSIGN_MED_EXC','SET_ASSIGN_MAX_INC','SET_ASSIGN_MAX_EXC','SET_ASSIGN_RND_INC','SET_ASSIGN_RND_EXC']
+
+ENUM_CLASSES.append(SetAssign)
+

packages/gecode/dev/gecode-enums-3.7.1.py

@@ -0,0 +1,113 @@
+# This file was automatically extracted from Gecode source files.
+# It is subject to the same Copyright as the source files from which
+# it is derived, and is distributed under the same Licensing conditions.
+ENUM_CLASSES = []
+
+class ScriptMode(object):
+    TYPE = 'ScriptMode'
+    ENUM = ['SM_SOLUTION','SM_TIME','SM_STAT','SM_GIST']
+
+ENUM_CLASSES.append(ScriptMode)
+
+class IntRelType(object):
+    TYPE = 'IntRelType'
+    ENUM = ['IRT_EQ','IRT_NQ','IRT_LQ','IRT_LE','IRT_GQ','IRT_GR']
+
+ENUM_CLASSES.append(IntRelType)
+
+class BoolOpType(object):
+    TYPE = 'BoolOpType'
+    ENUM = ['BOT_AND','BOT_OR','BOT_IMP','BOT_EQV','BOT_XOR']
+
+ENUM_CLASSES.append(BoolOpType)
+
+class IntConLevel(object):
+    TYPE = 'IntConLevel'
+    ENUM = ['ICL_VAL','ICL_BND','ICL_DOM','ICL_DEF']
+
+ENUM_CLASSES.append(IntConLevel)
+
+class TaskType(object):
+    TYPE = 'TaskType'
+    ENUM = ['TT_FIXP','TT_FIXS','TT_FIXE']
+
+ENUM_CLASSES.append(TaskType)
+
+class ExtensionalPropKind(object):
+    TYPE = 'ExtensionalPropKind'
+    ENUM = ['EPK_DEF','EPK_SPEED','EPK_MEMORY']
+
+ENUM_CLASSES.append(ExtensionalPropKind)
+
+class IntVarBranch(object):
+    TYPE = 'IntVarBranch'
+    ENUM = ['INT_VAR_NONE','INT_VAR_RND','INT_VAR_DEGREE_MIN','INT_VAR_DEGREE_MAX','INT_VAR_AFC_MIN','INT_VAR_AFC_MAX','INT_VAR_MIN_MIN','INT_VAR_MIN_MAX','INT_VAR_MAX_MIN','INT_VAR_MAX_MAX','INT_VAR_SIZE_MIN','INT_VAR_SIZE_MAX','INT_VAR_SIZE_DEGREE_MIN','INT_VAR_SIZE_DEGREE_MAX','INT_VAR_SIZE_AFC_MIN','INT_VAR_SIZE_AFC_MAX','INT_VAR_REGRET_MIN_MIN','INT_VAR_REGRET_MIN_MAX','INT_VAR_REGRET_MAX_MIN','INT_VAR_REGRET_MAX_MAX']
+
+ENUM_CLASSES.append(IntVarBranch)
+
+class IntValBranch(object):
+    TYPE = 'IntValBranch'
+    ENUM = ['INT_VAL_MIN','INT_VAL_MED','INT_VAL_MAX','INT_VAL_RND','INT_VAL_SPLIT_MIN','INT_VAL_SPLIT_MAX','INT_VAL_RANGE_MIN','INT_VAL_RANGE_MAX','INT_VALUES_MIN','INT_VALUES_MAX']
+
+ENUM_CLASSES.append(IntValBranch)
+
+class IntAssign(object):
+    TYPE = 'IntAssign'
+    ENUM = ['INT_ASSIGN_MIN','INT_ASSIGN_MED','INT_ASSIGN_MAX','INT_ASSIGN_RND']
+
+ENUM_CLASSES.append(IntAssign)
+
+class ViewSelStatus(object):
+    TYPE = 'ViewSelStatus'
+    ENUM = ['VSS_BEST','VSS_BETTER','VSS_TIE','VSS_WORSE']
+
+ENUM_CLASSES.append(ViewSelStatus)
+
+class ExecStatus(object):
+    TYPE = 'ExecStatus'
+    ENUM = ['__ES_SUBSUMED','ES_FAILED','ES_NOFIX','ES_OK','ES_FIX','ES_NOFIX_FORCE','__ES_PARTIAL']
+
+ENUM_CLASSES.append(ExecStatus)
+
+class ActorProperty(object):
+    TYPE = 'ActorProperty'
+    ENUM = ['AP_DISPOSE','AP_WEAKLY']
+
+ENUM_CLASSES.append(ActorProperty)
+
+class SpaceStatus(object):
+    TYPE = 'SpaceStatus'
+    ENUM = ['SS_FAILED','SS_SOLVED','SS_BRANCH']
+
+ENUM_CLASSES.append(SpaceStatus)
+
+class SetRelType(object):
+    TYPE = 'SetRelType'
+    ENUM = ['SRT_EQ','SRT_NQ','SRT_SUB','SRT_SUP','SRT_DISJ','SRT_CMPL','SRT_LQ','SRT_LE','SRT_GQ','SRT_GR']
+
+ENUM_CLASSES.append(SetRelType)
+
+class SetOpType(object):
+    TYPE = 'SetOpType'
+    ENUM = ['SOT_UNION','SOT_DUNION','SOT_INTER','SOT_MINUS']
+
+ENUM_CLASSES.append(SetOpType)
+
+class SetVarBranch(object):
+    TYPE = 'SetVarBranch'
+    ENUM = ['SET_VAR_NONE','SET_VAR_RND','SET_VAR_DEGREE_MIN','SET_VAR_DEGREE_MAX','SET_VAR_AFC_MIN','SET_VAR_AFC_MAX','SET_VAR_MIN_MIN','SET_VAR_MIN_MAX','SET_VAR_MAX_MIN','SET_VAR_MAX_MAX','SET_VAR_SIZE_MIN','SET_VAR_SIZE_MAX','SET_VAR_SIZE_DEGREE_MIN','SET_VAR_SIZE_DEGREE_MAX','SET_VAR_SIZE_AFC_MIN','SET_VAR_SIZE_AFC_MAX']
+
+ENUM_CLASSES.append(SetVarBranch)
+
+class SetValBranch(object):
+    TYPE = 'SetValBranch'
+    ENUM = ['SET_VAL_MIN_INC','SET_VAL_MIN_EXC','SET_VAL_MED_INC','SET_VAL_MED_EXC','SET_VAL_MAX_INC','SET_VAL_MAX_EXC','SET_VAL_RND_INC','SET_VAL_RND_EXC']
+
+ENUM_CLASSES.append(SetValBranch)
+
+class SetAssign(object):
+    TYPE = 'SetAssign'
+    ENUM = ['SET_ASSIGN_MIN_INC','SET_ASSIGN_MIN_EXC','SET_ASSIGN_MED_INC','SET_ASSIGN_MED_EXC','SET_ASSIGN_MAX_INC','SET_ASSIGN_MAX_EXC','SET_ASSIGN_RND_INC','SET_ASSIGN_RND_EXC']
+
+ENUM_CLASSES.append(SetAssign)
+

packages/gecode/dev/gecode-enums-3.7.2.py

@@ -0,0 +1,113 @@
+# This file was automatically extracted from Gecode source files.
+# It is subject to the same Copyright as the source files from which
+# it is derived, and is distributed under the same Licensing conditions.
+ENUM_CLASSES = []
+
+class ScriptMode(object):
+    TYPE = 'ScriptMode'
+    ENUM = ['SM_SOLUTION','SM_TIME','SM_STAT','SM_GIST']
+
+ENUM_CLASSES.append(ScriptMode)
+
+class IntRelType(object):
+    TYPE = 'IntRelType'
+    ENUM = ['IRT_EQ','IRT_NQ','IRT_LQ','IRT_LE','IRT_GQ','IRT_GR']
+
+ENUM_CLASSES.append(IntRelType)
+
+class BoolOpType(object):
+    TYPE = 'BoolOpType'
+    ENUM = ['BOT_AND','BOT_OR','BOT_IMP','BOT_EQV','BOT_XOR']
+
+ENUM_CLASSES.append(BoolOpType)
+
+class IntConLevel(object):
+    TYPE = 'IntConLevel'
+    ENUM = ['ICL_VAL','ICL_BND','ICL_DOM','ICL_DEF']
+
+ENUM_CLASSES.append(IntConLevel)
+
+class TaskType(object):
+    TYPE = 'TaskType'
+    ENUM = ['TT_FIXP','TT_FIXS','TT_FIXE']
+
+ENUM_CLASSES.append(TaskType)
+
+class ExtensionalPropKind(object):
+    TYPE = 'ExtensionalPropKind'
+    ENUM = ['EPK_DEF','EPK_SPEED','EPK_MEMORY']
+
+ENUM_CLASSES.append(ExtensionalPropKind)
+
+class IntVarBranch(object):
+    TYPE = 'IntVarBranch'
+    ENUM = ['INT_VAR_NONE','INT_VAR_RND','INT_VAR_DEGREE_MIN','INT_VAR_DEGREE_MAX','INT_VAR_AFC_MIN','INT_VAR_AFC_MAX','INT_VAR_MIN_MIN','INT_VAR_MIN_MAX','INT_VAR_MAX_MIN','INT_VAR_MAX_MAX','INT_VAR_SIZE_MIN','INT_VAR_SIZE_MAX','INT_VAR_SIZE_DEGREE_MIN','INT_VAR_SIZE_DEGREE_MAX','INT_VAR_SIZE_AFC_MIN','INT_VAR_SIZE_AFC_MAX','INT_VAR_REGRET_MIN_MIN','INT_VAR_REGRET_MIN_MAX','INT_VAR_REGRET_MAX_MIN','INT_VAR_REGRET_MAX_MAX']
+
+ENUM_CLASSES.append(IntVarBranch)
+
+class IntValBranch(object):
+    TYPE = 'IntValBranch'
+    ENUM = ['INT_VAL_MIN','INT_VAL_MED','INT_VAL_MAX','INT_VAL_RND','INT_VAL_SPLIT_MIN','INT_VAL_SPLIT_MAX','INT_VAL_RANGE_MIN','INT_VAL_RANGE_MAX','INT_VALUES_MIN','INT_VALUES_MAX']
+
+ENUM_CLASSES.append(IntValBranch)
+
+class IntAssign(object):
+    TYPE = 'IntAssign'
+    ENUM = ['INT_ASSIGN_MIN','INT_ASSIGN_MED','INT_ASSIGN_MAX','INT_ASSIGN_RND']
+
+ENUM_CLASSES.append(IntAssign)
+
+class ViewSelStatus(object):
+    TYPE = 'ViewSelStatus'
+    ENUM = ['VSS_BEST','VSS_BETTER','VSS_TIE','VSS_WORSE']
+
+ENUM_CLASSES.append(ViewSelStatus)
+
+class ExecStatus(object):
+    TYPE = 'ExecStatus'
+    ENUM = ['__ES_SUBSUMED','ES_FAILED','ES_NOFIX','ES_OK','ES_FIX','ES_NOFIX_FORCE','__ES_PARTIAL']
+
+ENUM_CLASSES.append(ExecStatus)
+
+class ActorProperty(object):
+    TYPE = 'ActorProperty'
+    ENUM = ['AP_DISPOSE','AP_WEAKLY']
+
+ENUM_CLASSES.append(ActorProperty)
+
+class SpaceStatus(object):
+    TYPE = 'SpaceStatus'
+    ENUM = ['SS_FAILED','SS_SOLVED','SS_BRANCH']
+
+ENUM_CLASSES.append(SpaceStatus)
+
+class SetRelType(object):
+    TYPE = 'SetRelType'
+    ENUM = ['SRT_EQ','SRT_NQ','SRT_SUB','SRT_SUP','SRT_DISJ','SRT_CMPL','SRT_LQ','SRT_LE','SRT_GQ','SRT_GR']
+
+ENUM_CLASSES.append(SetRelType)
+
+class SetOpType(object):
+    TYPE = 'SetOpType'
+    ENUM = ['SOT_UNION','SOT_DUNION','SOT_INTER','SOT_MINUS']
+
+ENUM_CLASSES.append(SetOpType)
+
+class SetVarBranch(object):
+    TYPE = 'SetVarBranch'
+    ENUM = ['SET_VAR_NONE','SET_VAR_RND','SET_VAR_DEGREE_MIN','SET_VAR_DEGREE_MAX','SET_VAR_AFC_MIN','SET_VAR_AFC_MAX','SET_VAR_MIN_MIN','SET_VAR_MIN_MAX','SET_VAR_MAX_MIN','SET_VAR_MAX_MAX','SET_VAR_SIZE_MIN','SET_VAR_SIZE_MAX','SET_VAR_SIZE_DEGREE_MIN','SET_VAR_SIZE_DEGREE_MAX','SET_VAR_SIZE_AFC_MIN','SET_VAR_SIZE_AFC_MAX']
+
+ENUM_CLASSES.append(SetVarBranch)
+
+class SetValBranch(object):
+    TYPE = 'SetValBranch'
+    ENUM = ['SET_VAL_MIN_INC','SET_VAL_MIN_EXC','SET_VAL_MED_INC','SET_VAL_MED_EXC','SET_VAL_MAX_INC','SET_VAL_MAX_EXC','SET_VAL_RND_INC','SET_VAL_RND_EXC']
+
+ENUM_CLASSES.append(SetValBranch)
+
+class SetAssign(object):
+    TYPE = 'SetAssign'
+    ENUM = ['SET_ASSIGN_MIN_INC','SET_ASSIGN_MIN_EXC','SET_ASSIGN_MED_INC','SET_ASSIGN_MED_EXC','SET_ASSIGN_MAX_INC','SET_ASSIGN_MAX_EXC','SET_ASSIGN_RND_INC','SET_ASSIGN_RND_EXC']
+
+ENUM_CLASSES.append(SetAssign)
+

packages/gecode/dev/gecode-enums-3.7.3.py

@@ -0,0 +1,113 @@
+# This file was automatically extracted from Gecode source files.
+# It is subject to the same Copyright as the source files from which
+# it is derived, and is distributed under the same Licensing conditions.
+ENUM_CLASSES = []
+
+class ScriptMode(object):
+    TYPE = 'ScriptMode'
+    ENUM = ['SM_SOLUTION','SM_TIME','SM_STAT','SM_GIST']
+
+ENUM_CLASSES.append(ScriptMode)
+
+class IntRelType(object):
+    TYPE = 'IntRelType'
+    ENUM = ['IRT_EQ','IRT_NQ','IRT_LQ','IRT_LE','IRT_GQ','IRT_GR']
+
+ENUM_CLASSES.append(IntRelType)
+
+class BoolOpType(object):
+    TYPE = 'BoolOpType'
+    ENUM = ['BOT_AND','BOT_OR','BOT_IMP','BOT_EQV','BOT_XOR']
+
+ENUM_CLASSES.append(BoolOpType)
+
+class IntConLevel(object):
+    TYPE = 'IntConLevel'
+    ENUM = ['ICL_VAL','ICL_BND','ICL_DOM','ICL_DEF']
+
+ENUM_CLASSES.append(IntConLevel)
+
+class TaskType(object):
+    TYPE = 'TaskType'
+    ENUM = ['TT_FIXP','TT_FIXS','TT_FIXE']
+
+ENUM_CLASSES.append(TaskType)
+
+class ExtensionalPropKind(object):
+    TYPE = 'ExtensionalPropKind'
+    ENUM = ['EPK_DEF','EPK_SPEED','EPK_MEMORY']
+
+ENUM_CLASSES.append(ExtensionalPropKind)
+
+class IntVarBranch(object):
+    TYPE = 'IntVarBranch'
+    ENUM = ['INT_VAR_NONE','INT_VAR_RND','INT_VAR_DEGREE_MIN','INT_VAR_DEGREE_MAX','INT_VAR_AFC_MIN','INT_VAR_AFC_MAX','INT_VAR_MIN_MIN','INT_VAR_MIN_MAX','INT_VAR_MAX_MIN','INT_VAR_MAX_MAX','INT_VAR_SIZE_MIN','INT_VAR_SIZE_MAX','INT_VAR_SIZE_DEGREE_MIN','INT_VAR_SIZE_DEGREE_MAX','INT_VAR_SIZE_AFC_MIN','INT_VAR_SIZE_AFC_MAX','INT_VAR_REGRET_MIN_MIN','INT_VAR_REGRET_MIN_MAX','INT_VAR_REGRET_MAX_MIN','INT_VAR_REGRET_MAX_MAX']
+
+ENUM_CLASSES.append(IntVarBranch)
+
+class IntValBranch(object):
+    TYPE = 'IntValBranch'
+    ENUM = ['INT_VAL_MIN','INT_VAL_MED','INT_VAL_MAX','INT_VAL_RND','INT_VAL_SPLIT_MIN','INT_VAL_SPLIT_MAX','INT_VAL_RANGE_MIN','INT_VAL_RANGE_MAX','INT_VALUES_MIN','INT_VALUES_MAX']
+
+ENUM_CLASSES.append(IntValBranch)
+
+class IntAssign(object):
+    TYPE = 'IntAssign'
+    ENUM = ['INT_ASSIGN_MIN','INT_ASSIGN_MED','INT_ASSIGN_MAX','INT_ASSIGN_RND']
+
+ENUM_CLASSES.append(IntAssign)
+
+class ViewSelStatus(object):
+    TYPE = 'ViewSelStatus'
+    ENUM = ['VSS_BEST','VSS_BETTER','VSS_TIE','VSS_WORSE']
+
+ENUM_CLASSES.append(ViewSelStatus)
+
+class ExecStatus(object):
+    TYPE = 'ExecStatus'
+    ENUM = ['__ES_SUBSUMED','ES_FAILED','ES_NOFIX','ES_OK','ES_FIX','ES_NOFIX_FORCE','__ES_PARTIAL']
+
+ENUM_CLASSES.append(ExecStatus)
+
+class ActorProperty(object):
+    TYPE = 'ActorProperty'
+    ENUM = ['AP_DISPOSE','AP_WEAKLY']
+
+ENUM_CLASSES.append(ActorProperty)
+
+class SpaceStatus(object):
+    TYPE = 'SpaceStatus'
+    ENUM = ['SS_FAILED','SS_SOLVED','SS_BRANCH']
+
+ENUM_CLASSES.append(SpaceStatus)
+
+class SetRelType(object):
+    TYPE = 'SetRelType'
+    ENUM = ['SRT_EQ','SRT_NQ','SRT_SUB','SRT_SUP','SRT_DISJ','SRT_CMPL','SRT_LQ','SRT_LE','SRT_GQ','SRT_GR']
+
+ENUM_CLASSES.append(SetRelType)
+
+class SetOpType(object):
+    TYPE = 'SetOpType'
+    ENUM = ['SOT_UNION','SOT_DUNION','SOT_INTER','SOT_MINUS']
+
+ENUM_CLASSES.append(SetOpType)
+
+class SetVarBranch(object):
+    TYPE = 'SetVarBranch'
+    ENUM = ['SET_VAR_NONE','SET_VAR_RND','SET_VAR_DEGREE_MIN','SET_VAR_DEGREE_MAX','SET_VAR_AFC_MIN','SET_VAR_AFC_MAX','SET_VAR_MIN_MIN','SET_VAR_MIN_MAX','SET_VAR_MAX_MIN','SET_VAR_MAX_MAX','SET_VAR_SIZE_MIN','SET_VAR_SIZE_MAX','SET_VAR_SIZE_DEGREE_MIN','SET_VAR_SIZE_DEGREE_MAX','SET_VAR_SIZE_AFC_MIN','SET_VAR_SIZE_AFC_MAX']
+
+ENUM_CLASSES.append(SetVarBranch)
+
+class SetValBranch(object):
+    TYPE = 'SetValBranch'
+    ENUM = ['SET_VAL_MIN_INC','SET_VAL_MIN_EXC','SET_VAL_MED_INC','SET_VAL_MED_EXC','SET_VAL_MAX_INC','SET_VAL_MAX_EXC','SET_VAL_RND_INC','SET_VAL_RND_EXC']
+
+ENUM_CLASSES.append(SetValBranch)
+
+class SetAssign(object):
+    TYPE = 'SetAssign'
+    ENUM = ['SET_ASSIGN_MIN_INC','SET_ASSIGN_MIN_EXC','SET_ASSIGN_MED_INC','SET_ASSIGN_MED_EXC','SET_ASSIGN_MAX_INC','SET_ASSIGN_MAX_EXC','SET_ASSIGN_RND_INC','SET_ASSIGN_RND_EXC']
+
+ENUM_CLASSES.append(SetAssign)
+

packages/gecode/dev/gecode-enums-4.0.0.py

@@ -0,0 +1,119 @@
+# This file was automatically extracted from Gecode source files.
+# It is subject to the same Copyright as the source files from which
+# it is derived, and is distributed under the same Licensing conditions.
+ENUM_CLASSES = []
+
+class ScriptMode(object):
+    TYPE = 'ScriptMode'
+    ENUM = ['SM_SOLUTION','SM_TIME','SM_STAT','SM_GIST']
+
+ENUM_CLASSES.append(ScriptMode)
+
+class ReifyMode(object):
+    TYPE = 'ReifyMode'
+    ENUM = ['RM_EQV','RM_IMP','RM_PMI']
+
+ENUM_CLASSES.append(ReifyMode)
+
+class IntRelType(object):
+    TYPE = 'IntRelType'
+    ENUM = ['IRT_EQ','IRT_NQ','IRT_LQ','IRT_LE','IRT_GQ','IRT_GR']
+
+ENUM_CLASSES.append(IntRelType)
+
+class BoolOpType(object):
+    TYPE = 'BoolOpType'
+    ENUM = ['BOT_AND','BOT_OR','BOT_IMP','BOT_EQV','BOT_XOR']
+
+ENUM_CLASSES.append(BoolOpType)
+
+class IntConLevel(object):
+    TYPE = 'IntConLevel'
+    ENUM = ['ICL_VAL','ICL_BND','ICL_DOM','ICL_DEF']
+
+ENUM_CLASSES.append(IntConLevel)
+
+class TaskType(object):
+    TYPE = 'TaskType'
+    ENUM = ['TT_FIXP','TT_FIXS','TT_FIXE']
+
+ENUM_CLASSES.append(TaskType)
+
+class ExtensionalPropKind(object):
+    TYPE = 'ExtensionalPropKind'
+    ENUM = ['EPK_DEF','EPK_SPEED','EPK_MEMORY']
+
+ENUM_CLASSES.append(ExtensionalPropKind)
+
+class IntVarBranch(object):
+    TYPE = 'IntVarBranch'
+    ENUM = ['INT_VAR_NONE','INT_VAR_RND','INT_VAR_DEGREE_MIN','INT_VAR_DEGREE_MAX','INT_VAR_AFC_MIN','INT_VAR_AFC_MAX','INT_VAR_MIN_MIN','INT_VAR_MIN_MAX','INT_VAR_MAX_MIN','INT_VAR_MAX_MAX','INT_VAR_SIZE_MIN','INT_VAR_SIZE_MAX','INT_VAR_SIZE_DEGREE_MIN','INT_VAR_SIZE_DEGREE_MAX','INT_VAR_SIZE_AFC_MIN','INT_VAR_SIZE_AFC_MAX','INT_VAR_REGRET_MIN_MIN','INT_VAR_REGRET_MIN_MAX','INT_VAR_REGRET_MAX_MIN','INT_VAR_REGRET_MAX_MAX']
+
+ENUM_CLASSES.append(IntVarBranch)
+
+class IntValBranch(object):
+    TYPE = 'IntValBranch'
+    ENUM = ['INT_VAL_MIN','INT_VAL_MED','INT_VAL_MAX','INT_VAL_RND','INT_VAL_SPLIT_MIN','INT_VAL_SPLIT_MAX','INT_VAL_RANGE_MIN','INT_VAL_RANGE_MAX','INT_VALUES_MIN','INT_VALUES_MAX']
+
+ENUM_CLASSES.append(IntValBranch)
+
+class IntAssign(object):
+    TYPE = 'IntAssign'
+    ENUM = ['INT_ASSIGN_MIN','INT_ASSIGN_MED','INT_ASSIGN_MAX','INT_ASSIGN_RND']
+
+ENUM_CLASSES.append(IntAssign)
+
+class ViewSelStatus(object):
+    TYPE = 'ViewSelStatus'
+    ENUM = ['VSS_BEST','VSS_BETTER','VSS_TIE','VSS_WORSE']
+
+ENUM_CLASSES.append(ViewSelStatus)
+
+class ExecStatus(object):
+    TYPE = 'ExecStatus'
+    ENUM = ['__ES_SUBSUMED','ES_FAILED','ES_NOFIX','ES_OK','ES_FIX','ES_NOFIX_FORCE','__ES_PARTIAL']
+
+ENUM_CLASSES.append(ExecStatus)
+
+class ActorProperty(object):
+    TYPE = 'ActorProperty'
+    ENUM = ['AP_DISPOSE','AP_WEAKLY']
+
+ENUM_CLASSES.append(ActorProperty)
+
+class SpaceStatus(object):
+    TYPE = 'SpaceStatus'
+    ENUM = ['SS_FAILED','SS_SOLVED','SS_BRANCH']
+
+ENUM_CLASSES.append(SpaceStatus)
+
+class SetRelType(object):
+    TYPE = 'SetRelType'
+    ENUM = ['SRT_EQ','SRT_NQ','SRT_SUB','SRT_SUP','SRT_DISJ','SRT_CMPL','SRT_LQ','SRT_LE','SRT_GQ','SRT_GR']
+
+ENUM_CLASSES.append(SetRelType)
+
+class SetOpType(object):
+    TYPE = 'SetOpType'
+    ENUM = ['SOT_UNION','SOT_DUNION','SOT_INTER','SOT_MINUS']
+
+ENUM_CLASSES.append(SetOpType)
+
+class SetVarBranch(object):
+    TYPE = 'SetVarBranch'
+    ENUM = ['SET_VAR_NONE','SET_VAR_RND','SET_VAR_DEGREE_MIN','SET_VAR_DEGREE_MAX','SET_VAR_AFC_MIN','SET_VAR_AFC_MAX','SET_VAR_MIN_MIN','SET_VAR_MIN_MAX','SET_VAR_MAX_MIN','SET_VAR_MAX_MAX','SET_VAR_SIZE_MIN','SET_VAR_SIZE_MAX','SET_VAR_SIZE_DEGREE_MIN','SET_VAR_SIZE_DEGREE_MAX','SET_VAR_SIZE_AFC_MIN','SET_VAR_SIZE_AFC_MAX']
+
+ENUM_CLASSES.append(SetVarBranch)
+
+class SetValBranch(object):
+    TYPE = 'SetValBranch'
+    ENUM = ['SET_VAL_MIN_INC','SET_VAL_MIN_EXC','SET_VAL_MED_INC','SET_VAL_MED_EXC','SET_VAL_MAX_INC','SET_VAL_MAX_EXC','SET_VAL_RND_INC','SET_VAL_RND_EXC']
+
+ENUM_CLASSES.append(SetValBranch)
+
+class SetAssign(object):
+    TYPE = 'SetAssign'
+    ENUM = ['SET_ASSIGN_MIN_INC','SET_ASSIGN_MIN_EXC','SET_ASSIGN_MED_INC','SET_ASSIGN_MED_EXC','SET_ASSIGN_MAX_INC','SET_ASSIGN_MAX_EXC','SET_ASSIGN_RND_INC','SET_ASSIGN_RND_EXC']
+
+ENUM_CLASSES.append(SetAssign)
+

packages/gecode/dev/gecode-enums-4.2.0.py

@@ -0,0 +1,95 @@
+# This file was automatically extracted from Gecode source files.
+# It is subject to the same Copyright as the source files from which
+# it is derived, and is distributed under the same Licensing conditions.
+ENUM_CLASSES = []
+
+class ScriptMode(object):
+    TYPE = 'ScriptMode'
+    ENUM = ['SM_SOLUTION','SM_TIME','SM_STAT','SM_GIST']
+
+ENUM_CLASSES.append(ScriptMode)
+
+class RestartMode(object):
+    TYPE = 'RestartMode'
+    ENUM = ['RM_NONE','RM_CONSTANT','RM_LINEAR','RM_LUBY','RM_GEOMETRIC']
+
+ENUM_CLASSES.append(RestartMode)
+
+class FloatRelType(object):
+    TYPE = 'FloatRelType'
+    ENUM = ['FRT_EQ','FRT_NQ','FRT_LQ','FRT_LE','FRT_GQ','FRT_GR']
+
+ENUM_CLASSES.append(FloatRelType)
+
+class ReifyMode(object):
+    TYPE = 'ReifyMode'
+    ENUM = ['RM_EQV','RM_IMP','RM_PMI']
+
+ENUM_CLASSES.append(ReifyMode)
+
+class IntRelType(object):
+    TYPE = 'IntRelType'
+    ENUM = ['IRT_EQ','IRT_NQ','IRT_LQ','IRT_LE','IRT_GQ','IRT_GR']
+
+ENUM_CLASSES.append(IntRelType)
+
+class BoolOpType(object):
+    TYPE = 'BoolOpType'
+    ENUM = ['BOT_AND','BOT_OR','BOT_IMP','BOT_EQV','BOT_XOR']
+
+ENUM_CLASSES.append(BoolOpType)
+
+class IntConLevel(object):
+    TYPE = 'IntConLevel'
+    ENUM = ['ICL_VAL','ICL_BND','ICL_DOM','ICL_DEF']
+
+ENUM_CLASSES.append(IntConLevel)
+
+class TaskType(object):
+    TYPE = 'TaskType'
+    ENUM = ['TT_FIXP','TT_FIXS','TT_FIXE']
+
+ENUM_CLASSES.append(TaskType)
+
+class ExtensionalPropKind(object):
+    TYPE = 'ExtensionalPropKind'
+    ENUM = ['EPK_DEF','EPK_SPEED','EPK_MEMORY']
+
+ENUM_CLASSES.append(ExtensionalPropKind)
+
+class ViewSelStatus(object):
+    TYPE = 'ViewSelStatus'
+    ENUM = ['VSS_BEST','VSS_BETTER','VSS_TIE','VSS_WORSE']
+
+ENUM_CLASSES.append(ViewSelStatus)
+
+class ExecStatus(object):
+    TYPE = 'ExecStatus'
+    ENUM = ['__ES_SUBSUMED','ES_FAILED','ES_NOFIX','ES_OK','ES_FIX','ES_NOFIX_FORCE','__ES_PARTIAL']
+
+ENUM_CLASSES.append(ExecStatus)
+
+class ActorProperty(object):
+    TYPE = 'ActorProperty'
+    ENUM = ['AP_DISPOSE','AP_WEAKLY']
+
+ENUM_CLASSES.append(ActorProperty)
+
+class SpaceStatus(object):
+    TYPE = 'SpaceStatus'
+    ENUM = ['SS_FAILED','SS_SOLVED','SS_BRANCH']
+
+ENUM_CLASSES.append(SpaceStatus)
+
+class SetRelType(object):
+    TYPE = 'SetRelType'
+    ENUM = ['SRT_EQ','SRT_NQ','SRT_SUB','SRT_SUP','SRT_DISJ','SRT_CMPL','SRT_LQ','SRT_LE','SRT_GQ','SRT_GR']
+
+ENUM_CLASSES.append(SetRelType)
+
+class SetOpType(object):
+    TYPE = 'SetOpType'
+    ENUM = ['SOT_UNION','SOT_DUNION','SOT_INTER','SOT_MINUS']
+
+ENUM_CLASSES.append(SetOpType)
+

packages/gecode/dev/gecode-prototypes-3.6.0.hh

@@ -0,0 +1,209 @@
+// This file was automatically extracted from Gecode source files.
+// It is subject to the same Copyright as the source files from which
+// it is derived, and is distributed under the same Licensing conditions.
+void abs(Home,IntVar,IntVar,IntConLevel=ICL_DEF);
+void assign(Home,BoolVar,IntAssign,const ValBranchOptions&=ValBranchOptions::def);
+void assign(Home,const BoolVarArgs&,IntAssign,const ValBranchOptions&=ValBranchOptions::def);
+void assign(Home,const IntVarArgs&,IntAssign,const ValBranchOptions&=ValBranchOptions::def);
+void assign(Home,const SetVarArgs&,SetAssign,const ValBranchOptions&=ValBranchOptions::def);
+void assign(Home,IntVar,IntAssign,const ValBranchOptions&=ValBranchOptions::def);
+void assign(Home,SetVar,SetAssign,const ValBranchOptions&=ValBranchOptions::def);
+void atmostOne(Home,const SetVarArgs&,unsigned int);
+void binpacking(Home,const IntVarArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void branch(Home,BoolVar,IntValBranch,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,const BoolVarArgs&,const TieBreakVarBranch<IntVarBranch>&,IntValBranch,const TieBreakVarBranchOptions&=TieBreakVarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,const BoolVarArgs&,IntVarBranch,IntValBranch,const VarBranchOptions&=VarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,const IntVarArgs&,const TieBreakVarBranch<IntVarBranch>&,IntValBranch,const TieBreakVarBranchOptions&=TieBreakVarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,const IntVarArgs&,IntVarBranch,IntValBranch,const VarBranchOptions&=VarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,const SetVarArgs&,const TieBreakVarBranch<SetVarBranch>&,SetValBranch,const TieBreakVarBranchOptions&=TieBreakVarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,const SetVarArgs&,SetVarBranch,SetValBranch,const VarBranchOptions&=VarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,IntVar,IntValBranch,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,SetVar,SetValBranch,const ValBranchOptions&=ValBranchOptions::def);
+void cardinality(Home,SetVar,IntVar);
+void cardinality(Home,SetVar,unsigned int,unsigned int);
+void channel(Home,BoolVar,IntVar,IntConLevel=ICL_DEF);
+void channel(Home,const BoolVarArgs&,IntVar,int=0,IntConLevel=ICL_DEF);
+void channel(Home,const BoolVarArgs&,SetVar);
+void channel(Home,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void channel(Home,const IntVarArgs&,const SetVarArgs&);
+void channel(Home,const IntVarArgs&,int,const IntVarArgs&,int,IntConLevel=ICL_DEF);
+void channel(Home,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void channelSorted(Home,const IntVarArgs&,SetVar);
+void circuit(Home,const IntArgs&,const IntVarArgs&,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void circuit(Home,const IntArgs&,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void circuit(Home,const IntArgs&,int,const IntVarArgs&,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void circuit(Home,const IntArgs&,int,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void circuit(Home,const IntVarArgs&,IntConLevel=ICL_DEF);
+void circuit(Home,int,const IntVarArgs&,IntConLevel=ICL_DEF);
+void clause(Home,BoolOpType,const BoolVarArgs&,const BoolVarArgs&,BoolVar,IntConLevel=ICL_DEF);
+void clause(Home,BoolOpType,const BoolVarArgs&,const BoolVarArgs&,int,IntConLevel=ICL_DEF);
+void convex(Home,SetVar);
+void convex(Home,SetVar,SetVar);
+void count(Home,const IntVarArgs&,const IntArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSetArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSetArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSet&,const IntArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,int,IntRelType,int,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,int,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,IntVar,IntRelType,int,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,IntVar,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const IntVarArgs&,const IntArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const IntVarArgs&,const IntArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const IntVarArgs&,const IntArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const IntVarArgs&,const IntArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntArgs&,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntArgs&,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void distinct(Home,const IntArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void distinct(Home,const IntVarArgs&,IntConLevel=ICL_DEF);
+void div(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void divmod(Home,IntVar,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void dom(Home,const IntVarArgs&,const IntSet&,IntConLevel=ICL_DEF);
+void dom(Home,const IntVarArgs&,int,IntConLevel=ICL_DEF);
+void dom(Home,const IntVarArgs&,int,int,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,const IntSet&,BoolVar,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,const IntSet&,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,int,BoolVar,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,int,int,BoolVar,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,int,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,int,int,IntConLevel=ICL_DEF);
+void dom(Home,SetVar,SetRelType,const IntSet&);
+void dom(Home,SetVar,SetRelType,const IntSet&,BoolVar);
+void dom(Home,SetVar,SetRelType,int);
+void dom(Home,SetVar,SetRelType,int,BoolVar);
+void dom(Home,SetVar,SetRelType,int,int);
+void dom(Home,SetVar,SetRelType,int,int,BoolVar);
+void element(Home,const BoolVarArgs&,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void element(Home,const BoolVarArgs&,IntVar,int,IntConLevel=ICL_DEF);
+void element(Home,const BoolVarArgs&,IntVar,int,IntVar,int,BoolVar,IntConLevel=ICL_DEF);
+void element(Home,const IntSetArgs&,IntVar,int,IntVar,int,SetVar);
+void element(Home,const IntSetArgs&,IntVar,SetVar);
+void element(Home,const IntVarArgs&,IntVar,int,IntConLevel=ICL_DEF);
+void element(Home,const IntVarArgs&,IntVar,int,IntVar,int,IntVar,IntConLevel=ICL_DEF);
+void element(Home,const IntVarArgs&,IntVar,IntVar,IntConLevel=ICL_DEF);
+void element(Home,const SetVarArgs&,IntVar,int,IntVar,int,SetVar);
+void element(Home,const SetVarArgs&,IntVar,SetVar);
+void element(Home,IntSharedArray,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void element(Home,IntSharedArray,IntVar,int,IntConLevel=ICL_DEF);
+void element(Home,IntSharedArray,IntVar,int,IntVar,int,BoolVar,IntConLevel=ICL_DEF);
+void element(Home,IntSharedArray,IntVar,int,IntVar,int,IntVar,IntConLevel=ICL_DEF);
+void element(Home,IntSharedArray,IntVar,IntVar,IntConLevel=ICL_DEF);
+void element(Home,SetOpType,const IntSetArgs&,SetVar,SetVar,const IntSet&=IntSet(Set::Limits::min,Set::Limits::max));
+void element(Home,SetOpType,const SetVarArgs&,SetVar,SetVar,const IntSet&=IntSet(Set::Limits::min,Set::Limits::max));
+void extensional(Home,const BoolVarArgs&,const TupleSet&,ExtensionalPropKind=EPK_DEF,IntConLevel=ICL_DEF);
+void extensional(Home,const BoolVarArgs&,DFA,IntConLevel=ICL_DEF);
+void extensional(Home,const IntVarArgs&,const TupleSet&,ExtensionalPropKind=EPK_DEF,IntConLevel=ICL_DEF);
+void extensional(Home,const IntVarArgs&,DFA,IntConLevel=ICL_DEF);
+void linear(Home,const BoolVarArgs&,IntRelType,int,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const BoolVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void linear(Home,const BoolVarArgs&,IntRelType,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const BoolVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const BoolVarArgs&,IntRelType,int,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const BoolVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const BoolVarArgs&,IntRelType,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const BoolVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const IntVarArgs&,IntRelType,int,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const IntVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const IntVarArgs&,IntRelType,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const IntVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntVarArgs&,IntRelType,int,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void linear(Home,const IntVarArgs&,IntRelType,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void max(Home,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void max(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void max(Home,SetVar,IntVar);
+void max(Home,SetVar,IntVar,BoolVar);
+void min(Home,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void min(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void min(Home,SetVar,IntVar);
+void min(Home,SetVar,IntVar,BoolVar);
+void mod(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void mult(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void nooverlap(Home,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void nooverlap(Home,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void nooverlap(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void nooverlap(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void notMax(Home,SetVar,IntVar);
+void notMin(Home,SetVar,IntVar);
+void path(Home,const IntArgs&,const IntVarArgs&,IntVar,IntVar,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntArgs&,const IntVarArgs&,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntArgs&,int,const IntVarArgs&,IntVar,IntVar,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntArgs&,int,const IntVarArgs&,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntVarArgs&,IntVar,IntVar,IntConLevel=ICL_DEF);
+void path(Home,int,const IntVarArgs&,IntVar,IntVar,IntConLevel=ICL_DEF);
+void precede(Home,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void precede(Home,const IntVarArgs&,int,int,IntConLevel=ICL_DEF);
+void precede(Home,const SetVarArgs&,const IntArgs&);
+void precede(Home,const SetVarArgs&,int,int);
+void rel(Home,BoolOpType,const BoolVarArgs&,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,BoolOpType,const BoolVarArgs&,int,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,BoolOpType,BoolVar,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,BoolOpType,BoolVar,int,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,IntRelType,BoolVar,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,IntRelType,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,IntRelType,int,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,IntRelType,int,IntConLevel=ICL_DEF);
+void rel(Home,const BoolVarArgs&,IntRelType,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,const BoolVarArgs&,IntRelType,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void rel(Home,const BoolVarArgs&,IntRelType,IntConLevel=ICL_DEF);
+void rel(Home,const BoolVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void rel(Home,const IntSet&,SetOpType,SetVar,SetRelType,const IntSet&);
+void rel(Home,const IntSet&,SetOpType,SetVar,SetRelType,SetVar);
+void rel(Home,const IntVarArgs&,IntRelType,const IntVarArgs&,IntConLevel=ICL_DEF);
+void rel(Home,const IntVarArgs&,IntRelType,IntConLevel=ICL_DEF);
+void rel(Home,const IntVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void rel(Home,const IntVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,int,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,int,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,SetVar);
+void rel(Home,IntVar,SetRelType,SetVar);
+void rel(Home,IntVar,SetRelType,SetVar,BoolVar);
+void rel(Home,SetOpType,const IntVarArgs&,const IntSet&,SetVar);
+void rel(Home,SetOpType,const IntVarArgs&,SetVar);
+void rel(Home,SetOpType,const SetVarArgs&,const IntSet&,SetVar);
+void rel(Home,SetOpType,const SetVarArgs&,SetVar);
+void rel(Home,SetVar,IntRelType,IntVar);
+void rel(Home,SetVar,SetOpType,const IntSet&,SetRelType,const IntSet&);
+void rel(Home,SetVar,SetOpType,const IntSet&,SetRelType,SetVar);
+void rel(Home,SetVar,SetOpType,SetVar,SetRelType,const IntSet&);
+void rel(Home,SetVar,SetOpType,SetVar,SetRelType,SetVar);
+void rel(Home,SetVar,SetRelType,IntVar);
+void rel(Home,SetVar,SetRelType,IntVar,BoolVar);
+void rel(Home,SetVar,SetRelType,SetVar);
+void rel(Home,SetVar,SetRelType,SetVar,BoolVar);
+void sequence(Home,const BoolVarArgs&,const IntSet&,int,int,int,IntConLevel=ICL_DEF);
+void sequence(Home,const IntVarArgs&,const IntSet&,int,int,int,IntConLevel=ICL_DEF);
+void sequence(Home,const SetVarArgs&);
+void sequence(Home,const SetVarArgs&,SetVar);
+void sorted(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void sorted(Home,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void sqr(Home,IntVar,IntVar,IntConLevel=ICL_DEF);
+void sqrt(Home,IntVar,IntVar,IntConLevel=ICL_DEF);
+void unary(Home,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void unshare(Home,BoolVarArgs&,IntConLevel=ICL_DEF);
+void unshare(Home,IntVarArgs&,IntConLevel=ICL_DEF);
+void weights(Home,const IntArgs&,const IntArgs&,SetVar,IntVar);

packages/gecode/dev/gecode-prototypes-3.7.0.hh

@@ -0,0 +1,221 @@
+// This file was automatically extracted from Gecode source files.
+// It is subject to the same Copyright as the source files from which
+// it is derived, and is distributed under the same Licensing conditions.
+void abs(Home,IntVar,IntVar,IntConLevel=ICL_DEF);
+void assign(Home,BoolVar,IntAssign,const ValBranchOptions&=ValBranchOptions::def);
+void assign(Home,const BoolVarArgs&,IntAssign,const ValBranchOptions&=ValBranchOptions::def);
+void assign(Home,const IntVarArgs&,IntAssign,const ValBranchOptions&=ValBranchOptions::def);
+void assign(Home,const SetVarArgs&,SetAssign,const ValBranchOptions&=ValBranchOptions::def);
+void assign(Home,IntVar,IntAssign,const ValBranchOptions&=ValBranchOptions::def);
+void assign(Home,SetVar,SetAssign,const ValBranchOptions&=ValBranchOptions::def);
+void atmostOne(Home,const SetVarArgs&,unsigned int);
+void binpacking(Home,const IntVarArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void branch(Home,BoolVar,IntValBranch,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,const BoolVarArgs&,const TieBreakVarBranch<IntVarBranch>&,IntValBranch,const TieBreakVarBranchOptions&=TieBreakVarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,const BoolVarArgs&,IntVarBranch,IntValBranch,const VarBranchOptions&=VarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,const IntVarArgs&,const TieBreakVarBranch<IntVarBranch>&,IntValBranch,const TieBreakVarBranchOptions&=TieBreakVarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,const IntVarArgs&,IntVarBranch,IntValBranch,const VarBranchOptions&=VarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,const SetVarArgs&,const TieBreakVarBranch<SetVarBranch>&,SetValBranch,const TieBreakVarBranchOptions&=TieBreakVarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,const SetVarArgs&,SetVarBranch,SetValBranch,const VarBranchOptions&=VarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,IntVar,IntValBranch,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,SetVar,SetValBranch,const ValBranchOptions&=ValBranchOptions::def);
+void cardinality(Home,SetVar,IntVar);
+void cardinality(Home,SetVar,unsigned int,unsigned int);
+void channel(Home,BoolVar,IntVar,IntConLevel=ICL_DEF);
+void channel(Home,const BoolVarArgs&,IntVar,int=0,IntConLevel=ICL_DEF);
+void channel(Home,const BoolVarArgs&,SetVar);
+void channel(Home,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void channel(Home,const IntVarArgs&,const SetVarArgs&);
+void channel(Home,const IntVarArgs&,int,const IntVarArgs&,int,IntConLevel=ICL_DEF);
+void channel(Home,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void channelSorted(Home,const IntVarArgs&,SetVar);
+void circuit(Home,const IntArgs&,const IntVarArgs&,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void circuit(Home,const IntArgs&,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void circuit(Home,const IntArgs&,int,const IntVarArgs&,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void circuit(Home,const IntArgs&,int,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void circuit(Home,const IntVarArgs&,IntConLevel=ICL_DEF);
+void circuit(Home,int,const IntVarArgs&,IntConLevel=ICL_DEF);
+void clause(Home,BoolOpType,const BoolVarArgs&,const BoolVarArgs&,BoolVar,IntConLevel=ICL_DEF);
+void clause(Home,BoolOpType,const BoolVarArgs&,const BoolVarArgs&,int,IntConLevel=ICL_DEF);
+void convex(Home,SetVar);
+void convex(Home,SetVar,SetVar);
+void count(Home,const IntVarArgs&,const IntArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSetArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSetArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSet&,const IntArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSet&,IntRelType,int,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSet&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,int,IntRelType,int,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,int,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,IntVar,IntRelType,int,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,IntVar,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const IntVarArgs&,const IntArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const IntVarArgs&,const IntArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const IntVarArgs&,const IntArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const IntVarArgs&,const IntArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntArgs&,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntArgs&,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void distinct(Home,const IntArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void distinct(Home,const IntVarArgs&,IntConLevel=ICL_DEF);
+void div(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void divmod(Home,IntVar,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void dom(Home,const IntVarArgs&,const IntSet&,IntConLevel=ICL_DEF);
+void dom(Home,const IntVarArgs&,int,IntConLevel=ICL_DEF);
+void dom(Home,const IntVarArgs&,int,int,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,const IntSet&,BoolVar,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,const IntSet&,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,int,BoolVar,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,int,int,BoolVar,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,int,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,int,int,IntConLevel=ICL_DEF);
+void dom(Home,SetVar,SetRelType,const IntSet&);
+void dom(Home,SetVar,SetRelType,const IntSet&,BoolVar);
+void dom(Home,SetVar,SetRelType,int);
+void dom(Home,SetVar,SetRelType,int,BoolVar);
+void dom(Home,SetVar,SetRelType,int,int);
+void dom(Home,SetVar,SetRelType,int,int,BoolVar);
+void element(Home,const BoolVarArgs&,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void element(Home,const BoolVarArgs&,IntVar,int,IntConLevel=ICL_DEF);
+void element(Home,const BoolVarArgs&,IntVar,int,IntVar,int,BoolVar,IntConLevel=ICL_DEF);
+void element(Home,const IntSetArgs&,IntVar,int,IntVar,int,SetVar);
+void element(Home,const IntSetArgs&,IntVar,SetVar);
+void element(Home,const IntVarArgs&,IntVar,int,IntConLevel=ICL_DEF);
+void element(Home,const IntVarArgs&,IntVar,int,IntVar,int,IntVar,IntConLevel=ICL_DEF);
+void element(Home,const IntVarArgs&,IntVar,IntVar,IntConLevel=ICL_DEF);
+void element(Home,const SetVarArgs&,IntVar,int,IntVar,int,SetVar);
+void element(Home,const SetVarArgs&,IntVar,SetVar);
+void element(Home,IntSharedArray,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void element(Home,IntSharedArray,IntVar,int,IntConLevel=ICL_DEF);
+void element(Home,IntSharedArray,IntVar,int,IntVar,int,BoolVar,IntConLevel=ICL_DEF);
+void element(Home,IntSharedArray,IntVar,int,IntVar,int,IntVar,IntConLevel=ICL_DEF);
+void element(Home,IntSharedArray,IntVar,IntVar,IntConLevel=ICL_DEF);
+void element(Home,SetOpType,const IntArgs&,SetVar,SetVar,const IntSet&=IntSet(Set::Limits::min,Set::Limits::max));
+void element(Home,SetOpType,const IntSetArgs&,SetVar,SetVar,const IntSet&=IntSet(Set::Limits::min,Set::Limits::max));
+void element(Home,SetOpType,const IntVarArgs&,SetVar,SetVar,const IntSet&=IntSet(Set::Limits::min,Set::Limits::max));
+void element(Home,SetOpType,const SetVarArgs&,SetVar,SetVar,const IntSet&=IntSet(Set::Limits::min,Set::Limits::max));
+void extensional(Home,const BoolVarArgs&,const TupleSet&,ExtensionalPropKind=EPK_DEF,IntConLevel=ICL_DEF);
+void extensional(Home,const BoolVarArgs&,DFA,IntConLevel=ICL_DEF);
+void extensional(Home,const IntVarArgs&,const TupleSet&,ExtensionalPropKind=EPK_DEF,IntConLevel=ICL_DEF);
+void extensional(Home,const IntVarArgs&,DFA,IntConLevel=ICL_DEF);
+void linear(Home,const BoolVarArgs&,IntRelType,int,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const BoolVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void linear(Home,const BoolVarArgs&,IntRelType,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const BoolVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const BoolVarArgs&,IntRelType,int,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const BoolVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const BoolVarArgs&,IntRelType,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const BoolVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const IntVarArgs&,IntRelType,int,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const IntVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const IntVarArgs&,IntRelType,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const IntVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntVarArgs&,IntRelType,int,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void linear(Home,const IntVarArgs&,IntRelType,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void max(Home,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void max(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void max(Home,SetVar,IntVar);
+void max(Home,SetVar,IntVar,BoolVar);
+void member(Home,const BoolVarArgs&,BoolVar,BoolVar,IntConLevel=ICL_DEF);
+void member(Home,const BoolVarArgs&,BoolVar,IntConLevel=ICL_DEF);
+void member(Home,const IntVarArgs&,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void member(Home,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void min(Home,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void min(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void min(Home,SetVar,IntVar);
+void min(Home,SetVar,IntVar,BoolVar);
+void mod(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void mult(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void nooverlap(Home,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void nooverlap(Home,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void nooverlap(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void nooverlap(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void notMax(Home,SetVar,IntVar);
+void notMin(Home,SetVar,IntVar);
+void nvalues(Home,const BoolVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void nvalues(Home,const BoolVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void nvalues(Home,const IntVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void nvalues(Home,const IntVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntArgs&,const IntVarArgs&,IntVar,IntVar,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntArgs&,const IntVarArgs&,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntArgs&,int,const IntVarArgs&,IntVar,IntVar,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntArgs&,int,const IntVarArgs&,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntVarArgs&,IntVar,IntVar,IntConLevel=ICL_DEF);
+void path(Home,int,const IntVarArgs&,IntVar,IntVar,IntConLevel=ICL_DEF);
+void precede(Home,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void precede(Home,const IntVarArgs&,int,int,IntConLevel=ICL_DEF);
+void precede(Home,const SetVarArgs&,const IntArgs&);
+void precede(Home,const SetVarArgs&,int,int);
+void rel(Home,BoolOpType,const BoolVarArgs&,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,BoolOpType,const BoolVarArgs&,int,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,BoolOpType,BoolVar,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,BoolOpType,BoolVar,int,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,IntRelType,BoolVar,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,IntRelType,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,IntRelType,int,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,IntRelType,int,IntConLevel=ICL_DEF);
+void rel(Home,const BoolVarArgs&,IntRelType,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,const BoolVarArgs&,IntRelType,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void rel(Home,const BoolVarArgs&,IntRelType,IntConLevel=ICL_DEF);
+void rel(Home,const BoolVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void rel(Home,const IntSet&,SetOpType,SetVar,SetRelType,const IntSet&);
+void rel(Home,const IntSet&,SetOpType,SetVar,SetRelType,SetVar);
+void rel(Home,const IntVarArgs&,IntRelType,const IntVarArgs&,IntConLevel=ICL_DEF);
+void rel(Home,const IntVarArgs&,IntRelType,IntConLevel=ICL_DEF);
+void rel(Home,const IntVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void rel(Home,const IntVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,int,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,int,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,SetVar);
+void rel(Home,IntVar,SetRelType,SetVar);
+void rel(Home,IntVar,SetRelType,SetVar,BoolVar);
+void rel(Home,SetOpType,const IntVarArgs&,const IntSet&,SetVar);
+void rel(Home,SetOpType,const IntVarArgs&,SetVar);
+void rel(Home,SetOpType,const SetVarArgs&,const IntSet&,SetVar);
+void rel(Home,SetOpType,const SetVarArgs&,SetVar);
+void rel(Home,SetVar,IntRelType,IntVar);
+void rel(Home,SetVar,SetOpType,const IntSet&,SetRelType,const IntSet&);
+void rel(Home,SetVar,SetOpType,const IntSet&,SetRelType,SetVar);
+void rel(Home,SetVar,SetOpType,SetVar,SetRelType,const IntSet&);
+void rel(Home,SetVar,SetOpType,SetVar,SetRelType,SetVar);
+void rel(Home,SetVar,SetRelType,IntVar);
+void rel(Home,SetVar,SetRelType,IntVar,BoolVar);
+void rel(Home,SetVar,SetRelType,SetVar);
+void rel(Home,SetVar,SetRelType,SetVar,BoolVar);
+void sequence(Home,const BoolVarArgs&,const IntSet&,int,int,int,IntConLevel=ICL_DEF);
+void sequence(Home,const IntVarArgs&,const IntSet&,int,int,int,IntConLevel=ICL_DEF);
+void sequence(Home,const SetVarArgs&);
+void sequence(Home,const SetVarArgs&,SetVar);
+void sorted(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void sorted(Home,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void sqr(Home,IntVar,IntVar,IntConLevel=ICL_DEF);
+void sqrt(Home,IntVar,IntVar,IntConLevel=ICL_DEF);
+void unary(Home,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void unshare(Home,BoolVarArgs&,IntConLevel=ICL_DEF);
+void unshare(Home,IntVarArgs&,IntConLevel=ICL_DEF);
+void weights(Home,IntSharedArray,IntSharedArray,SetVar,IntVar);

packages/gecode/dev/gecode-prototypes-3.7.1.hh

@@ -0,0 +1,221 @@
+// This file was automatically extracted from Gecode source files.
+// It is subject to the same Copyright as the source files from which
+// it is derived, and is distributed under the same Licensing conditions.
+void abs(Home,IntVar,IntVar,IntConLevel=ICL_DEF);
+void assign(Home,BoolVar,IntAssign,const ValBranchOptions&=ValBranchOptions::def);
+void assign(Home,const BoolVarArgs&,IntAssign,const ValBranchOptions&=ValBranchOptions::def);
+void assign(Home,const IntVarArgs&,IntAssign,const ValBranchOptions&=ValBranchOptions::def);
+void assign(Home,const SetVarArgs&,SetAssign,const ValBranchOptions&=ValBranchOptions::def);
+void assign(Home,IntVar,IntAssign,const ValBranchOptions&=ValBranchOptions::def);
+void assign(Home,SetVar,SetAssign,const ValBranchOptions&=ValBranchOptions::def);
+void atmostOne(Home,const SetVarArgs&,unsigned int);
+void binpacking(Home,const IntVarArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void branch(Home,BoolVar,IntValBranch,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,const BoolVarArgs&,const TieBreakVarBranch<IntVarBranch>&,IntValBranch,const TieBreakVarBranchOptions&=TieBreakVarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,const BoolVarArgs&,IntVarBranch,IntValBranch,const VarBranchOptions&=VarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,const IntVarArgs&,const TieBreakVarBranch<IntVarBranch>&,IntValBranch,const TieBreakVarBranchOptions&=TieBreakVarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,const IntVarArgs&,IntVarBranch,IntValBranch,const VarBranchOptions&=VarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,const SetVarArgs&,const TieBreakVarBranch<SetVarBranch>&,SetValBranch,const TieBreakVarBranchOptions&=TieBreakVarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,const SetVarArgs&,SetVarBranch,SetValBranch,const VarBranchOptions&=VarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,IntVar,IntValBranch,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,SetVar,SetValBranch,const ValBranchOptions&=ValBranchOptions::def);
+void cardinality(Home,SetVar,IntVar);
+void cardinality(Home,SetVar,unsigned int,unsigned int);
+void channel(Home,BoolVar,IntVar,IntConLevel=ICL_DEF);
+void channel(Home,const BoolVarArgs&,IntVar,int=0,IntConLevel=ICL_DEF);
+void channel(Home,const BoolVarArgs&,SetVar);
+void channel(Home,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void channel(Home,const IntVarArgs&,const SetVarArgs&);
+void channel(Home,const IntVarArgs&,int,const IntVarArgs&,int,IntConLevel=ICL_DEF);
+void channel(Home,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void channelSorted(Home,const IntVarArgs&,SetVar);
+void circuit(Home,const IntArgs&,const IntVarArgs&,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void circuit(Home,const IntArgs&,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void circuit(Home,const IntArgs&,int,const IntVarArgs&,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void circuit(Home,const IntArgs&,int,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void circuit(Home,const IntVarArgs&,IntConLevel=ICL_DEF);
+void circuit(Home,int,const IntVarArgs&,IntConLevel=ICL_DEF);
+void clause(Home,BoolOpType,const BoolVarArgs&,const BoolVarArgs&,BoolVar,IntConLevel=ICL_DEF);
+void clause(Home,BoolOpType,const BoolVarArgs&,const BoolVarArgs&,int,IntConLevel=ICL_DEF);
+void convex(Home,SetVar);
+void convex(Home,SetVar,SetVar);
+void count(Home,const IntVarArgs&,const IntArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSetArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSetArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSet&,const IntArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSet&,IntRelType,int,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSet&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,int,IntRelType,int,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,int,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,IntVar,IntRelType,int,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,IntVar,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const IntVarArgs&,const IntArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const IntVarArgs&,const IntArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const IntVarArgs&,const IntArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const IntVarArgs&,const IntArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntArgs&,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntArgs&,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void distinct(Home,const IntArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void distinct(Home,const IntVarArgs&,IntConLevel=ICL_DEF);
+void div(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void divmod(Home,IntVar,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void dom(Home,const IntVarArgs&,const IntSet&,IntConLevel=ICL_DEF);
+void dom(Home,const IntVarArgs&,int,IntConLevel=ICL_DEF);
+void dom(Home,const IntVarArgs&,int,int,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,const IntSet&,BoolVar,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,const IntSet&,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,int,BoolVar,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,int,int,BoolVar,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,int,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,int,int,IntConLevel=ICL_DEF);
+void dom(Home,SetVar,SetRelType,const IntSet&);
+void dom(Home,SetVar,SetRelType,const IntSet&,BoolVar);
+void dom(Home,SetVar,SetRelType,int);
+void dom(Home,SetVar,SetRelType,int,BoolVar);
+void dom(Home,SetVar,SetRelType,int,int);
+void dom(Home,SetVar,SetRelType,int,int,BoolVar);
+void element(Home,const BoolVarArgs&,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void element(Home,const BoolVarArgs&,IntVar,int,IntConLevel=ICL_DEF);
+void element(Home,const BoolVarArgs&,IntVar,int,IntVar,int,BoolVar,IntConLevel=ICL_DEF);
+void element(Home,const IntSetArgs&,IntVar,int,IntVar,int,SetVar);
+void element(Home,const IntSetArgs&,IntVar,SetVar);
+void element(Home,const IntVarArgs&,IntVar,int,IntConLevel=ICL_DEF);
+void element(Home,const IntVarArgs&,IntVar,int,IntVar,int,IntVar,IntConLevel=ICL_DEF);
+void element(Home,const IntVarArgs&,IntVar,IntVar,IntConLevel=ICL_DEF);
+void element(Home,const SetVarArgs&,IntVar,int,IntVar,int,SetVar);
+void element(Home,const SetVarArgs&,IntVar,SetVar);
+void element(Home,IntSharedArray,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void element(Home,IntSharedArray,IntVar,int,IntConLevel=ICL_DEF);
+void element(Home,IntSharedArray,IntVar,int,IntVar,int,BoolVar,IntConLevel=ICL_DEF);
+void element(Home,IntSharedArray,IntVar,int,IntVar,int,IntVar,IntConLevel=ICL_DEF);
+void element(Home,IntSharedArray,IntVar,IntVar,IntConLevel=ICL_DEF);
+void element(Home,SetOpType,const IntArgs&,SetVar,SetVar,const IntSet&=IntSet(Set::Limits::min,Set::Limits::max));
+void element(Home,SetOpType,const IntSetArgs&,SetVar,SetVar,const IntSet&=IntSet(Set::Limits::min,Set::Limits::max));
+void element(Home,SetOpType,const IntVarArgs&,SetVar,SetVar,const IntSet&=IntSet(Set::Limits::min,Set::Limits::max));
+void element(Home,SetOpType,const SetVarArgs&,SetVar,SetVar,const IntSet&=IntSet(Set::Limits::min,Set::Limits::max));
+void extensional(Home,const BoolVarArgs&,const TupleSet&,ExtensionalPropKind=EPK_DEF,IntConLevel=ICL_DEF);
+void extensional(Home,const BoolVarArgs&,DFA,IntConLevel=ICL_DEF);
+void extensional(Home,const IntVarArgs&,const TupleSet&,ExtensionalPropKind=EPK_DEF,IntConLevel=ICL_DEF);
+void extensional(Home,const IntVarArgs&,DFA,IntConLevel=ICL_DEF);
+void linear(Home,const BoolVarArgs&,IntRelType,int,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const BoolVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void linear(Home,const BoolVarArgs&,IntRelType,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const BoolVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const BoolVarArgs&,IntRelType,int,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const BoolVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const BoolVarArgs&,IntRelType,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const BoolVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const IntVarArgs&,IntRelType,int,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const IntVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const IntVarArgs&,IntRelType,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const IntVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntVarArgs&,IntRelType,int,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void linear(Home,const IntVarArgs&,IntRelType,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void max(Home,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void max(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void max(Home,SetVar,IntVar);
+void max(Home,SetVar,IntVar,BoolVar);
+void member(Home,const BoolVarArgs&,BoolVar,BoolVar,IntConLevel=ICL_DEF);
+void member(Home,const BoolVarArgs&,BoolVar,IntConLevel=ICL_DEF);
+void member(Home,const IntVarArgs&,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void member(Home,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void min(Home,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void min(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void min(Home,SetVar,IntVar);
+void min(Home,SetVar,IntVar,BoolVar);
+void mod(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void mult(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void nooverlap(Home,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void nooverlap(Home,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void nooverlap(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void nooverlap(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void notMax(Home,SetVar,IntVar);
+void notMin(Home,SetVar,IntVar);
+void nvalues(Home,const BoolVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void nvalues(Home,const BoolVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void nvalues(Home,const IntVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void nvalues(Home,const IntVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntArgs&,const IntVarArgs&,IntVar,IntVar,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntArgs&,const IntVarArgs&,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntArgs&,int,const IntVarArgs&,IntVar,IntVar,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntArgs&,int,const IntVarArgs&,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntVarArgs&,IntVar,IntVar,IntConLevel=ICL_DEF);
+void path(Home,int,const IntVarArgs&,IntVar,IntVar,IntConLevel=ICL_DEF);
+void precede(Home,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void precede(Home,const IntVarArgs&,int,int,IntConLevel=ICL_DEF);
+void precede(Home,const SetVarArgs&,const IntArgs&);
+void precede(Home,const SetVarArgs&,int,int);
+void rel(Home,BoolOpType,const BoolVarArgs&,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,BoolOpType,const BoolVarArgs&,int,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,BoolOpType,BoolVar,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,BoolOpType,BoolVar,int,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,IntRelType,BoolVar,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,IntRelType,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,IntRelType,int,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,IntRelType,int,IntConLevel=ICL_DEF);
+void rel(Home,const BoolVarArgs&,IntRelType,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,const BoolVarArgs&,IntRelType,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void rel(Home,const BoolVarArgs&,IntRelType,IntConLevel=ICL_DEF);
+void rel(Home,const BoolVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void rel(Home,const IntSet&,SetOpType,SetVar,SetRelType,const IntSet&);
+void rel(Home,const IntSet&,SetOpType,SetVar,SetRelType,SetVar);
+void rel(Home,const IntVarArgs&,IntRelType,const IntVarArgs&,IntConLevel=ICL_DEF);
+void rel(Home,const IntVarArgs&,IntRelType,IntConLevel=ICL_DEF);
+void rel(Home,const IntVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void rel(Home,const IntVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,int,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,int,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,SetVar);
+void rel(Home,IntVar,SetRelType,SetVar);
+void rel(Home,IntVar,SetRelType,SetVar,BoolVar);
+void rel(Home,SetOpType,const IntVarArgs&,const IntSet&,SetVar);
+void rel(Home,SetOpType,const IntVarArgs&,SetVar);
+void rel(Home,SetOpType,const SetVarArgs&,const IntSet&,SetVar);
+void rel(Home,SetOpType,const SetVarArgs&,SetVar);
+void rel(Home,SetVar,IntRelType,IntVar);
+void rel(Home,SetVar,SetOpType,const IntSet&,SetRelType,const IntSet&);
+void rel(Home,SetVar,SetOpType,const IntSet&,SetRelType,SetVar);
+void rel(Home,SetVar,SetOpType,SetVar,SetRelType,const IntSet&);
+void rel(Home,SetVar,SetOpType,SetVar,SetRelType,SetVar);
+void rel(Home,SetVar,SetRelType,IntVar);
+void rel(Home,SetVar,SetRelType,IntVar,BoolVar);
+void rel(Home,SetVar,SetRelType,SetVar);
+void rel(Home,SetVar,SetRelType,SetVar,BoolVar);
+void sequence(Home,const BoolVarArgs&,const IntSet&,int,int,int,IntConLevel=ICL_DEF);
+void sequence(Home,const IntVarArgs&,const IntSet&,int,int,int,IntConLevel=ICL_DEF);
+void sequence(Home,const SetVarArgs&);
+void sequence(Home,const SetVarArgs&,SetVar);
+void sorted(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void sorted(Home,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void sqr(Home,IntVar,IntVar,IntConLevel=ICL_DEF);
+void sqrt(Home,IntVar,IntVar,IntConLevel=ICL_DEF);
+void unary(Home,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void unshare(Home,BoolVarArgs&,IntConLevel=ICL_DEF);
+void unshare(Home,IntVarArgs&,IntConLevel=ICL_DEF);
+void weights(Home,IntSharedArray,IntSharedArray,SetVar,IntVar);

packages/gecode/dev/gecode-prototypes-3.7.2.hh

@@ -0,0 +1,221 @@
+// This file was automatically extracted from Gecode source files.
+// It is subject to the same Copyright as the source files from which
+// it is derived, and is distributed under the same Licensing conditions.
+void abs(Home,IntVar,IntVar,IntConLevel=ICL_DEF);
+void assign(Home,BoolVar,IntAssign,const ValBranchOptions&=ValBranchOptions::def);
+void assign(Home,const BoolVarArgs&,IntAssign,const ValBranchOptions&=ValBranchOptions::def);
+void assign(Home,const IntVarArgs&,IntAssign,const ValBranchOptions&=ValBranchOptions::def);
+void assign(Home,const SetVarArgs&,SetAssign,const ValBranchOptions&=ValBranchOptions::def);
+void assign(Home,IntVar,IntAssign,const ValBranchOptions&=ValBranchOptions::def);
+void assign(Home,SetVar,SetAssign,const ValBranchOptions&=ValBranchOptions::def);
+void atmostOne(Home,const SetVarArgs&,unsigned int);
+void binpacking(Home,const IntVarArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void branch(Home,BoolVar,IntValBranch,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,const BoolVarArgs&,const TieBreakVarBranch<IntVarBranch>&,IntValBranch,const TieBreakVarBranchOptions&=TieBreakVarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,const BoolVarArgs&,IntVarBranch,IntValBranch,const VarBranchOptions&=VarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,const IntVarArgs&,const TieBreakVarBranch<IntVarBranch>&,IntValBranch,const TieBreakVarBranchOptions&=TieBreakVarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,const IntVarArgs&,IntVarBranch,IntValBranch,const VarBranchOptions&=VarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,const SetVarArgs&,const TieBreakVarBranch<SetVarBranch>&,SetValBranch,const TieBreakVarBranchOptions&=TieBreakVarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,const SetVarArgs&,SetVarBranch,SetValBranch,const VarBranchOptions&=VarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,IntVar,IntValBranch,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,SetVar,SetValBranch,const ValBranchOptions&=ValBranchOptions::def);
+void cardinality(Home,SetVar,IntVar);
+void cardinality(Home,SetVar,unsigned int,unsigned int);
+void channel(Home,BoolVar,IntVar,IntConLevel=ICL_DEF);
+void channel(Home,const BoolVarArgs&,IntVar,int=0,IntConLevel=ICL_DEF);
+void channel(Home,const BoolVarArgs&,SetVar);
+void channel(Home,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void channel(Home,const IntVarArgs&,const SetVarArgs&);
+void channel(Home,const IntVarArgs&,int,const IntVarArgs&,int,IntConLevel=ICL_DEF);
+void channel(Home,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void channelSorted(Home,const IntVarArgs&,SetVar);
+void circuit(Home,const IntArgs&,const IntVarArgs&,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void circuit(Home,const IntArgs&,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void circuit(Home,const IntArgs&,int,const IntVarArgs&,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void circuit(Home,const IntArgs&,int,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void circuit(Home,const IntVarArgs&,IntConLevel=ICL_DEF);
+void circuit(Home,int,const IntVarArgs&,IntConLevel=ICL_DEF);
+void clause(Home,BoolOpType,const BoolVarArgs&,const BoolVarArgs&,BoolVar,IntConLevel=ICL_DEF);
+void clause(Home,BoolOpType,const BoolVarArgs&,const BoolVarArgs&,int,IntConLevel=ICL_DEF);
+void convex(Home,SetVar);
+void convex(Home,SetVar,SetVar);
+void count(Home,const IntVarArgs&,const IntArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSetArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSetArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSet&,const IntArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSet&,IntRelType,int,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSet&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,int,IntRelType,int,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,int,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,IntVar,IntRelType,int,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,IntVar,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const IntVarArgs&,const IntArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const IntVarArgs&,const IntArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const IntVarArgs&,const IntArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const IntVarArgs&,const IntArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntArgs&,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntArgs&,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void distinct(Home,const IntArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void distinct(Home,const IntVarArgs&,IntConLevel=ICL_DEF);
+void div(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void divmod(Home,IntVar,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void dom(Home,const IntVarArgs&,const IntSet&,IntConLevel=ICL_DEF);
+void dom(Home,const IntVarArgs&,int,IntConLevel=ICL_DEF);
+void dom(Home,const IntVarArgs&,int,int,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,const IntSet&,BoolVar,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,const IntSet&,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,int,BoolVar,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,int,int,BoolVar,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,int,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,int,int,IntConLevel=ICL_DEF);
+void dom(Home,SetVar,SetRelType,const IntSet&);
+void dom(Home,SetVar,SetRelType,const IntSet&,BoolVar);
+void dom(Home,SetVar,SetRelType,int);
+void dom(Home,SetVar,SetRelType,int,BoolVar);
+void dom(Home,SetVar,SetRelType,int,int);
+void dom(Home,SetVar,SetRelType,int,int,BoolVar);
+void element(Home,const BoolVarArgs&,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void element(Home,const BoolVarArgs&,IntVar,int,IntConLevel=ICL_DEF);
+void element(Home,const BoolVarArgs&,IntVar,int,IntVar,int,BoolVar,IntConLevel=ICL_DEF);
+void element(Home,const IntSetArgs&,IntVar,int,IntVar,int,SetVar);
+void element(Home,const IntSetArgs&,IntVar,SetVar);
+void element(Home,const IntVarArgs&,IntVar,int,IntConLevel=ICL_DEF);
+void element(Home,const IntVarArgs&,IntVar,int,IntVar,int,IntVar,IntConLevel=ICL_DEF);
+void element(Home,const IntVarArgs&,IntVar,IntVar,IntConLevel=ICL_DEF);
+void element(Home,const SetVarArgs&,IntVar,int,IntVar,int,SetVar);
+void element(Home,const SetVarArgs&,IntVar,SetVar);
+void element(Home,IntSharedArray,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void element(Home,IntSharedArray,IntVar,int,IntConLevel=ICL_DEF);
+void element(Home,IntSharedArray,IntVar,int,IntVar,int,BoolVar,IntConLevel=ICL_DEF);
+void element(Home,IntSharedArray,IntVar,int,IntVar,int,IntVar,IntConLevel=ICL_DEF);
+void element(Home,IntSharedArray,IntVar,IntVar,IntConLevel=ICL_DEF);
+void element(Home,SetOpType,const IntArgs&,SetVar,SetVar,const IntSet&=IntSet(Set::Limits::min,Set::Limits::max));
+void element(Home,SetOpType,const IntSetArgs&,SetVar,SetVar,const IntSet&=IntSet(Set::Limits::min,Set::Limits::max));
+void element(Home,SetOpType,const IntVarArgs&,SetVar,SetVar,const IntSet&=IntSet(Set::Limits::min,Set::Limits::max));
+void element(Home,SetOpType,const SetVarArgs&,SetVar,SetVar,const IntSet&=IntSet(Set::Limits::min,Set::Limits::max));
+void extensional(Home,const BoolVarArgs&,const TupleSet&,ExtensionalPropKind=EPK_DEF,IntConLevel=ICL_DEF);
+void extensional(Home,const BoolVarArgs&,DFA,IntConLevel=ICL_DEF);
+void extensional(Home,const IntVarArgs&,const TupleSet&,ExtensionalPropKind=EPK_DEF,IntConLevel=ICL_DEF);
+void extensional(Home,const IntVarArgs&,DFA,IntConLevel=ICL_DEF);
+void linear(Home,const BoolVarArgs&,IntRelType,int,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const BoolVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void linear(Home,const BoolVarArgs&,IntRelType,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const BoolVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const BoolVarArgs&,IntRelType,int,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const BoolVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const BoolVarArgs&,IntRelType,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const BoolVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const IntVarArgs&,IntRelType,int,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const IntVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const IntVarArgs&,IntRelType,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const IntVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntVarArgs&,IntRelType,int,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void linear(Home,const IntVarArgs&,IntRelType,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void max(Home,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void max(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void max(Home,SetVar,IntVar);
+void max(Home,SetVar,IntVar,BoolVar);
+void member(Home,const BoolVarArgs&,BoolVar,BoolVar,IntConLevel=ICL_DEF);
+void member(Home,const BoolVarArgs&,BoolVar,IntConLevel=ICL_DEF);
+void member(Home,const IntVarArgs&,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void member(Home,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void min(Home,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void min(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void min(Home,SetVar,IntVar);
+void min(Home,SetVar,IntVar,BoolVar);
+void mod(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void mult(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void nooverlap(Home,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void nooverlap(Home,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void nooverlap(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void nooverlap(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void notMax(Home,SetVar,IntVar);
+void notMin(Home,SetVar,IntVar);
+void nvalues(Home,const BoolVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void nvalues(Home,const BoolVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void nvalues(Home,const IntVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void nvalues(Home,const IntVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntArgs&,const IntVarArgs&,IntVar,IntVar,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntArgs&,const IntVarArgs&,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntArgs&,int,const IntVarArgs&,IntVar,IntVar,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntArgs&,int,const IntVarArgs&,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntVarArgs&,IntVar,IntVar,IntConLevel=ICL_DEF);
+void path(Home,int,const IntVarArgs&,IntVar,IntVar,IntConLevel=ICL_DEF);
+void precede(Home,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void precede(Home,const IntVarArgs&,int,int,IntConLevel=ICL_DEF);
+void precede(Home,const SetVarArgs&,const IntArgs&);
+void precede(Home,const SetVarArgs&,int,int);
+void rel(Home,BoolOpType,const BoolVarArgs&,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,BoolOpType,const BoolVarArgs&,int,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,BoolOpType,BoolVar,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,BoolOpType,BoolVar,int,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,IntRelType,BoolVar,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,IntRelType,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,IntRelType,int,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,IntRelType,int,IntConLevel=ICL_DEF);
+void rel(Home,const BoolVarArgs&,IntRelType,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,const BoolVarArgs&,IntRelType,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void rel(Home,const BoolVarArgs&,IntRelType,IntConLevel=ICL_DEF);
+void rel(Home,const BoolVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void rel(Home,const IntSet&,SetOpType,SetVar,SetRelType,const IntSet&);
+void rel(Home,const IntSet&,SetOpType,SetVar,SetRelType,SetVar);
+void rel(Home,const IntVarArgs&,IntRelType,const IntVarArgs&,IntConLevel=ICL_DEF);
+void rel(Home,const IntVarArgs&,IntRelType,IntConLevel=ICL_DEF);
+void rel(Home,const IntVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void rel(Home,const IntVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,int,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,int,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,SetVar);
+void rel(Home,IntVar,SetRelType,SetVar);
+void rel(Home,IntVar,SetRelType,SetVar,BoolVar);
+void rel(Home,SetOpType,const IntVarArgs&,const IntSet&,SetVar);
+void rel(Home,SetOpType,const IntVarArgs&,SetVar);
+void rel(Home,SetOpType,const SetVarArgs&,const IntSet&,SetVar);
+void rel(Home,SetOpType,const SetVarArgs&,SetVar);
+void rel(Home,SetVar,IntRelType,IntVar);
+void rel(Home,SetVar,SetOpType,const IntSet&,SetRelType,const IntSet&);
+void rel(Home,SetVar,SetOpType,const IntSet&,SetRelType,SetVar);
+void rel(Home,SetVar,SetOpType,SetVar,SetRelType,const IntSet&);
+void rel(Home,SetVar,SetOpType,SetVar,SetRelType,SetVar);
+void rel(Home,SetVar,SetRelType,IntVar);
+void rel(Home,SetVar,SetRelType,IntVar,BoolVar);
+void rel(Home,SetVar,SetRelType,SetVar);
+void rel(Home,SetVar,SetRelType,SetVar,BoolVar);
+void sequence(Home,const BoolVarArgs&,const IntSet&,int,int,int,IntConLevel=ICL_DEF);
+void sequence(Home,const IntVarArgs&,const IntSet&,int,int,int,IntConLevel=ICL_DEF);
+void sequence(Home,const SetVarArgs&);
+void sequence(Home,const SetVarArgs&,SetVar);
+void sorted(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void sorted(Home,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void sqr(Home,IntVar,IntVar,IntConLevel=ICL_DEF);
+void sqrt(Home,IntVar,IntVar,IntConLevel=ICL_DEF);
+void unary(Home,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void unshare(Home,BoolVarArgs&,IntConLevel=ICL_DEF);
+void unshare(Home,IntVarArgs&,IntConLevel=ICL_DEF);
+void weights(Home,IntSharedArray,IntSharedArray,SetVar,IntVar);

packages/gecode/dev/gecode-prototypes-3.7.3.hh

@@ -0,0 +1,221 @@
+// This file was automatically extracted from Gecode source files.
+// It is subject to the same Copyright as the source files from which
+// it is derived, and is distributed under the same Licensing conditions.
+void abs(Home,IntVar,IntVar,IntConLevel=ICL_DEF);
+void assign(Home,BoolVar,IntAssign,const ValBranchOptions&=ValBranchOptions::def);
+void assign(Home,const BoolVarArgs&,IntAssign,const ValBranchOptions&=ValBranchOptions::def);
+void assign(Home,const IntVarArgs&,IntAssign,const ValBranchOptions&=ValBranchOptions::def);
+void assign(Home,const SetVarArgs&,SetAssign,const ValBranchOptions&=ValBranchOptions::def);
+void assign(Home,IntVar,IntAssign,const ValBranchOptions&=ValBranchOptions::def);
+void assign(Home,SetVar,SetAssign,const ValBranchOptions&=ValBranchOptions::def);
+void atmostOne(Home,const SetVarArgs&,unsigned int);
+void binpacking(Home,const IntVarArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void branch(Home,BoolVar,IntValBranch,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,const BoolVarArgs&,const TieBreakVarBranch<IntVarBranch>&,IntValBranch,const TieBreakVarBranchOptions&=TieBreakVarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,const BoolVarArgs&,IntVarBranch,IntValBranch,const VarBranchOptions&=VarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,const IntVarArgs&,const TieBreakVarBranch<IntVarBranch>&,IntValBranch,const TieBreakVarBranchOptions&=TieBreakVarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,const IntVarArgs&,IntVarBranch,IntValBranch,const VarBranchOptions&=VarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,const SetVarArgs&,const TieBreakVarBranch<SetVarBranch>&,SetValBranch,const TieBreakVarBranchOptions&=TieBreakVarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,const SetVarArgs&,SetVarBranch,SetValBranch,const VarBranchOptions&=VarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,IntVar,IntValBranch,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,SetVar,SetValBranch,const ValBranchOptions&=ValBranchOptions::def);
+void cardinality(Home,SetVar,IntVar);
+void cardinality(Home,SetVar,unsigned int,unsigned int);
+void channel(Home,BoolVar,IntVar,IntConLevel=ICL_DEF);
+void channel(Home,const BoolVarArgs&,IntVar,int=0,IntConLevel=ICL_DEF);
+void channel(Home,const BoolVarArgs&,SetVar);
+void channel(Home,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void channel(Home,const IntVarArgs&,const SetVarArgs&);
+void channel(Home,const IntVarArgs&,int,const IntVarArgs&,int,IntConLevel=ICL_DEF);
+void channel(Home,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void channelSorted(Home,const IntVarArgs&,SetVar);
+void circuit(Home,const IntArgs&,const IntVarArgs&,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void circuit(Home,const IntArgs&,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void circuit(Home,const IntArgs&,int,const IntVarArgs&,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void circuit(Home,const IntArgs&,int,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void circuit(Home,const IntVarArgs&,IntConLevel=ICL_DEF);
+void circuit(Home,int,const IntVarArgs&,IntConLevel=ICL_DEF);
+void clause(Home,BoolOpType,const BoolVarArgs&,const BoolVarArgs&,BoolVar,IntConLevel=ICL_DEF);
+void clause(Home,BoolOpType,const BoolVarArgs&,const BoolVarArgs&,int,IntConLevel=ICL_DEF);
+void convex(Home,SetVar);
+void convex(Home,SetVar,SetVar);
+void count(Home,const IntVarArgs&,const IntArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSetArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSetArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSet&,const IntArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSet&,IntRelType,int,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSet&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,int,IntRelType,int,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,int,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,IntVar,IntRelType,int,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,IntVar,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const IntVarArgs&,const IntArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const IntVarArgs&,const IntArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const IntVarArgs&,const IntArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const IntVarArgs&,const IntArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntArgs&,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntArgs&,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void distinct(Home,const IntArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void distinct(Home,const IntVarArgs&,IntConLevel=ICL_DEF);
+void div(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void divmod(Home,IntVar,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void dom(Home,const IntVarArgs&,const IntSet&,IntConLevel=ICL_DEF);
+void dom(Home,const IntVarArgs&,int,IntConLevel=ICL_DEF);
+void dom(Home,const IntVarArgs&,int,int,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,const IntSet&,BoolVar,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,const IntSet&,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,int,BoolVar,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,int,int,BoolVar,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,int,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,int,int,IntConLevel=ICL_DEF);
+void dom(Home,SetVar,SetRelType,const IntSet&);
+void dom(Home,SetVar,SetRelType,const IntSet&,BoolVar);
+void dom(Home,SetVar,SetRelType,int);
+void dom(Home,SetVar,SetRelType,int,BoolVar);
+void dom(Home,SetVar,SetRelType,int,int);
+void dom(Home,SetVar,SetRelType,int,int,BoolVar);
+void element(Home,const BoolVarArgs&,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void element(Home,const BoolVarArgs&,IntVar,int,IntConLevel=ICL_DEF);
+void element(Home,const BoolVarArgs&,IntVar,int,IntVar,int,BoolVar,IntConLevel=ICL_DEF);
+void element(Home,const IntSetArgs&,IntVar,int,IntVar,int,SetVar);
+void element(Home,const IntSetArgs&,IntVar,SetVar);
+void element(Home,const IntVarArgs&,IntVar,int,IntConLevel=ICL_DEF);
+void element(Home,const IntVarArgs&,IntVar,int,IntVar,int,IntVar,IntConLevel=ICL_DEF);
+void element(Home,const IntVarArgs&,IntVar,IntVar,IntConLevel=ICL_DEF);
+void element(Home,const SetVarArgs&,IntVar,int,IntVar,int,SetVar);
+void element(Home,const SetVarArgs&,IntVar,SetVar);
+void element(Home,IntSharedArray,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void element(Home,IntSharedArray,IntVar,int,IntConLevel=ICL_DEF);
+void element(Home,IntSharedArray,IntVar,int,IntVar,int,BoolVar,IntConLevel=ICL_DEF);
+void element(Home,IntSharedArray,IntVar,int,IntVar,int,IntVar,IntConLevel=ICL_DEF);
+void element(Home,IntSharedArray,IntVar,IntVar,IntConLevel=ICL_DEF);
+void element(Home,SetOpType,const IntArgs&,SetVar,SetVar,const IntSet&=IntSet(Set::Limits::min,Set::Limits::max));
+void element(Home,SetOpType,const IntSetArgs&,SetVar,SetVar,const IntSet&=IntSet(Set::Limits::min,Set::Limits::max));
+void element(Home,SetOpType,const IntVarArgs&,SetVar,SetVar,const IntSet&=IntSet(Set::Limits::min,Set::Limits::max));
+void element(Home,SetOpType,const SetVarArgs&,SetVar,SetVar,const IntSet&=IntSet(Set::Limits::min,Set::Limits::max));
+void extensional(Home,const BoolVarArgs&,const TupleSet&,ExtensionalPropKind=EPK_DEF,IntConLevel=ICL_DEF);
+void extensional(Home,const BoolVarArgs&,DFA,IntConLevel=ICL_DEF);
+void extensional(Home,const IntVarArgs&,const TupleSet&,ExtensionalPropKind=EPK_DEF,IntConLevel=ICL_DEF);
+void extensional(Home,const IntVarArgs&,DFA,IntConLevel=ICL_DEF);
+void linear(Home,const BoolVarArgs&,IntRelType,int,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const BoolVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void linear(Home,const BoolVarArgs&,IntRelType,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const BoolVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const BoolVarArgs&,IntRelType,int,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const BoolVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const BoolVarArgs&,IntRelType,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const BoolVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const IntVarArgs&,IntRelType,int,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const IntVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const IntVarArgs&,IntRelType,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const IntVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntVarArgs&,IntRelType,int,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void linear(Home,const IntVarArgs&,IntRelType,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void max(Home,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void max(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void max(Home,SetVar,IntVar);
+void max(Home,SetVar,IntVar,BoolVar);
+void member(Home,const BoolVarArgs&,BoolVar,BoolVar,IntConLevel=ICL_DEF);
+void member(Home,const BoolVarArgs&,BoolVar,IntConLevel=ICL_DEF);
+void member(Home,const IntVarArgs&,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void member(Home,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void min(Home,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void min(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void min(Home,SetVar,IntVar);
+void min(Home,SetVar,IntVar,BoolVar);
+void mod(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void mult(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void nooverlap(Home,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void nooverlap(Home,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void nooverlap(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void nooverlap(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void notMax(Home,SetVar,IntVar);
+void notMin(Home,SetVar,IntVar);
+void nvalues(Home,const BoolVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void nvalues(Home,const BoolVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void nvalues(Home,const IntVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void nvalues(Home,const IntVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntArgs&,const IntVarArgs&,IntVar,IntVar,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntArgs&,const IntVarArgs&,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntArgs&,int,const IntVarArgs&,IntVar,IntVar,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntArgs&,int,const IntVarArgs&,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntVarArgs&,IntVar,IntVar,IntConLevel=ICL_DEF);
+void path(Home,int,const IntVarArgs&,IntVar,IntVar,IntConLevel=ICL_DEF);
+void precede(Home,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void precede(Home,const IntVarArgs&,int,int,IntConLevel=ICL_DEF);
+void precede(Home,const SetVarArgs&,const IntArgs&);
+void precede(Home,const SetVarArgs&,int,int);
+void rel(Home,BoolOpType,const BoolVarArgs&,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,BoolOpType,const BoolVarArgs&,int,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,BoolOpType,BoolVar,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,BoolOpType,BoolVar,int,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,IntRelType,BoolVar,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,IntRelType,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,IntRelType,int,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,IntRelType,int,IntConLevel=ICL_DEF);
+void rel(Home,const BoolVarArgs&,IntRelType,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,const BoolVarArgs&,IntRelType,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void rel(Home,const BoolVarArgs&,IntRelType,IntConLevel=ICL_DEF);
+void rel(Home,const BoolVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void rel(Home,const IntSet&,SetOpType,SetVar,SetRelType,const IntSet&);
+void rel(Home,const IntSet&,SetOpType,SetVar,SetRelType,SetVar);
+void rel(Home,const IntVarArgs&,IntRelType,const IntVarArgs&,IntConLevel=ICL_DEF);
+void rel(Home,const IntVarArgs&,IntRelType,IntConLevel=ICL_DEF);
+void rel(Home,const IntVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void rel(Home,const IntVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,int,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,int,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,SetVar);
+void rel(Home,IntVar,SetRelType,SetVar);
+void rel(Home,IntVar,SetRelType,SetVar,BoolVar);
+void rel(Home,SetOpType,const IntVarArgs&,const IntSet&,SetVar);
+void rel(Home,SetOpType,const IntVarArgs&,SetVar);
+void rel(Home,SetOpType,const SetVarArgs&,const IntSet&,SetVar);
+void rel(Home,SetOpType,const SetVarArgs&,SetVar);
+void rel(Home,SetVar,IntRelType,IntVar);
+void rel(Home,SetVar,SetOpType,const IntSet&,SetRelType,const IntSet&);
+void rel(Home,SetVar,SetOpType,const IntSet&,SetRelType,SetVar);
+void rel(Home,SetVar,SetOpType,SetVar,SetRelType,const IntSet&);
+void rel(Home,SetVar,SetOpType,SetVar,SetRelType,SetVar);
+void rel(Home,SetVar,SetRelType,IntVar);
+void rel(Home,SetVar,SetRelType,IntVar,BoolVar);
+void rel(Home,SetVar,SetRelType,SetVar);
+void rel(Home,SetVar,SetRelType,SetVar,BoolVar);
+void sequence(Home,const BoolVarArgs&,const IntSet&,int,int,int,IntConLevel=ICL_DEF);
+void sequence(Home,const IntVarArgs&,const IntSet&,int,int,int,IntConLevel=ICL_DEF);
+void sequence(Home,const SetVarArgs&);
+void sequence(Home,const SetVarArgs&,SetVar);
+void sorted(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void sorted(Home,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void sqr(Home,IntVar,IntVar,IntConLevel=ICL_DEF);
+void sqrt(Home,IntVar,IntVar,IntConLevel=ICL_DEF);
+void unary(Home,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void unshare(Home,BoolVarArgs&,IntConLevel=ICL_DEF);
+void unshare(Home,IntVarArgs&,IntConLevel=ICL_DEF);
+void weights(Home,IntSharedArray,IntSharedArray,SetVar,IntVar);

packages/gecode/dev/gecode-prototypes-4.0.0.hh

@@ -0,0 +1,222 @@
+// This file was automatically extracted from Gecode source files.
+// It is subject to the same Copyright as the source files from which
+// it is derived, and is distributed under the same Licensing conditions.
+void abs(Home,IntVar,IntVar,IntConLevel=ICL_DEF);
+void assign(Home,BoolVar,IntAssign,const ValBranchOptions&=ValBranchOptions::def);
+void assign(Home,const BoolVarArgs&,IntAssign,const ValBranchOptions&=ValBranchOptions::def);
+void assign(Home,const IntVarArgs&,IntAssign,const ValBranchOptions&=ValBranchOptions::def);
+void assign(Home,const SetVarArgs&,SetAssign,const ValBranchOptions&=ValBranchOptions::def);
+void assign(Home,IntVar,IntAssign,const ValBranchOptions&=ValBranchOptions::def);
+void assign(Home,SetVar,SetAssign,const ValBranchOptions&=ValBranchOptions::def);
+void atmostOne(Home,const SetVarArgs&,unsigned int);
+void binpacking(Home,const IntVarArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void branch(Home,BoolVar,IntValBranch,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,const BoolVarArgs&,const TieBreakVarBranch<IntVarBranch>&,IntValBranch,const TieBreakVarBranchOptions&=TieBreakVarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,const BoolVarArgs&,IntVarBranch,IntValBranch,const VarBranchOptions&=VarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,const IntVarArgs&,const TieBreakVarBranch<IntVarBranch>&,IntValBranch,const TieBreakVarBranchOptions&=TieBreakVarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,const IntVarArgs&,IntVarBranch,IntValBranch,const VarBranchOptions&=VarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,const SetVarArgs&,const TieBreakVarBranch<SetVarBranch>&,SetValBranch,const TieBreakVarBranchOptions&=TieBreakVarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,const SetVarArgs&,SetVarBranch,SetValBranch,const VarBranchOptions&=VarBranchOptions::def,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,IntVar,IntValBranch,const ValBranchOptions&=ValBranchOptions::def);
+void branch(Home,SetVar,SetValBranch,const ValBranchOptions&=ValBranchOptions::def);
+void cardinality(Home,SetVar,IntVar);
+void cardinality(Home,SetVar,unsigned int,unsigned int);
+void channel(Home,BoolVar,IntVar,IntConLevel=ICL_DEF);
+void channel(Home,const BoolVarArgs&,IntVar,int=0,IntConLevel=ICL_DEF);
+void channel(Home,const BoolVarArgs&,SetVar);
+void channel(Home,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void channel(Home,const IntVarArgs&,const SetVarArgs&);
+void channel(Home,const IntVarArgs&,int,const IntVarArgs&,int,IntConLevel=ICL_DEF);
+void channel(Home,const SetVarArgs&,const SetVarArgs&);
+void channel(Home,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void channelSorted(Home,const IntVarArgs&,SetVar);
+void circuit(Home,const IntArgs&,const IntVarArgs&,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void circuit(Home,const IntArgs&,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void circuit(Home,const IntArgs&,int,const IntVarArgs&,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void circuit(Home,const IntArgs&,int,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void circuit(Home,const IntVarArgs&,IntConLevel=ICL_DEF);
+void circuit(Home,int,const IntVarArgs&,IntConLevel=ICL_DEF);
+void clause(Home,BoolOpType,const BoolVarArgs&,const BoolVarArgs&,BoolVar,IntConLevel=ICL_DEF);
+void clause(Home,BoolOpType,const BoolVarArgs&,const BoolVarArgs&,int,IntConLevel=ICL_DEF);
+void convex(Home,SetVar);
+void convex(Home,SetVar,SetVar);
+void count(Home,const IntVarArgs&,const IntArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSetArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSetArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSet&,const IntArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSet&,IntRelType,int,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSet&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,int,IntRelType,int,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,int,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,IntVar,IntRelType,int,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,IntVar,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const IntVarArgs&,const IntArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const IntVarArgs&,const IntArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const IntVarArgs&,const IntArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const IntVarArgs&,const IntArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntArgs&,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntArgs&,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void distinct(Home,const IntArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void distinct(Home,const IntVarArgs&,IntConLevel=ICL_DEF);
+void div(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void divmod(Home,IntVar,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void dom(Home,const IntVarArgs&,const IntSet&,IntConLevel=ICL_DEF);
+void dom(Home,const IntVarArgs&,int,IntConLevel=ICL_DEF);
+void dom(Home,const IntVarArgs&,int,int,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,const IntSet&,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,const IntSet&,Reify,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,int,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,int,int,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,int,int,Reify,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,int,Reify,IntConLevel=ICL_DEF);
+void dom(Home,SetVar,SetRelType,const IntSet&);
+void dom(Home,SetVar,SetRelType,const IntSet&,BoolVar);
+void dom(Home,SetVar,SetRelType,int);
+void dom(Home,SetVar,SetRelType,int,BoolVar);
+void dom(Home,SetVar,SetRelType,int,int);
+void dom(Home,SetVar,SetRelType,int,int,BoolVar);
+void element(Home,const BoolVarArgs&,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void element(Home,const BoolVarArgs&,IntVar,int,IntConLevel=ICL_DEF);
+void element(Home,const BoolVarArgs&,IntVar,int,IntVar,int,BoolVar,IntConLevel=ICL_DEF);
+void element(Home,const IntSetArgs&,IntVar,int,IntVar,int,SetVar);
+void element(Home,const IntSetArgs&,IntVar,SetVar);
+void element(Home,const IntVarArgs&,IntVar,int,IntConLevel=ICL_DEF);
+void element(Home,const IntVarArgs&,IntVar,int,IntVar,int,IntVar,IntConLevel=ICL_DEF);
+void element(Home,const IntVarArgs&,IntVar,IntVar,IntConLevel=ICL_DEF);
+void element(Home,const SetVarArgs&,IntVar,int,IntVar,int,SetVar);
+void element(Home,const SetVarArgs&,IntVar,SetVar);
+void element(Home,IntSharedArray,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void element(Home,IntSharedArray,IntVar,int,IntConLevel=ICL_DEF);
+void element(Home,IntSharedArray,IntVar,int,IntVar,int,BoolVar,IntConLevel=ICL_DEF);
+void element(Home,IntSharedArray,IntVar,int,IntVar,int,IntVar,IntConLevel=ICL_DEF);
+void element(Home,IntSharedArray,IntVar,IntVar,IntConLevel=ICL_DEF);
+void element(Home,SetOpType,const IntArgs&,SetVar,SetVar,const IntSet&=IntSet(Set::Limits::min,Set::Limits::max));
+void element(Home,SetOpType,const IntSetArgs&,SetVar,SetVar,const IntSet&=IntSet(Set::Limits::min,Set::Limits::max));
+void element(Home,SetOpType,const IntVarArgs&,SetVar,SetVar,const IntSet&=IntSet(Set::Limits::min,Set::Limits::max));
+void element(Home,SetOpType,const SetVarArgs&,SetVar,SetVar,const IntSet&=IntSet(Set::Limits::min,Set::Limits::max));
+void extensional(Home,const BoolVarArgs&,const TupleSet&,ExtensionalPropKind=EPK_DEF,IntConLevel=ICL_DEF);
+void extensional(Home,const BoolVarArgs&,DFA,IntConLevel=ICL_DEF);
+void extensional(Home,const IntVarArgs&,const TupleSet&,ExtensionalPropKind=EPK_DEF,IntConLevel=ICL_DEF);
+void extensional(Home,const IntVarArgs&,DFA,IntConLevel=ICL_DEF);
+void linear(Home,const BoolVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void linear(Home,const BoolVarArgs&,IntRelType,int,Reify,IntConLevel=ICL_DEF);
+void linear(Home,const BoolVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void linear(Home,const BoolVarArgs&,IntRelType,IntVar,Reify,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const BoolVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const BoolVarArgs&,IntRelType,int,Reify,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const BoolVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const BoolVarArgs&,IntRelType,IntVar,Reify,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const IntVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const IntVarArgs&,IntRelType,int,Reify,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const IntVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const IntVarArgs&,IntRelType,IntVar,Reify,IntConLevel=ICL_DEF);
+void linear(Home,const IntVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void linear(Home,const IntVarArgs&,IntRelType,int,Reify,IntConLevel=ICL_DEF);
+void linear(Home,const IntVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntVarArgs&,IntRelType,IntVar,Reify,IntConLevel=ICL_DEF);
+void max(Home,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void max(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void max(Home,SetVar,IntVar);
+void max(Home,SetVar,IntVar,BoolVar);
+void member(Home,const BoolVarArgs&,BoolVar,IntConLevel=ICL_DEF);
+void member(Home,const BoolVarArgs&,BoolVar,Reify,IntConLevel=ICL_DEF);
+void member(Home,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void member(Home,const IntVarArgs&,IntVar,Reify,IntConLevel=ICL_DEF);
+void min(Home,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void min(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void min(Home,SetVar,IntVar);
+void min(Home,SetVar,IntVar,BoolVar);
+void mod(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void mult(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void nooverlap(Home,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void nooverlap(Home,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void nooverlap(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void nooverlap(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void notMax(Home,SetVar,IntVar);
+void notMin(Home,SetVar,IntVar);
+void nvalues(Home,const BoolVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void nvalues(Home,const BoolVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void nvalues(Home,const IntVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void nvalues(Home,const IntVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntArgs&,const IntVarArgs&,IntVar,IntVar,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntArgs&,const IntVarArgs&,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntArgs&,int,const IntVarArgs&,IntVar,IntVar,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntArgs&,int,const IntVarArgs&,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntVarArgs&,IntVar,IntVar,IntConLevel=ICL_DEF);
+void path(Home,int,const IntVarArgs&,IntVar,IntVar,IntConLevel=ICL_DEF);
+void precede(Home,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void precede(Home,const IntVarArgs&,int,int,IntConLevel=ICL_DEF);
+void precede(Home,const SetVarArgs&,const IntArgs&);
+void precede(Home,const SetVarArgs&,int,int);
+void rel(Home,BoolOpType,const BoolVarArgs&,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,BoolOpType,const BoolVarArgs&,int,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,BoolOpType,BoolVar,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,BoolOpType,BoolVar,int,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,IntRelType,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,IntRelType,BoolVar,Reify,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,IntRelType,int,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,IntRelType,int,Reify,IntConLevel=ICL_DEF);
+void rel(Home,const BoolVarArgs&,IntRelType,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,const BoolVarArgs&,IntRelType,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void rel(Home,const BoolVarArgs&,IntRelType,IntConLevel=ICL_DEF);
+void rel(Home,const BoolVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void rel(Home,const IntSet&,SetOpType,SetVar,SetRelType,const IntSet&);
+void rel(Home,const IntSet&,SetOpType,SetVar,SetRelType,SetVar);
+void rel(Home,const IntVarArgs&,IntRelType,const IntVarArgs&,IntConLevel=ICL_DEF);
+void rel(Home,const IntVarArgs&,IntRelType,IntConLevel=ICL_DEF);
+void rel(Home,const IntVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void rel(Home,const IntVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,int,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,int,Reify,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,IntVar,Reify,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,SetVar);
+void rel(Home,IntVar,SetRelType,SetVar);
+void rel(Home,IntVar,SetRelType,SetVar,BoolVar);
+void rel(Home,SetOpType,const IntVarArgs&,const IntSet&,SetVar);
+void rel(Home,SetOpType,const IntVarArgs&,SetVar);
+void rel(Home,SetOpType,const SetVarArgs&,const IntSet&,SetVar);
+void rel(Home,SetOpType,const SetVarArgs&,SetVar);
+void rel(Home,SetVar,IntRelType,IntVar);
+void rel(Home,SetVar,SetOpType,const IntSet&,SetRelType,const IntSet&);
+void rel(Home,SetVar,SetOpType,const IntSet&,SetRelType,SetVar);
+void rel(Home,SetVar,SetOpType,SetVar,SetRelType,const IntSet&);
+void rel(Home,SetVar,SetOpType,SetVar,SetRelType,SetVar);
+void rel(Home,SetVar,SetRelType,IntVar);
+void rel(Home,SetVar,SetRelType,IntVar,BoolVar);
+void rel(Home,SetVar,SetRelType,SetVar);
+void rel(Home,SetVar,SetRelType,SetVar,BoolVar);
+void sequence(Home,const BoolVarArgs&,const IntSet&,int,int,int,IntConLevel=ICL_DEF);
+void sequence(Home,const IntVarArgs&,const IntSet&,int,int,int,IntConLevel=ICL_DEF);
+void sequence(Home,const SetVarArgs&);
+void sequence(Home,const SetVarArgs&,SetVar);
+void sorted(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void sorted(Home,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void sqr(Home,IntVar,IntVar,IntConLevel=ICL_DEF);
+void sqrt(Home,IntVar,IntVar,IntConLevel=ICL_DEF);
+void unary(Home,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void unshare(Home,BoolVarArgs&,IntConLevel=ICL_DEF);
+void unshare(Home,IntVarArgs&,IntConLevel=ICL_DEF);
+void weights(Home,IntSharedArray,IntSharedArray,SetVar,IntVar);

packages/gecode/dev/gecode-prototypes-4.2.0.hh

@@ -0,0 +1,280 @@
+// This file was automatically extracted from Gecode source files.
+// It is subject to the same Copyright as the source files from which
+// it is derived, and is distributed under the same Licensing conditions.
+BrancherHandle assign(Home,BoolVar,IntAssign,BoolVarValPrint=NULL);
+BrancherHandle assign(Home,const BoolVarArgs&,IntAssign,BoolBranchFilter=NULL,BoolVarValPrint=NULL);
+BrancherHandle assign(Home,const FloatVarArgs&,FloatAssign,FloatBranchFilter=NULL,FloatVarValPrint=NULL);
+BrancherHandle assign(Home,const IntVarArgs&,IntAssign,IntBranchFilter=NULL,IntVarValPrint=NULL);
+BrancherHandle assign(Home,const SetVarArgs&,SetAssign,SetBranchFilter=NULL,SetVarValPrint=NULL);
+BrancherHandle assign(Home,FloatVar,FloatAssign,FloatVarValPrint=NULL);
+BrancherHandle assign(Home,IntVar,IntAssign,IntVarValPrint=NULL);
+BrancherHandle assign(Home,SetVar,SetAssign,SetVarValPrint=NULL);
+BrancherHandle branch(Home,BoolVar,IntValBranch,BoolVarValPrint=NULL);
+BrancherHandle branch(Home,const BoolVarArgs&,IntVarBranch,IntValBranch,BoolBranchFilter=NULL,BoolVarValPrint=NULL);
+BrancherHandle branch(Home,const BoolVarArgs&,IntVarBranch,IntValBranch,const Symmetries&,BoolBranchFilter=NULL,BoolVarValPrint=NULL);
+BrancherHandle branch(Home,const BoolVarArgs&,TieBreak<IntVarBranch>,IntValBranch,BoolBranchFilter=NULL,BoolVarValPrint=NULL);
+BrancherHandle branch(Home,const BoolVarArgs&,TieBreak<IntVarBranch>,IntValBranch,const Symmetries&,BoolBranchFilter=NULL,BoolVarValPrint=NULL);
+BrancherHandle branch(Home,const FloatVarArgs&,FloatVarBranch,FloatValBranch,FloatBranchFilter=NULL,FloatVarValPrint=NULL);
+BrancherHandle branch(Home,const FloatVarArgs&,TieBreak<FloatVarBranch>,FloatValBranch,FloatBranchFilter=NULL,FloatVarValPrint=NULL);
+BrancherHandle branch(Home,const IntVarArgs&,IntVarBranch,IntValBranch,const Symmetries&,IntBranchFilter=NULL,IntVarValPrint=NULL);
+BrancherHandle branch(Home,const IntVarArgs&,IntVarBranch,IntValBranch,IntBranchFilter=NULL,IntVarValPrint=NULL);
+BrancherHandle branch(Home,const IntVarArgs&,TieBreak<IntVarBranch>,IntValBranch,const Symmetries&,IntBranchFilter=NULL,IntVarValPrint=NULL);
+BrancherHandle branch(Home,const IntVarArgs&,TieBreak<IntVarBranch>,IntValBranch,IntBranchFilter=NULL,IntVarValPrint=NULL);
+BrancherHandle branch(Home,const SetVarArgs&,SetVarBranch,SetValBranch,const Symmetries&,SetBranchFilter=NULL,SetVarValPrint=NULL);
+BrancherHandle branch(Home,const SetVarArgs&,SetVarBranch,SetValBranch,SetBranchFilter=NULL,SetVarValPrint=NULL);
+BrancherHandle branch(Home,const SetVarArgs&,TieBreak<SetVarBranch>,SetValBranch,const Symmetries&,SetBranchFilter=NULL,SetVarValPrint=NULL);
+BrancherHandle branch(Home,const SetVarArgs&,TieBreak<SetVarBranch>,SetValBranch,SetBranchFilter=NULL,SetVarValPrint=NULL);
+BrancherHandle branch(Home,FloatVar,FloatValBranch,FloatVarValPrint=NULL);
+BrancherHandle branch(Home,IntVar,IntValBranch,IntVarValPrint=NULL);
+BrancherHandle branch(Home,SetVar,SetValBranch,SetVarValPrint=NULL);
+void abs(Home,FloatVar,FloatVar);
+void abs(Home,IntVar,IntVar,IntConLevel=ICL_DEF);
+void atmostOne(Home,const SetVarArgs&,unsigned int);
+void binpacking(Home,const IntVarArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cardinality(Home,const SetVarArgs&,unsigned int,unsigned int);
+void cardinality(Home,SetVar,IntVar);
+void cardinality(Home,SetVar,unsigned int,unsigned int);
+void channel(Home,BoolVar,IntVar,IntConLevel=ICL_DEF);
+void channel(Home,const BoolVarArgs&,IntVar,int=0,IntConLevel=ICL_DEF);
+void channel(Home,const BoolVarArgs&,SetVar);
+void channel(Home,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void channel(Home,const IntVarArgs&,const SetVarArgs&);
+void channel(Home,const IntVarArgs&,int,const IntVarArgs&,int,IntConLevel=ICL_DEF);
+void channel(Home,const SetVarArgs&,const SetVarArgs&);
+void channel(Home,FloatVar,IntVar);
+void channel(Home,IntVar,FloatVar);
+void channelSorted(Home,const IntVarArgs&,SetVar);
+void circuit(Home,const IntArgs&,const IntVarArgs&,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void circuit(Home,const IntArgs&,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void circuit(Home,const IntArgs&,int,const IntVarArgs&,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void circuit(Home,const IntArgs&,int,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void circuit(Home,const IntVarArgs&,IntConLevel=ICL_DEF);
+void circuit(Home,int,const IntVarArgs&,IntConLevel=ICL_DEF);
+void clause(Home,BoolOpType,const BoolVarArgs&,const BoolVarArgs&,BoolVar,IntConLevel=ICL_DEF);
+void clause(Home,BoolOpType,const BoolVarArgs&,const BoolVarArgs&,int,IntConLevel=ICL_DEF);
+void convex(Home,SetVar);
+void convex(Home,SetVar,SetVar);
+void count(Home,const IntVarArgs&,const IntArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSetArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSetArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSet&,const IntArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSet&,IntRelType,int,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntSet&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,int,IntRelType,int,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,int,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,IntVar,IntRelType,int,IntConLevel=ICL_DEF);
+void count(Home,const IntVarArgs&,IntVar,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const IntVarArgs&,const IntArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const IntVarArgs&,const IntArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,int,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const IntVarArgs&,const IntArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const IntVarArgs&,const IntArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void cumulative(Home,IntVar,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntArgs&,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntArgs&,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void cumulatives(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntArgs&,bool,IntConLevel=ICL_DEF);
+void distinct(Home,const IntArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void distinct(Home,const IntVarArgs&,IntConLevel=ICL_DEF);
+void div(Home,FloatVar,FloatVar,FloatVar);
+void div(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void divmod(Home,IntVar,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void dom(Home,BoolVar,BoolVar,IntConLevel=ICL_DEF);
+void dom(Home,const BoolVarArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void dom(Home,const FloatVarArgs&,const FloatVarArgs&);
+void dom(Home,const FloatVarArgs&,FloatNum,FloatNum);
+void dom(Home,const FloatVarArgs&,FloatVal);
+void dom(Home,const IntVarArgs&,const IntSet&,IntConLevel=ICL_DEF);
+void dom(Home,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void dom(Home,const IntVarArgs&,int,IntConLevel=ICL_DEF);
+void dom(Home,const IntVarArgs&,int,int,IntConLevel=ICL_DEF);
+void dom(Home,const SetVarArgs&,const SetVarArgs&);
+void dom(Home,const SetVarArgs&,SetRelType,const IntSet&);
+void dom(Home,const SetVarArgs&,SetRelType,int);
+void dom(Home,const SetVarArgs&,SetRelType,int,int);
+void dom(Home,FloatVar,FloatNum,FloatNum);
+void dom(Home,FloatVar,FloatNum,FloatNum,Reify);
+void dom(Home,FloatVar,FloatVal);
+void dom(Home,FloatVar,FloatVal,Reify);
+void dom(Home,FloatVar,FloatVar);
+void dom(Home,IntVar,const IntSet&,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,const IntSet&,Reify,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,int,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,int,int,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,int,int,Reify,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,int,Reify,IntConLevel=ICL_DEF);
+void dom(Home,IntVar,IntVar,IntConLevel=ICL_DEF);
+void dom(Home,SetVar,SetRelType,const IntSet&);
+void dom(Home,SetVar,SetRelType,const IntSet&,Reify);
+void dom(Home,SetVar,SetRelType,int);
+void dom(Home,SetVar,SetRelType,int,int);
+void dom(Home,SetVar,SetRelType,int,int,Reify);
+void dom(Home,SetVar,SetRelType,int,Reify);
+void dom(Home,SetVar,SetVar);
+void element(Home,const BoolVarArgs&,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void element(Home,const BoolVarArgs&,IntVar,int,IntConLevel=ICL_DEF);
+void element(Home,const BoolVarArgs&,IntVar,int,IntVar,int,BoolVar,IntConLevel=ICL_DEF);
+void element(Home,const IntSetArgs&,IntVar,int,IntVar,int,SetVar);
+void element(Home,const IntSetArgs&,IntVar,SetVar);
+void element(Home,const IntVarArgs&,IntVar,int,IntConLevel=ICL_DEF);
+void element(Home,const IntVarArgs&,IntVar,int,IntVar,int,IntVar,IntConLevel=ICL_DEF);
+void element(Home,const IntVarArgs&,IntVar,IntVar,IntConLevel=ICL_DEF);
+void element(Home,const SetVarArgs&,IntVar,int,IntVar,int,SetVar);
+void element(Home,const SetVarArgs&,IntVar,SetVar);
+void element(Home,IntSharedArray,IntVar,BoolVar,IntConLevel=ICL_DEF);
+void element(Home,IntSharedArray,IntVar,int,IntConLevel=ICL_DEF);
+void element(Home,IntSharedArray,IntVar,int,IntVar,int,BoolVar,IntConLevel=ICL_DEF);
+void element(Home,IntSharedArray,IntVar,int,IntVar,int,IntVar,IntConLevel=ICL_DEF);
+void element(Home,IntSharedArray,IntVar,IntVar,IntConLevel=ICL_DEF);
+void element(Home,SetOpType,const IntArgs&,SetVar,SetVar,const IntSet&=IntSet(Set::Limits::min,Set::Limits::max));
+void element(Home,SetOpType,const IntSetArgs&,SetVar,SetVar,const IntSet&=IntSet(Set::Limits::min,Set::Limits::max));
+void element(Home,SetOpType,const IntVarArgs&,SetVar,SetVar,const IntSet&=IntSet(Set::Limits::min,Set::Limits::max));
+void element(Home,SetOpType,const SetVarArgs&,SetVar,SetVar,const IntSet&=IntSet(Set::Limits::min,Set::Limits::max));
+void extensional(Home,const BoolVarArgs&,const TupleSet&,ExtensionalPropKind=EPK_DEF,IntConLevel=ICL_DEF);
+void extensional(Home,const BoolVarArgs&,DFA,IntConLevel=ICL_DEF);
+void extensional(Home,const IntVarArgs&,const TupleSet&,ExtensionalPropKind=EPK_DEF,IntConLevel=ICL_DEF);
+void extensional(Home,const IntVarArgs&,DFA,IntConLevel=ICL_DEF);
+void ite(Home,BoolVar,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void linear(Home,const BoolVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void linear(Home,const BoolVarArgs&,IntRelType,int,Reify,IntConLevel=ICL_DEF);
+void linear(Home,const BoolVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void linear(Home,const BoolVarArgs&,IntRelType,IntVar,Reify,IntConLevel=ICL_DEF);
+void linear(Home,const FloatValArgs&,const FloatVarArgs&,FloatRelType,FloatNum);
+void linear(Home,const FloatValArgs&,const FloatVarArgs&,FloatRelType,FloatNum,Reify);
+void linear(Home,const FloatValArgs&,const FloatVarArgs&,FloatRelType,FloatVar);
+void linear(Home,const FloatValArgs&,const FloatVarArgs&,FloatRelType,FloatVar,Reify);
+void linear(Home,const FloatVarArgs&,FloatRelType,FloatNum);
+void linear(Home,const FloatVarArgs&,FloatRelType,FloatNum,Reify);
+void linear(Home,const FloatVarArgs&,FloatRelType,FloatVar);
+void linear(Home,const FloatVarArgs&,FloatRelType,FloatVar,Reify);
+void linear(Home,const IntArgs&,const BoolVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const BoolVarArgs&,IntRelType,int,Reify,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const BoolVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const BoolVarArgs&,IntRelType,IntVar,Reify,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const IntVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const IntVarArgs&,IntRelType,int,Reify,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const IntVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntArgs&,const IntVarArgs&,IntRelType,IntVar,Reify,IntConLevel=ICL_DEF);
+void linear(Home,const IntVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void linear(Home,const IntVarArgs&,IntRelType,int,Reify,IntConLevel=ICL_DEF);
+void linear(Home,const IntVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void linear(Home,const IntVarArgs&,IntRelType,IntVar,Reify,IntConLevel=ICL_DEF);
+void max(Home,const FloatVarArgs&,FloatVar);
+void max(Home,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void max(Home,FloatVar,FloatVar,FloatVar);
+void max(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void max(Home,SetVar,IntVar);
+void max(Home,SetVar,IntVar,Reify);
+void member(Home,const BoolVarArgs&,BoolVar,IntConLevel=ICL_DEF);
+void member(Home,const BoolVarArgs&,BoolVar,Reify,IntConLevel=ICL_DEF);
+void member(Home,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void member(Home,const IntVarArgs&,IntVar,Reify,IntConLevel=ICL_DEF);
+void min(Home,const FloatVarArgs&,FloatVar);
+void min(Home,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void min(Home,FloatVar,FloatVar,FloatVar);
+void min(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void min(Home,SetVar,IntVar);
+void min(Home,SetVar,IntVar,Reify);
+void mod(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void mult(Home,FloatVar,FloatVar,FloatVar);
+void mult(Home,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void nooverlap(Home,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void nooverlap(Home,const IntVarArgs&,const IntArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void nooverlap(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void nooverlap(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void notMax(Home,SetVar,IntVar);
+void notMin(Home,SetVar,IntVar);
+void nroot(Home,FloatVar,int,FloatVar);
+void nroot(Home,IntVar,int,IntVar,IntConLevel=ICL_DEF);
+void nvalues(Home,const BoolVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void nvalues(Home,const BoolVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void nvalues(Home,const IntVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void nvalues(Home,const IntVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntArgs&,const IntVarArgs&,IntVar,IntVar,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntArgs&,const IntVarArgs&,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntArgs&,int,const IntVarArgs&,IntVar,IntVar,const IntVarArgs&,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntArgs&,int,const IntVarArgs&,IntVar,IntVar,IntVar,IntConLevel=ICL_DEF);
+void path(Home,const IntVarArgs&,IntVar,IntVar,IntConLevel=ICL_DEF);
+void path(Home,int,const IntVarArgs&,IntVar,IntVar,IntConLevel=ICL_DEF);
+void pow(Home,FloatVar,int,FloatVar);
+void pow(Home,IntVar,int,IntVar,IntConLevel=ICL_DEF);
+void precede(Home,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void precede(Home,const IntVarArgs&,int,int,IntConLevel=ICL_DEF);
+void precede(Home,const SetVarArgs&,const IntArgs&);
+void precede(Home,const SetVarArgs&,int,int);
+void rel(Home,BoolOpType,const BoolVarArgs&,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,BoolOpType,const BoolVarArgs&,int,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,BoolOpType,BoolVar,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,BoolOpType,BoolVar,int,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,IntRelType,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,IntRelType,BoolVar,Reify,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,IntRelType,int,IntConLevel=ICL_DEF);
+void rel(Home,BoolVar,IntRelType,int,Reify,IntConLevel=ICL_DEF);
+void rel(Home,const BoolVarArgs&,IntRelType,BoolVar,IntConLevel=ICL_DEF);
+void rel(Home,const BoolVarArgs&,IntRelType,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void rel(Home,const BoolVarArgs&,IntRelType,IntConLevel=ICL_DEF);
+void rel(Home,const BoolVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void rel(Home,const FloatVarArgs&,FloatRelType,FloatVal);
+void rel(Home,const FloatVarArgs&,FloatRelType,FloatVar);
+void rel(Home,const IntSet&,SetOpType,SetVar,SetRelType,const IntSet&);
+void rel(Home,const IntSet&,SetOpType,SetVar,SetRelType,SetVar);
+void rel(Home,const IntVarArgs&,IntRelType,const IntVarArgs&,IntConLevel=ICL_DEF);
+void rel(Home,const IntVarArgs&,IntRelType,IntConLevel=ICL_DEF);
+void rel(Home,const IntVarArgs&,IntRelType,int,IntConLevel=ICL_DEF);
+void rel(Home,const IntVarArgs&,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void rel(Home,FloatVar,FloatRelType,FloatVal);
+void rel(Home,FloatVar,FloatRelType,FloatVal,Reify);
+void rel(Home,FloatVar,FloatRelType,FloatVar);
+void rel(Home,FloatVar,FloatRelType,FloatVar,Reify);
+void rel(Home,IntVar,IntRelType,int,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,int,Reify,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,IntVar,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,IntVar,Reify,IntConLevel=ICL_DEF);
+void rel(Home,IntVar,IntRelType,SetVar);
+void rel(Home,IntVar,SetRelType,SetVar);
+void rel(Home,IntVar,SetRelType,SetVar,Reify);
+void rel(Home,SetOpType,const IntVarArgs&,const IntSet&,SetVar);
+void rel(Home,SetOpType,const IntVarArgs&,SetVar);
+void rel(Home,SetOpType,const SetVarArgs&,const IntSet&,SetVar);
+void rel(Home,SetOpType,const SetVarArgs&,SetVar);
+void rel(Home,SetVar,IntRelType,IntVar);
+void rel(Home,SetVar,SetOpType,const IntSet&,SetRelType,const IntSet&);
+void rel(Home,SetVar,SetOpType,const IntSet&,SetRelType,SetVar);
+void rel(Home,SetVar,SetOpType,SetVar,SetRelType,const IntSet&);
+void rel(Home,SetVar,SetOpType,SetVar,SetRelType,SetVar);
+void rel(Home,SetVar,SetRelType,IntVar);
+void rel(Home,SetVar,SetRelType,IntVar,Reify);
+void rel(Home,SetVar,SetRelType,SetVar);
+void rel(Home,SetVar,SetRelType,SetVar,Reify);
+void sequence(Home,const BoolVarArgs&,const IntSet&,int,int,int,IntConLevel=ICL_DEF);
+void sequence(Home,const IntVarArgs&,const IntSet&,int,int,int,IntConLevel=ICL_DEF);
+void sequence(Home,const SetVarArgs&);
+void sequence(Home,const SetVarArgs&,SetVar);
+void sorted(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void sorted(Home,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void sqr(Home,FloatVar,FloatVar);
+void sqr(Home,IntVar,IntVar,IntConLevel=ICL_DEF);
+void sqrt(Home,FloatVar,FloatVar);
+void sqrt(Home,IntVar,IntVar,IntConLevel=ICL_DEF);
+void unary(Home,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const IntVarArgs&,const IntVarArgs&,const IntVarArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,const BoolVarArgs&,IntConLevel=ICL_DEF);
+void unary(Home,const TaskTypeArgs&,const IntVarArgs&,const IntArgs&,IntConLevel=ICL_DEF);
+void unshare(Home,BoolVarArgs&,IntConLevel=ICL_DEF);
+void unshare(Home,IntVarArgs&,IntConLevel=ICL_DEF);
+void weights(Home,IntSharedArray,IntSharedArray,SetVar,IntVar);