From 141c07e09b953ddbd91d82405217fdb52a195cd1 Mon Sep 17 00:00:00 2001 From: Mikael Zayenz Lagerkvist Date: Wed, 14 Oct 2026 10:25:06 +0200 Subject: [PATCH 01/34] Add scoped suppression of global propagator information --- changelog.in | 10 +++ gecode/kernel/core.cpp | 19 +++- gecode/kernel/core.hpp | 80 ++++++++++++++++- gecode/kernel/gpi.hpp | 9 +- test/afc.cpp | 198 +++++++++++++++++++++++++++++++++++++++++ 5 files changed, 308 insertions(+), 8 deletions(-) diff --git a/changelog.in b/changelog.in index 394b936a5d..374a67787c 100755 --- a/changelog.in +++ b/changelog.in @@ -73,6 +73,16 @@ Date: unreleased [DESCRIPTION] This is the development changelog for the next Gecode release. +[ENTRY] +Module: kernel +What: new +Rank: minor +[DESCRIPTION] +Add Space::NoGPI for scoped posting without globally retained propagator +information. Scoped propagators keep their identifiers and groups in the +space, have zero AFC, and copy their information when cloned. Rewriting +preserves the original propagator information. + [ENTRY] Module: int diff --git a/gecode/kernel/core.cpp b/gecode/kernel/core.cpp index 4293cfe6a8..6d5489f761 100644 --- a/gecode/kernel/core.cpp +++ b/gecode/kernel/core.cpp @@ -118,7 +118,7 @@ namespace Gecode { VarImpDisposerBase* Space::vd[AllVarConf::idx_d]; #endif - Space::Space(void) : mm(ssd.data().sm) { + Space::Space(void) : no_gpi(false), mm(ssd.data().sm) { #ifdef GECODE_HAS_CBS var_id_counter = 0; #endif @@ -540,7 +540,8 @@ namespace Gecode { // Process failure failed: // Count failure - ssd.data().gpi.fail(p->gpi()); + if (!p->local_info()) + ssd.data().gpi.fail(p->gpi()); // Mark as failed fail(); // Propagate top priority propagators @@ -722,7 +723,7 @@ namespace Gecode { * */ Space::Space(Space& s) - : ssd(s.ssd), + : no_gpi(false), ssd(s.ssd), mm(ssd.data().sm,s.mm,s.pc.p.n_sub*sizeof(Propagator**)), #ifdef GECODE_HAS_CBS var_id_counter(s.var_id_counter), @@ -920,11 +921,23 @@ namespace Gecode { } + void* + Space::local_info(unsigned int gid) { + static_assert(alignof(Kernel::GPI::Info) >= 4, + "Propagator information needs two tag bits"); + Kernel::GPI::Info* i = alloc(1); + i->init(ssd.data().gpi.next_pid(),gid); + i->afc = 0.0; + return Support::ptrjoin(i,2); + } + void Space::afc_unshare(void) { if (ssd.data().gpi.unshare()) { for (Propagators ps(*this); ps(); ++ps) { Propagator& p = ps.propagator(); + if (p.local_info()) + continue; Kernel::GPI::Info* gpi = ssd.data().gpi.allocate(p.gpi().pid,p.gpi().gid); if (p.disabled()) diff --git a/gecode/kernel/core.hpp b/gecode/kernel/core.hpp index 169aab6599..95f9d93363 100755 --- a/gecode/kernel/core.hpp +++ b/gecode/kernel/core.hpp @@ -1087,12 +1087,19 @@ namespace Gecode { /// A list of advisors (used during cloning) Gecode::ActorLink* advisors; } u; - /// A tagged pointer combining a pointer to global propagator information and whether the propagator is disabled + /** + * \brief Tagged pointer to propagator information + * + * Bit zero marks disabled propagators; bit one marks space-local + * information, which has no accumulated failure count. + */ void* gpi_disabled; /// Static cast for a non-null pointer (to give a hint to optimizer) static Propagator* cast(ActorLink* al); /// Static cast for a non-null pointer (to give a hint to optimizer) static const Propagator* cast(const ActorLink* al); + /// Whether propagator information is local to the space + bool local_info(void) const; /// Disable propagator void disable(Space& home); /// Enable propagator @@ -1104,7 +1111,7 @@ namespace Gecode { Propagator(Space& home, Propagator& p); /// Return forwarding pointer during copying Propagator* fwd(void) const; - /// Provide access to global propagator information + /// Provide access to propagator information Kernel::GPI::Info& gpi(void); public: @@ -1791,6 +1798,10 @@ namespace Gecode { friend GECODE_KERNEL_EXPORT void trace(Home home, TraceFilter tf, int te, Tracer& t); private: + /// Whether new propagator information is local to this space + bool no_gpi; + /// Allocate tagged space-local propagator information + GECODE_KERNEL_EXPORT void* local_info(unsigned int gid); /// Shared data for space Kernel::SharedSpaceData ssd; /// Performs memory management for space @@ -2037,6 +2048,42 @@ namespace Gecode { GECODE_KERNEL_EXPORT void ap_ignore_dispose(Actor* a, bool d); public: + /** + * \brief Suppress global propagator information during scoped posting + * \ingroup TaskModelScript + * + * New propagators posted into this space use space-local information + * instead of records retained by all spaces in a search. Their AFC is + * always zero, including after AFC initialization or unsharing. They + * retain normal identifiers and groups, so tracing and counting-based + * search remain supported. Group changes for these propagators are + * local to the space; clones copy the current group. Local records are + * reclaimed with the space, even if their propagators subsume earlier. + * AFC-based branching therefore only counts ordinary propagators. + * + * Rewriting inherits the original propagator's information, regardless + * of this context. Existing propagators are unaffected. Clones retain + * local information but start with ordinary posting enabled. + * + * Contexts can be nested and restore the previous setting on destruction, + * including exception unwinding. The space must outlive the context, + * and contexts for the same space must be destroyed in reverse order. + */ + class NoGPI { + private: + /// Space in which to suppress global information + Space& home; + /// Previous setting + bool previous; + NoGPI(const NoGPI&) = delete; + NoGPI& operator =(const NoGPI&) = delete; + public: + /// Suppress global information for new propagators in \a home + explicit NoGPI(Space& home); + /// Restore the previous setting + ~NoGPI(void); + }; + /** * \brief Default constructor * \ingroup TaskModelScript @@ -3556,6 +3603,17 @@ namespace Gecode { } + forceinline + Space::NoGPI::NoGPI(Space& h) : home(h), previous(h.no_gpi) { + home.no_gpi = true; + } + + forceinline + Space::NoGPI::~NoGPI(void) { + home.no_gpi = previous; + } + + /* * Propagator * @@ -3581,6 +3639,11 @@ namespace Gecode { return static_cast(prev()); } + forceinline bool + Propagator::local_info(void) const { + return (reinterpret_cast(gpi_disabled) & 2) != 0; + } + forceinline bool Propagator::disabled(void) const { return Support::marked(gpi_disabled); @@ -3600,7 +3663,8 @@ namespace Gecode { forceinline Kernel::GPI::Info& Propagator::gpi(void) { - return *static_cast(Support::funmark(gpi_disabled)); + return *reinterpret_cast + (reinterpret_cast(gpi_disabled) & ~static_cast(3)); } forceinline @@ -3608,6 +3672,9 @@ namespace Gecode { : gpi_disabled((home.propagator() != nullptr) ? // Inherit propagator information home.propagator()->gpi_disabled : + static_cast(home).no_gpi ? + static_cast(home).local_info + (home.propagatorgroup().gid) : // New propagator information static_cast(home).ssd.data().gpi.allocate (home.propagatorgroup().gid)) { @@ -3617,8 +3684,13 @@ namespace Gecode { } forceinline - Propagator::Propagator(Space&, Propagator& p) + Propagator::Propagator(Space& home, Propagator& p) : gpi_disabled(p.gpi_disabled) { + if (p.local_info()) { + Kernel::GPI::Info* i = home.alloc(1); + *i = p.gpi(); + gpi_disabled = Support::ptrjoin(i, p.disabled() ? 3 : 2); + } u.advisors = nullptr; assert((u.med == 0) && (u.size == 0)); // Set forwarding pointer diff --git a/gecode/kernel/gpi.hpp b/gecode/kernel/gpi.hpp index bca28ef4ee..56d18353eb 100755 --- a/gecode/kernel/gpi.hpp +++ b/gecode/kernel/gpi.hpp @@ -92,6 +92,8 @@ namespace Gecode { namespace Kernel { Info* allocate(unsigned int p, unsigned int gid); /// Allocate new actor info Info* allocate(unsigned int gid); + /// Allocate a new propagator id without allocating information + unsigned int next_pid(void); /// Return next free propagator id unsigned int pid(void) const; /// Provide access to unshare info and set to true @@ -141,6 +143,11 @@ namespace Gecode { namespace Kernel { return d; } + forceinline unsigned int + GPI::next_pid(void) { + return npid.fetch_add(1, std::memory_order_seq_cst); + } + forceinline unsigned int GPI::pid(void) const { return npid.load(std::memory_order_acquire); @@ -186,7 +193,7 @@ namespace Gecode { namespace Kernel { } c = &b->info[--b->free]; m.release(); - c->init(npid.fetch_add(1, std::memory_order_seq_cst),gid); + c->init(next_pid(),gid); return c; } diff --git a/test/afc.cpp b/test/afc.cpp index eceff77137..ed9aa620c9 100644 --- a/test/afc.cpp +++ b/test/afc.cpp @@ -36,6 +36,8 @@ #include "test/test.hh" +#include + namespace Test { /// %Test for %AFC infrastructure @@ -132,6 +134,202 @@ namespace Test { } }; + /// Scoped suppression of global propagator information + class NoGPI : public Test::Base { + /// Space with variables for posting and rewriting relations + class TestSpace : public Gecode::Space { + public: + Gecode::IntVar x, y; + Gecode::BoolVar b; + TestSpace(void) : x(*this,0,10), y(*this,0,10), b(*this,0,1) {} + TestSpace(TestSpace& s) : Space(s) { + x.update(*this,s.x); y.update(*this,s.y); b.update(*this,s.b); + } + virtual Space* copy(void) { return new TestSpace(*this); } + /// Find a surviving propagator by its identifier + Gecode::Propagator* find(unsigned int id) { + for (Propagators ps(*this); ps(); ++ps) + if (ps.propagator().id() == id) + return &ps.propagator(); + return nullptr; + } + /// Post a non-subsumed relation and return its propagator + Gecode::Propagator& post(Gecode::PropagatorGroup g = + Gecode::PropagatorGroup::def) { + Gecode::rel((*this)(g), x, Gecode::IRT_LE, y); + Gecode::Propagator* p = nullptr; + for (Propagators ps(*this); ps(); ++ps) + if ((p == nullptr) || (ps.propagator().id() > p->id())) + p = &ps.propagator(); + return *p; + } + }; + + /// Check nesting, unwinding, isolation, and posting in a clone + bool scopes(void) { + using namespace Gecode; + TestSpace s, other; + if (s.post().afc() != 1.0) + return false; + { + Space::NoGPI outer(s); + if ((s.post().afc() != 0.0) || (other.post().afc() != 1.0)) + return false; + try { + Space::NoGPI inner(s); + if (s.post().afc() != 0.0) + return false; + throw 1; + } catch (int) {} + if (s.post().afc() != 0.0) + return false; + (void) s.status(); + std::unique_ptr c(static_cast(s.clone())); + if (c->post().afc() != 1.0) + return false; + } + try { + Space::NoGPI context(s); + throw 1; + } catch (int) {} + return s.post().afc() == 1.0; + } + + /// Check local groups, disabled pointer tags, and lifetime after cloning + bool lifetime(void) { + using namespace Gecode; + std::unique_ptr s(new TestSpace); + PropagatorGroup a, b; + unsigned int id; + { + Space::NoGPI context(*s); + Propagator& p = s->post(a); + id = p.id(); + if ((p.group() != a) || (s->post().id() == id)) + return false; + } + a.disable(*s); + (void) s->status(); + std::unique_ptr c(static_cast(s->clone())); + // The first call marks the shared pool; the second really unshares. + s->afc_unshare(); + c->afc_unshare(); + Propagator* p = c->find(id); + if (!p || !p->disabled() || (p->afc() != 0.0)) + return false; + b.move(*c,id); + if ((p->group() != b) || (s->find(id)->group() != a)) + return false; + s.reset(); + b.enable(*c); + if (p->disabled() || (c->status() == SS_FAILED)) + return false; + b.kill(*c); + return (c->find(id) == nullptr) && (b.size(*c) == 0); + } + + /// Check AFC failure accounting, initialization, and rescaling + bool failure(bool local) { + using namespace Gecode; + TestSpace s; + Propagator* p; + if (local) { + Space::NoGPI context(s); + p = &s.post(); + } else { + p = &s.post(); + } + (void) s.status(); + std::unique_ptr c(static_cast(s.clone())); + // Force rescaling on failure for the ordinary propagator. + IntAFC afc(*c,IntVarArgs() << c->x << c->y,1.0e-300,false); + c->afc_unshare(); + Propagator* q = c->find(p->id()); + if (!q || (q->afc() != (local ? 0.0 : 1.0))) + return false; + rel(*c,c->x,IRT_EQ,5); + rel(*c,c->y,IRT_EQ,4); + if (c->status() != SS_FAILED) + return false; + return local ? ((q->afc() == 0.0) && (p->afc() == 0.0)) : + ((q->afc() > 1.0) && (p->afc() < 1.0)); + } + + /// A real reified propagator must retain its information when rewritten + bool rewrite(bool local) { + using namespace Gecode; + TestSpace s; + PropagatorGroup g; + if (local) { + Space::NoGPI context(s); + rel(s(g),s.x,IRT_EQ,s.y,Reify(s.b)); + } else { + rel(s(g),s.x,IRT_EQ,s.y,Reify(s.b)); + } + (void) s.status(); + Gecode::Propagators ps(s,PropagatorGroup::all); + unsigned int id = ps.propagator().id(); + rel(s,s.b,IRT_EQ,1); + if (local) { + (void) s.status(); + } else { + Space::NoGPI context(s); + (void) s.status(); + } + Propagator* p = s.find(id); + if (!p || (p->group() != g) || + (p->afc() != (local ? 0.0 : 1.0))) + return false; + rel(s,s.x,IRT_EQ,3); + return (s.status() == SS_SOLVED) && s.y.assigned() && (s.y.val() == 3); + } + + /// Collect posting counts and propagated identifiers + class Tracer : public Gecode::Tracer { + public: + unsigned int posted = 0; + std::vector ids; + virtual void propagate(const Gecode::Space&, + const Gecode::PropagateTraceInfo& p) { + ids.push_back(p.id()); + } + virtual void commit(const Gecode::Space&, + const Gecode::CommitTraceInfo&) {} + virtual void post(const Gecode::Space&, + const Gecode::PostTraceInfo& p) { + posted += p.propagators(); + } + }; + + /// Posting traces and propagation traces must retain distinct identities + bool tracing(void) { + using namespace Gecode; + Tracer t; + TestSpace s; + PropagatorGroup g; + trace(s,g,TE_POST | TE_PROPAGATE,t); + t.posted = 0; + unsigned int a, b; + { + Space::NoGPI context(s); + a = s.post(g).id(); + b = s.post(g).id(); + } + (void) s.status(); + return (t.posted == 2) && (a != b) && + (std::find(t.ids.begin(),t.ids.end(),a) != t.ids.end()) && + (std::find(t.ids.begin(),t.ids.end(),b) != t.ids.end()); + } + public: + NoGPI(void) : Test::Base("AFC::NoGPI") {} + virtual bool run(void) { + return scopes() && lifetime() && failure(false) && failure(true) && + rewrite(false) && rewrite(true) && tracing(); + } + }; + + NoGPI no_gpi; + AFC afc; } From ef525f16929838b6f1cf8b86bf622219517d49f9 Mon Sep 17 00:00:00 2001 From: Mikael Zayenz Lagerkvist Date: Wed, 14 Oct 2026 11:03:07 +0200 Subject: [PATCH 02/34] Add scoped GPI opt-in and fix CBS cache iteration --- changelog.in | 13 ++++++++- gecode/int/branch/cbs.hpp | 16 ++++++----- gecode/kernel/core.hpp | 39 +++++++++++++++++++++++++- test/afc.cpp | 28 +++++++++++++++++++ test/branch/int.cpp | 58 +++++++++++++++++++++++++++++++++++++++ 5 files changed, 145 insertions(+), 9 deletions(-) diff --git a/changelog.in b/changelog.in index 374a67787c..82f35d7e4e 100755 --- a/changelog.in +++ b/changelog.in @@ -81,7 +81,18 @@ Rank: minor Add Space::NoGPI for scoped posting without globally retained propagator information. Scoped propagators keep their identifiers and groups in the space, have zero AFC, and copy their information when cloned. Rewriting -preserves the original propagator information. +preserves the original propagator information. Space::UseGPI enables global +information for selected posting calls inside a NoGPI scope. Both contexts +restore the previous setting when they leave scope. + +[ENTRY] +Module: int +What: bug +Rank: minor +[DESCRIPTION] +Fix iterator invalidation when counting-based search removes expired +propagator cache entries. The invalid iterator could skip remaining entries +and leave the brancher without a choice. [ENTRY] diff --git a/gecode/int/branch/cbs.hpp b/gecode/int/branch/cbs.hpp index 6c21bcf1f4..263d437428 100755 --- a/gecode/int/branch/cbs.hpp +++ b/gecode/int/branch/cbs.hpp @@ -191,13 +191,15 @@ namespace Gecode { namespace Int { namespace Branch { // We delete unvisited propagators from the log and look for the highest // solution density across all propagators. - for (const auto& kv : logProp) { - unsigned int prop_id = kv.first; - const PropInfo& info = kv.second; - if (!info.visited) - logProp.erase(prop_id); - else if (info.dens > maxSD.dens) - maxSD = {info.var_id, info.val, info.dens}; + for (auto i = logProp.begin(); i != logProp.end(); ) { + if (!i->second.visited) { + i = logProp.erase(i); + } else { + const PropInfo& info = i->second; + if (info.dens > maxSD.dens) + maxSD = {info.var_id, info.val, info.dens}; + ++i; + } } assert(maxSD.dens != -1); diff --git a/gecode/kernel/core.hpp b/gecode/kernel/core.hpp index 95f9d93363..44ed428bc5 100755 --- a/gecode/kernel/core.hpp +++ b/gecode/kernel/core.hpp @@ -2065,7 +2065,8 @@ namespace Gecode { * of this context. Existing propagators are unaffected. Clones retain * local information but start with ordinary posting enabled. * - * Contexts can be nested and restore the previous setting on destruction, + * A nested UseGPI context enables global information for selected + * posting calls. Both contexts restore the previous setting on destruction, * including exception unwinding. The space must outlive the context, * and contexts for the same space must be destroyed in reverse order. */ @@ -2084,6 +2085,31 @@ namespace Gecode { ~NoGPI(void); }; + /** + * \brief Enable global propagator information during scoped posting + * \ingroup TaskModelScript + * + * Overrides an enclosing NoGPI context for new propagators posted into + * this space. Rewriting still inherits the original information. + * Destruction restores the previous setting, including exception + * unwinding. The space must outlive the context, and NoGPI and UseGPI + * contexts for the same space must be destroyed in reverse order. + */ + class UseGPI { + private: + /// Space in which to enable global information + Space& home; + /// Previous setting + bool previous; + UseGPI(const UseGPI&) = delete; + UseGPI& operator =(const UseGPI&) = delete; + public: + /// Enable global information for new propagators in \a home + explicit UseGPI(Space& home); + /// Restore the previous setting + ~UseGPI(void); + }; + /** * \brief Default constructor * \ingroup TaskModelScript @@ -3614,6 +3640,17 @@ namespace Gecode { } + forceinline + Space::UseGPI::UseGPI(Space& h) : home(h), previous(h.no_gpi) { + home.no_gpi = false; + } + + forceinline + Space::UseGPI::~UseGPI(void) { + home.no_gpi = previous; + } + + /* * Propagator * diff --git a/test/afc.cpp b/test/afc.cpp index ed9aa620c9..75c2769555 100644 --- a/test/afc.cpp +++ b/test/afc.cpp @@ -181,6 +181,33 @@ namespace Test { return false; throw 1; } catch (int) {} + if (s.post().afc() != 0.0) + return false; + { + Space::UseGPI use(s); + if (s.post().afc() != 1.0) + return false; + { + Space::UseGPI nested(s); + if (s.post().afc() != 1.0) + return false; + } + { + Space::NoGPI suppress(s); + if (s.post().afc() != 0.0) + return false; + } + if (s.post().afc() != 1.0) + return false; + } + if (s.post().afc() != 0.0) + return false; + try { + Space::UseGPI use(s); + if (s.post().afc() != 1.0) + return false; + throw 1; + } catch (int) {} if (s.post().afc() != 0.0) return false; (void) s.status(); @@ -271,6 +298,7 @@ namespace Test { unsigned int id = ps.propagator().id(); rel(s,s.b,IRT_EQ,1); if (local) { + Space::UseGPI context(s); (void) s.status(); } else { Space::NoGPI context(s); diff --git a/test/branch/int.cpp b/test/branch/int.cpp index 33837242ec..ab0ab575c3 100644 --- a/test/branch/int.cpp +++ b/test/branch/int.cpp @@ -36,6 +36,8 @@ #include #include +#include + namespace Test { namespace Branch { /// Space for testing filtered random tie selection @@ -131,6 +133,62 @@ namespace Test { namespace Branch { FilteredRndTies filtered_rnd_ties; +#ifdef GECODE_HAS_CBS + /// Independent permutations leave one CBS cache entry after another expires + class CBSSpace : public Gecode::Space { + public: + Gecode::IntVarArray x; + CBSSpace(bool local) : x(*this,8,0,3) { + if (local) { + NoGPI suppress(*this); + post(); + } else { + post(); + } + Gecode::cbsbranch(*this,x); + } + void post(void) { + using namespace Gecode; + distinct(*this,IntVarArgs() << x[0] << x[1] << x[2] << x[3],IPL_VAL); + distinct(*this,IntVarArgs() << x[4] << x[5] << x[6] << x[7],IPL_VAL); + } + CBSSpace(CBSSpace& s) : Space(s) { + x.update(*this,s.x); + } + virtual Space* copy(void) { + return new CBSSpace(*this); + } + }; + + /// Cache removal must preserve choices from surviving propagators + class CBS : public Base { + public: + CBS(void) : Base("Int::Branch::CBS",TestTags::check()) {} + virtual bool run(void) { + using namespace Gecode; + for (bool local : {false,true}) { + CBSSpace root(local); + Search::Options o; + o.c_d = 2; + o.a_d = 1; + DFS engine(&root,o); + int n = 0; + while (std::unique_ptr s{engine.next()}) { + for (int i=0; ix.size(); i++) + if (!s->x[i].assigned()) + return false; + n++; + } + if (n != 24*24) + return false; + } + return true; + } + }; + + CBS cbs; +#endif + /// %Test brancher with distinct propagator class Int : public IntTest { public: From c65f45fd49b1656bbd9c4f6afe94b645cd5a1fad Mon Sep 17 00:00:00 2001 From: Mikael Zayenz Lagerkvist Date: Wed, 14 Oct 2026 11:31:15 +0200 Subject: [PATCH 03/34] Place posting flag in CBS alignment padding --- gecode/kernel/core.cpp | 6 +++--- gecode/kernel/core.hpp | 4 ++-- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/gecode/kernel/core.cpp b/gecode/kernel/core.cpp index 6d5489f761..63b03c7594 100644 --- a/gecode/kernel/core.cpp +++ b/gecode/kernel/core.cpp @@ -118,7 +118,7 @@ namespace Gecode { VarImpDisposerBase* Space::vd[AllVarConf::idx_d]; #endif - Space::Space(void) : no_gpi(false), mm(ssd.data().sm) { + Space::Space(void) : mm(ssd.data().sm), no_gpi(false) { #ifdef GECODE_HAS_CBS var_id_counter = 0; #endif @@ -723,12 +723,12 @@ namespace Gecode { * */ Space::Space(Space& s) - : no_gpi(false), ssd(s.ssd), + : ssd(s.ssd), mm(ssd.data().sm,s.mm,s.pc.p.n_sub*sizeof(Propagator**)), #ifdef GECODE_HAS_CBS var_id_counter(s.var_id_counter), #endif - d_fst(&Actor::sentinel),d_cur(nullptr),d_lst(nullptr) { + no_gpi(false), d_fst(&Actor::sentinel),d_cur(nullptr),d_lst(nullptr) { #ifdef GECODE_HAS_VAR_DISPOSE for (int i=0; i Date: Thu, 15 Oct 2026 14:42:50 +0200 Subject: [PATCH 04/34] Generalize pointer unmarking and trim GPI tests --- changelog.in | 12 +++------ gecode/kernel/core.cpp | 2 +- gecode/kernel/core.hpp | 40 ++++++++++------------------ gecode/support/marked-pointer.hpp | 10 ++++--- test/afc.cpp | 43 +------------------------------ 5 files changed, 26 insertions(+), 81 deletions(-) diff --git a/changelog.in b/changelog.in index 82f35d7e4e..21287db675 100755 --- a/changelog.in +++ b/changelog.in @@ -78,21 +78,15 @@ Module: kernel What: new Rank: minor [DESCRIPTION] -Add Space::NoGPI for scoped posting without globally retained propagator -information. Scoped propagators keep their identifiers and groups in the -space, have zero AFC, and copy their information when cloned. Rewriting -preserves the original propagator information. Space::UseGPI enables global -information for selected posting calls inside a NoGPI scope. Both contexts -restore the previous setting when they leave scope. +Add Space::NoGPI and Space::UseGPI to control global propagator information +for scoped posting. NoGPI keeps information in the space with zero AFC. [ENTRY] Module: int What: bug Rank: minor [DESCRIPTION] -Fix iterator invalidation when counting-based search removes expired -propagator cache entries. The invalid iterator could skip remaining entries -and leave the brancher without a choice. +Fix iterator invalidation during counting-based search cache cleanup. [ENTRY] diff --git a/gecode/kernel/core.cpp b/gecode/kernel/core.cpp index 63b03c7594..c5ea98eb78 100644 --- a/gecode/kernel/core.cpp +++ b/gecode/kernel/core.cpp @@ -928,7 +928,7 @@ namespace Gecode { Kernel::GPI::Info* i = alloc(1); i->init(ssd.data().gpi.next_pid(),gid); i->afc = 0.0; - return Support::ptrjoin(i,2); + return Support::ptrjoin(i,0b10); } void diff --git a/gecode/kernel/core.hpp b/gecode/kernel/core.hpp index 7ad7e9abc0..ed257fdbb9 100755 --- a/gecode/kernel/core.hpp +++ b/gecode/kernel/core.hpp @@ -2052,23 +2052,15 @@ namespace Gecode { * \brief Suppress global propagator information during scoped posting * \ingroup TaskModelScript * - * New propagators posted into this space use space-local information - * instead of records retained by all spaces in a search. Their AFC is - * always zero, including after AFC initialization or unsharing. They - * retain normal identifiers and groups, so tracing and counting-based - * search remain supported. Group changes for these propagators are - * local to the space; clones copy the current group. Local records are - * reclaimed with the space, even if their propagators subsume earlier. - * AFC-based branching therefore only counts ordinary propagators. - * - * Rewriting inherits the original propagator's information, regardless - * of this context. Existing propagators are unaffected. Clones retain - * local information but start with ordinary posting enabled. - * - * A nested UseGPI context enables global information for selected - * posting calls. Both contexts restore the previous setting on destruction, - * including exception unwinding. The space must outlive the context, - * and contexts for the same space must be destroyed in reverse order. + * New propagators keep their information in the space, with normal + * identifiers and groups but zero AFC. Group changes stay local to the + * space. Clones copy this information and start with ordinary posting + * enabled. Rewriting preserves the original propagator's information. + * + * UseGPI enables global information within this scope. Both contexts + * restore the previous setting on destruction, including unwinding. + * The space must outlive them; contexts for the same space must be + * destroyed in reverse order. */ class NoGPI { private: @@ -2089,11 +2081,8 @@ namespace Gecode { * \brief Enable global propagator information during scoped posting * \ingroup TaskModelScript * - * Overrides an enclosing NoGPI context for new propagators posted into - * this space. Rewriting still inherits the original information. - * Destruction restores the previous setting, including exception - * unwinding. The space must outlive the context, and NoGPI and UseGPI - * contexts for the same space must be destroyed in reverse order. + * Overrides NoGPI for new postings and restores the previous setting + * on destruction. The lifetime and nesting rules of NoGPI also apply. */ class UseGPI { private: @@ -3678,7 +3667,7 @@ namespace Gecode { forceinline bool Propagator::local_info(void) const { - return (reinterpret_cast(gpi_disabled) & 2) != 0; + return (reinterpret_cast(gpi_disabled) & 0b10) != 0; } forceinline bool @@ -3700,8 +3689,7 @@ namespace Gecode { forceinline Kernel::GPI::Info& Propagator::gpi(void) { - return *reinterpret_cast - (reinterpret_cast(gpi_disabled) & ~static_cast(3)); + return *static_cast(Support::funmark<2>(gpi_disabled)); } forceinline @@ -3726,7 +3714,7 @@ namespace Gecode { if (p.local_info()) { Kernel::GPI::Info* i = home.alloc(1); *i = p.gpi(); - gpi_disabled = Support::ptrjoin(i, p.disabled() ? 3 : 2); + gpi_disabled = Support::ptrjoin(i, p.disabled() ? 0b11 : 0b10); } u.advisors = nullptr; assert((u.med == 0) && (u.size == 0)); diff --git a/gecode/support/marked-pointer.hpp b/gecode/support/marked-pointer.hpp index 7fa78e514a..9c0f1c117e 100644 --- a/gecode/support/marked-pointer.hpp +++ b/gecode/support/marked-pointer.hpp @@ -32,6 +32,7 @@ */ #include +#include namespace Gecode { namespace Support { @@ -43,7 +44,8 @@ namespace Gecode { namespace Support { void* unmark(void* p); /// Return marked pointer for \a p (possibly already marked) void* fmark(void* p); - /// Return unmarked pointer for a possibly marked pointer \a p + /// Clear the lowest \a bits bits of a possibly marked pointer \a p + template void* funmark(void* p); /// Split possibly marked pointer \a p into mark \a m and unmarked pointer void* ptrsplit(void* p, ptrdiff_t& m); @@ -68,10 +70,12 @@ namespace Gecode { namespace Support { fmark(void* p) { return reinterpret_cast(reinterpret_cast(p)|1); } + template forceinline void* funmark(void* p) { - return reinterpret_cast(reinterpret_cast(p)& - ~static_cast(1)); + static_assert(bits < sizeof(size_t)*CHAR_BIT, "Too many pointer tag bits"); + return reinterpret_cast(reinterpret_cast(p)& + ~((static_cast(1) << bits)-1)); } forceinline void* ptrsplit(void* p, ptrdiff_t& m) { diff --git a/test/afc.cpp b/test/afc.cpp index 75c2769555..a5441e0416 100644 --- a/test/afc.cpp +++ b/test/afc.cpp @@ -187,11 +187,6 @@ namespace Test { Space::UseGPI use(s); if (s.post().afc() != 1.0) return false; - { - Space::UseGPI nested(s); - if (s.post().afc() != 1.0) - return false; - } { Space::NoGPI suppress(s); if (s.post().afc() != 0.0) @@ -312,47 +307,11 @@ namespace Test { return (s.status() == SS_SOLVED) && s.y.assigned() && (s.y.val() == 3); } - /// Collect posting counts and propagated identifiers - class Tracer : public Gecode::Tracer { - public: - unsigned int posted = 0; - std::vector ids; - virtual void propagate(const Gecode::Space&, - const Gecode::PropagateTraceInfo& p) { - ids.push_back(p.id()); - } - virtual void commit(const Gecode::Space&, - const Gecode::CommitTraceInfo&) {} - virtual void post(const Gecode::Space&, - const Gecode::PostTraceInfo& p) { - posted += p.propagators(); - } - }; - - /// Posting traces and propagation traces must retain distinct identities - bool tracing(void) { - using namespace Gecode; - Tracer t; - TestSpace s; - PropagatorGroup g; - trace(s,g,TE_POST | TE_PROPAGATE,t); - t.posted = 0; - unsigned int a, b; - { - Space::NoGPI context(s); - a = s.post(g).id(); - b = s.post(g).id(); - } - (void) s.status(); - return (t.posted == 2) && (a != b) && - (std::find(t.ids.begin(),t.ids.end(),a) != t.ids.end()) && - (std::find(t.ids.begin(),t.ids.end(),b) != t.ids.end()); - } public: NoGPI(void) : Test::Base("AFC::NoGPI") {} virtual bool run(void) { return scopes() && lifetime() && failure(false) && failure(true) && - rewrite(false) && rewrite(true) && tracing(); + rewrite(false) && rewrite(true); } }; From b0fe5d436cf824621fafe355197598a67ead22e2 Mon Sep 17 00:00:00 2001 From: Mikael Zayenz Lagerkvist Date: Thu, 15 Oct 2026 14:50:14 +0200 Subject: [PATCH 05/34] Use uintptr_t for pointer tag removal --- gecode/support/marked-pointer.hpp | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/gecode/support/marked-pointer.hpp b/gecode/support/marked-pointer.hpp index 9c0f1c117e..f5f33751ea 100644 --- a/gecode/support/marked-pointer.hpp +++ b/gecode/support/marked-pointer.hpp @@ -33,6 +33,7 @@ #include #include +#include namespace Gecode { namespace Support { @@ -73,9 +74,10 @@ namespace Gecode { namespace Support { template forceinline void* funmark(void* p) { - static_assert(bits < sizeof(size_t)*CHAR_BIT, "Too many pointer tag bits"); - return reinterpret_cast(reinterpret_cast(p)& - ~((static_cast(1) << bits)-1)); + static_assert(bits < sizeof(std::uintptr_t)*CHAR_BIT, + "Too many pointer tag bits"); + return reinterpret_cast(reinterpret_cast(p)& + ~((static_cast(1) << bits)-1)); } forceinline void* ptrsplit(void* p, ptrdiff_t& m) { From e1ca30e97644fa57e6610cbdd2a7bf7b611069bb Mon Sep 17 00:00:00 2001 From: Mikael Zayenz Lagerkvist Date: Thu, 15 Oct 2026 14:54:03 +0200 Subject: [PATCH 06/34] Provide a fallback pointer integer type in Support --- gecode/support/marked-pointer.hpp | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-) diff --git a/gecode/support/marked-pointer.hpp b/gecode/support/marked-pointer.hpp index f5f33751ea..78e5265dfc 100644 --- a/gecode/support/marked-pointer.hpp +++ b/gecode/support/marked-pointer.hpp @@ -32,11 +32,18 @@ */ #include -#include #include +#include namespace Gecode { namespace Support { + /// Integer type for tagged pointers +#ifdef UINTPTR_MAX + using ptrint_t = std::uintptr_t; +#else + using ptrint_t = ptrdiff_t; +#endif + /// Check whether \a p is marked bool marked(void* p); /// Return marked pointer for unmarked pointer \a p @@ -74,10 +81,10 @@ namespace Gecode { namespace Support { template forceinline void* funmark(void* p) { - static_assert(bits < sizeof(std::uintptr_t)*CHAR_BIT, + static_assert(bits < std::numeric_limits::digits, "Too many pointer tag bits"); - return reinterpret_cast(reinterpret_cast(p)& - ~((static_cast(1) << bits)-1)); + return reinterpret_cast(reinterpret_cast(p)& + ~((static_cast(1) << bits)-1)); } forceinline void* ptrsplit(void* p, ptrdiff_t& m) { From 222ede3aa45df97aa154995c8bf608bd9a4f2f70 Mon Sep 17 00:00:00 2001 From: Mikael Zayenz Lagerkvist Date: Thu, 15 Oct 2026 15:12:40 +0200 Subject: [PATCH 07/34] Centralize unsigned pointer encodings in Support --- gecode/gist/node.cpp | 4 +-- gecode/gist/node.hpp | 14 ++++----- gecode/int/extensional.hh | 2 +- gecode/int/extensional/compact.hpp | 6 ++-- gecode/int/var-imp/int.hpp | 24 ++++++++-------- gecode/int/view-val-graph.hh | 2 +- gecode/int/view-val-graph/comb-ptr-flag.hpp | 16 +++++++---- gecode/kernel/core.hpp | 15 +++++----- gecode/support.hh | 2 +- gecode/support/int-type.hpp | 20 +++++++++++++ gecode/support/marked-pointer.hpp | 32 +++++++++------------ 11 files changed, 78 insertions(+), 59 deletions(-) diff --git a/gecode/gist/node.cpp b/gecode/gist/node.cpp index ff050b5c6c..99f3066745 100644 --- a/gecode/gist/node.cpp +++ b/gecode/gist/node.cpp @@ -48,7 +48,7 @@ namespace Gecode { namespace Gist { case 1: childrenOrFirstChild = reinterpret_cast( - static_cast(na.allocate(getIndex(na)) << 2)); + static_cast(na.allocate(getIndex(na))) << 2); noOfChildren = 1; setTag(TWO_CHILDREN); break; @@ -57,7 +57,7 @@ namespace Gecode { namespace Gist { int idx = getIndex(na); childrenOrFirstChild = reinterpret_cast( - static_cast(na.allocate(idx) << 2)); + static_cast(na.allocate(idx)) << 2); noOfChildren = -na.allocate(idx); setTag(TWO_CHILDREN); } diff --git a/gecode/gist/node.hpp b/gecode/gist/node.hpp index 27bdc0060c..f51b1013fe 100644 --- a/gecode/gist/node.hpp +++ b/gecode/gist/node.hpp @@ -148,27 +148,27 @@ namespace Gecode { namespace Gist { forceinline unsigned int Node::getTag(void) const { return static_cast - (reinterpret_cast(childrenOrFirstChild) & 3); + (reinterpret_cast(childrenOrFirstChild) & 0b11); } forceinline void Node::setTag(unsigned int tag) { - assert(tag <= 3); + assert(tag <= 0b11); assert(getTag() == UNDET); - childrenOrFirstChild = reinterpret_cast - ( (reinterpret_cast(childrenOrFirstChild) & ~(3)) | tag); + childrenOrFirstChild = + Support::ptrjoin(Support::funmark<2>(childrenOrFirstChild),tag); } forceinline void* Node::getPtr(void) const { - return reinterpret_cast - (reinterpret_cast(childrenOrFirstChild) & ~(3)); + return Support::funmark<2>(childrenOrFirstChild); } forceinline int Node::getFirstChild(void) const { return static_cast - ((reinterpret_cast(childrenOrFirstChild) & ~(3)) >> 2); + ((reinterpret_cast(childrenOrFirstChild) & + ~static_cast(0b11)) >> 2); } forceinline diff --git a/gecode/int/extensional.hh b/gecode/int/extensional.hh index 99ddee0577..e1de6da1c5 100755 --- a/gecode/int/extensional.hh +++ b/gecode/int/extensional.hh @@ -470,7 +470,7 @@ namespace Gecode { namespace Int { namespace Extensional { class CompactStatus { protected: /// A tagged advisor pointer or a status value - ptrdiff_t s; + Support::uptrint_t s; public: /// Type of status enum StatusType { diff --git a/gecode/int/extensional/compact.hpp b/gecode/int/extensional/compact.hpp index 1aba8ae137..503ed43737 100755 --- a/gecode/int/extensional/compact.hpp +++ b/gecode/int/extensional/compact.hpp @@ -155,7 +155,7 @@ namespace Gecode { namespace Int { namespace Extensional { template forceinline typename CompactStatus::StatusType CompactStatus::type(void) const { - return static_cast(s & 3); + return static_cast(s & 0b11); } template @@ -169,8 +169,8 @@ namespace Gecode { namespace Int { namespace Extensional { forceinline void CompactStatus::touched(Advisor& a) { if (type() == NONE) { - s = reinterpret_cast(&a); - assert((s & 3) == SINGLE); + s = reinterpret_cast(&a); + assert((s & 0b11) == SINGLE); } else if ((type() == SINGLE) && !single(a)) { s = MULTIPLE; } diff --git a/gecode/int/var-imp/int.hpp b/gecode/int/var-imp/int.hpp index dcadd00d48..5323323cc4 100644 --- a/gecode/int/var-imp/int.hpp +++ b/gecode/int/var-imp/int.hpp @@ -44,8 +44,8 @@ namespace Gecode { namespace Int { * */ -#define GECODE_INT_RL2PD(r) reinterpret_cast(r) -#define GECODE_INT_PD2RL(p) reinterpret_cast(p) +#define GECODE_INT_RL2PI(r) reinterpret_cast(r) +#define GECODE_INT_PI2RL(p) reinterpret_cast(p) forceinline unsigned int range_width(int min, int max) { @@ -63,30 +63,30 @@ namespace Gecode { namespace Int { forceinline IntVarImp::RangeList::RangeList(int min, int max, RangeList* p, RangeList* n) : _min(min), _max(max) { - _next = GECODE_INT_PD2RL(GECODE_INT_RL2PD(p)^GECODE_INT_RL2PD(n)); + _next = GECODE_INT_PI2RL(GECODE_INT_RL2PI(p)^GECODE_INT_RL2PI(n)); } forceinline IntVarImp::RangeList* IntVarImp::RangeList::next(const RangeList* p) const { - return GECODE_INT_PD2RL(GECODE_INT_RL2PD(_next)^GECODE_INT_RL2PD(p)); + return GECODE_INT_PI2RL(GECODE_INT_RL2PI(_next)^GECODE_INT_RL2PI(p)); } forceinline IntVarImp::RangeList* IntVarImp::RangeList::prev(const RangeList* n) const { - return GECODE_INT_PD2RL(GECODE_INT_RL2PD(_next)^GECODE_INT_RL2PD(n)); + return GECODE_INT_PI2RL(GECODE_INT_RL2PI(_next)^GECODE_INT_RL2PI(n)); } forceinline void IntVarImp::RangeList::prevnext(RangeList* p, RangeList* n) { - _next = GECODE_INT_PD2RL(GECODE_INT_RL2PD(p)^GECODE_INT_RL2PD(n)); + _next = GECODE_INT_PI2RL(GECODE_INT_RL2PI(p)^GECODE_INT_RL2PI(n)); } forceinline void IntVarImp::RangeList::next(RangeList* o, RangeList* n) { - _next = GECODE_INT_PD2RL(GECODE_INT_RL2PD(_next)^ - (GECODE_INT_RL2PD(o)^GECODE_INT_RL2PD(n))); + _next = GECODE_INT_PI2RL(GECODE_INT_RL2PI(_next)^ + (GECODE_INT_RL2PI(o)^GECODE_INT_RL2PI(n))); } forceinline void IntVarImp::RangeList::prev(RangeList* o, RangeList* n) { - _next = GECODE_INT_PD2RL(GECODE_INT_RL2PD(_next)^ - (GECODE_INT_RL2PD(o)^GECODE_INT_RL2PD(n))); + _next = GECODE_INT_PI2RL(GECODE_INT_RL2PI(_next)^ + (GECODE_INT_RL2PI(o)^GECODE_INT_RL2PI(n))); } forceinline void IntVarImp::RangeList::fix(RangeList* n) { @@ -159,8 +159,8 @@ namespace Gecode { namespace Int { home.fl_dispose(this,this); } -#undef GECODE_INT_RL2PD -#undef GECODE_INT_PD2RL +#undef GECODE_INT_RL2PI +#undef GECODE_INT_PI2RL /* * Mainitaining range lists for variable domain diff --git a/gecode/int/view-val-graph.hh b/gecode/int/view-val-graph.hh index 24d7c6f983..0851eae21d 100644 --- a/gecode/int/view-val-graph.hh +++ b/gecode/int/view-val-graph.hh @@ -54,7 +54,7 @@ namespace Gecode { namespace Int { namespace ViewValGraph { class CombPtrFlag { private: /// Store pointer and flag - ptrdiff_t cpf; + Support::uptrint_t cpf; public: /// Initialize with pointer \a p1 and \a p2 CombPtrFlag(T* p1, T* p2); diff --git a/gecode/int/view-val-graph/comb-ptr-flag.hpp b/gecode/int/view-val-graph/comb-ptr-flag.hpp index 022b944236..a2e3abaf0b 100644 --- a/gecode/int/view-val-graph/comb-ptr-flag.hpp +++ b/gecode/int/view-val-graph/comb-ptr-flag.hpp @@ -36,36 +36,40 @@ namespace Gecode { namespace Int { namespace ViewValGraph { template forceinline CombPtrFlag::CombPtrFlag(T* p1, T* p2) - : cpf(reinterpret_cast(p1) ^ reinterpret_cast(p2)) {} + : cpf(reinterpret_cast(p1) ^ + reinterpret_cast(p2)) {} template forceinline T* CombPtrFlag::ptr(T* p) const { - return reinterpret_cast((cpf&~1) ^ reinterpret_cast(p)); + return reinterpret_cast + ((cpf & ~static_cast(0b1)) ^ + reinterpret_cast(p)); } template forceinline int CombPtrFlag::is_set(void) const { - return static_cast(cpf&1); + return static_cast(cpf & 0b1); } template forceinline void CombPtrFlag::set(void) { - cpf |= 1; + cpf |= 0b1; } template forceinline void CombPtrFlag::unset(void) { - cpf &= ~1; + cpf &= ~static_cast(0b1); } template forceinline void CombPtrFlag::init(T* p1, T* p2) { - cpf = reinterpret_cast(p1) ^ reinterpret_cast(p2); + cpf = reinterpret_cast(p1) ^ + reinterpret_cast(p2); } }}} diff --git a/gecode/kernel/core.hpp b/gecode/kernel/core.hpp index ed257fdbb9..2f8b79326a 100755 --- a/gecode/kernel/core.hpp +++ b/gecode/kernel/core.hpp @@ -931,7 +931,7 @@ namespace Gecode { }; protected: /// Encoding a tagged pointer or a tagged group id - ptrdiff_t who; + Support::uptrint_t who; /// Record that propagator \a p is executing void propagator(Propagator& p); /// Record that brancher \a b is executing @@ -3485,15 +3485,15 @@ namespace Gecode { */ forceinline void ViewTraceInfo::propagator(Propagator& p) { - who = reinterpret_cast(&p) | PROPAGATOR; + who = reinterpret_cast(&p) | PROPAGATOR; } forceinline void ViewTraceInfo::brancher(Brancher& b) { - who = reinterpret_cast(&b) | BRANCHER; + who = reinterpret_cast(&b) | BRANCHER; } forceinline void ViewTraceInfo::post(PropagatorGroup g) { - who = (g.id() << 2) | POST; + who = (static_cast(g.id()) << 2) | POST; } forceinline void ViewTraceInfo::other(void) { @@ -3501,7 +3501,7 @@ namespace Gecode { } forceinline ViewTraceInfo::What ViewTraceInfo::what(void) const { - return static_cast(who & 3); + return static_cast(who & 0b11); } forceinline const Propagator& ViewTraceInfo::propagator(void) const { @@ -3512,7 +3512,8 @@ namespace Gecode { forceinline const Brancher& ViewTraceInfo::brancher(void) const { assert(what() == BRANCHER); - return *reinterpret_cast(who & ~3); + return *reinterpret_cast + (who & ~static_cast(0b11)); } forceinline PropagatorGroup ViewTraceInfo::post(void) const { @@ -3667,7 +3668,7 @@ namespace Gecode { forceinline bool Propagator::local_info(void) const { - return (reinterpret_cast(gpi_disabled) & 0b10) != 0; + return (reinterpret_cast(gpi_disabled) & 0b10) != 0; } forceinline bool diff --git a/gecode/support.hh b/gecode/support.hh index 79f4894608..63d1b46c54 100644 --- a/gecode/support.hh +++ b/gecode/support.hh @@ -99,8 +99,8 @@ #include #include #include -#include #include +#include /* * Common datastructures and algorithms diff --git a/gecode/support/int-type.hpp b/gecode/support/int-type.hpp index 2a089b3c27..f9c47c3822 100644 --- a/gecode/support/int-type.hpp +++ b/gecode/support/int-type.hpp @@ -32,9 +32,29 @@ */ #include +#include +#include +#include +#include namespace Gecode { namespace Support { + /** + * \brief Unsigned integer for pointer encodings + * + * Prefer uintptr_t for pointer round trips. If unavailable, use the + * unsigned counterpart of ptrdiff_t and require room for every pointer + * bit. Unsigned arithmetic keeps tag masks and shifts well-defined. + * Tagging assumes alignment leaves the low pointer bits unused. + */ +#ifdef UINTPTR_MAX + using uptrint_t = std::uintptr_t; +#else + using uptrint_t = std::make_unsigned_t; + static_assert(std::numeric_limits::digits >= sizeof(void*)*CHAR_BIT, + "Pointer encoding requires a pointer-wide integer"); +#endif + /// Description of integer types enum IntType { IT_CHAR = 0, ///< char integer type diff --git a/gecode/support/marked-pointer.hpp b/gecode/support/marked-pointer.hpp index 78e5265dfc..08b73cedde 100644 --- a/gecode/support/marked-pointer.hpp +++ b/gecode/support/marked-pointer.hpp @@ -32,18 +32,10 @@ */ #include -#include #include namespace Gecode { namespace Support { - /// Integer type for tagged pointers -#ifdef UINTPTR_MAX - using ptrint_t = std::uintptr_t; -#else - using ptrint_t = ptrdiff_t; -#endif - /// Check whether \a p is marked bool marked(void* p); /// Return marked pointer for unmarked pointer \a p @@ -62,39 +54,41 @@ namespace Gecode { namespace Support { forceinline bool marked(void* p) { - return (reinterpret_cast(p) & 1) != 0; + return (reinterpret_cast(p) & 0b1) != 0; } forceinline void* mark(void* p) { assert(!marked(p)); - return reinterpret_cast(reinterpret_cast(p)+1); + return reinterpret_cast(reinterpret_cast(p) | 0b1); } forceinline void* unmark(void* p) { assert(marked(p)); - return reinterpret_cast(reinterpret_cast(p)-1); + return funmark(p); } forceinline void* fmark(void* p) { - return reinterpret_cast(reinterpret_cast(p)|1); + return reinterpret_cast(reinterpret_cast(p) | 0b1); } template forceinline void* funmark(void* p) { - static_assert(bits < std::numeric_limits::digits, + static_assert(bits < std::numeric_limits::digits, "Too many pointer tag bits"); - return reinterpret_cast(reinterpret_cast(p)& - ~((static_cast(1) << bits)-1)); + return reinterpret_cast(reinterpret_cast(p)& + ~((static_cast(1) << bits)-1)); } forceinline void* ptrsplit(void* p, ptrdiff_t& m) { - ptrdiff_t mp = reinterpret_cast(p); - m = mp & 1; - return reinterpret_cast(mp & ~static_cast(1)); + uptrint_t mp = reinterpret_cast(p); + m = static_cast(mp & 0b1); + return funmark(p); } forceinline void* ptrjoin(void* p, ptrdiff_t m) { - return reinterpret_cast(reinterpret_cast(p) | m); + assert((reinterpret_cast(p) & static_cast(m)) == 0); + return reinterpret_cast(reinterpret_cast(p) | + static_cast(m)); } }} From 0c89572a076cbab085c748329d3917bb531fbe40 Mon Sep 17 00:00:00 2001 From: Mikael Zayenz Lagerkvist Date: Sat, 22 Aug 2026 15:09:15 +0200 Subject: [PATCH 08/34] Add open integer variable sequences --- Makefile.in | 6 +- cmake/GecodeSources.cmake | 3 + gecode/int.hh | 232 ++++++++ gecode/int/extensional-open-regular.cpp | 577 +++++++++++++++++++ gecode/int/open-sequence.cpp | 704 ++++++++++++++++++++++++ test/int/extensional.cpp | 336 +++++++++++ test/int/open-sequence.cpp | 522 ++++++++++++++++++ 7 files changed, 2378 insertions(+), 2 deletions(-) create mode 100644 gecode/int/extensional-open-regular.cpp create mode 100644 gecode/int/open-sequence.cpp create mode 100644 test/int/open-sequence.cpp diff --git a/Makefile.in b/Makefile.in index 8e5d2c625d..0a9e87a49d 100755 --- a/Makefile.in +++ b/Makefile.in @@ -323,7 +323,9 @@ INTSRC0 = \ int-set.cpp var-imp/int.cpp var-imp/bool.cpp var/int.cpp \ var/bool.cpp array.cpp bool.cpp bool/eqv.cpp \ extensional/dfa.cpp extensional/tuple-set.cpp \ - extensional-regular.cpp extensional-tuple-set.cpp \ + extensional-regular.cpp extensional-open-regular.cpp \ + extensional-tuple-set.cpp \ + open-sequence.cpp \ dom.cpp rel.cpp precede.cpp element.cpp count.cpp \ arithmetic.cpp exec.cpp \ exec/when.cpp element/pair.cpp \ @@ -1119,7 +1121,7 @@ EXETARGETS = $(FLATZINCEXE) $(FLATZINCLAUNCHER) INTTESTSRC00 = \ channel arithmetic basic bool count dom distinct element extensional \ - rel linear gcc sorted unshare exec sequence \ + rel linear gcc sorted unshare exec sequence open-sequence \ mm-arithmetic mm-bool mm-lin mm-count mm-rel \ bin-packing order unary cumulative cumulatives circuit \ no-overlap precede inter-distance nvalues member min-distance diff --git a/cmake/GecodeSources.cmake b/cmake/GecodeSources.cmake index 58a415eb36..2b3df973ad 100644 --- a/cmake/GecodeSources.cmake +++ b/cmake/GecodeSources.cmake @@ -83,7 +83,9 @@ set(GECODE_INT_SOURCES gecode/int/exec.cpp gecode/int/exec/when.cpp gecode/int/extensional-regular.cpp + gecode/int/extensional-open-regular.cpp gecode/int/extensional-tuple-set.cpp + gecode/int/open-sequence.cpp gecode/int/extensional/dfa.cpp gecode/int/extensional/tuple-set.cpp gecode/int/gcc.cpp @@ -428,6 +430,7 @@ set(GECODE_TEST_SOURCES test/int/no-overlap.cpp test/int/nvalues.cpp test/int/order.cpp + test/int/open-sequence.cpp test/int/precede.cpp test/int/rel.cpp test/int/sequence.cpp diff --git a/gecode/int.hh b/gecode/int.hh index 04bfb99d70..71472609d1 100755 --- a/gecode/int.hh +++ b/gecode/int.hh @@ -2424,6 +2424,194 @@ namespace Gecode { std::size_t hash(void) const; }; + namespace Int { + class OpenSequence; + class OpenSequencePropagator; + namespace Extensional { + class OpenRegular; + } + } + + /** + * \brief Space-local sequence of integer variables with an open length + * + * Variables can be appended until the sequence is closed. The length + * variable denotes the eventual sequence length. + * + * \ingroup TaskModelInt + */ + class OpenIntVarSequence : public LocalHandle { + private: + /// Space-local sequence implementation + class Sequence; + /// Return the materialized-length variable + IntVar materialized(void) const; + friend class Int::OpenSequence; + friend class Int::OpenSequencePropagator; + friend class Int::Extensional::OpenRegular; + friend void extensional(Home, OpenIntVarSequence, DFA, IntPropLevel); + public: + /** + * \brief Function returning the domain for position \a i + * + * The function must be deterministic so that recomputation creates + * the same variables. + */ + typedef std::function Domain; + /** + * \brief Function called after materializing position \a i + * + * The function object is shared between clones. It must be + * deterministic and must not capture space-local data; \a home and + * \a x refer to the current space. + */ + typedef std::function + Transition; + /// Construct an uninitialized sequence + GECODE_INT_EXPORT + OpenIntVarSequence(void); + /// Construct a sequence with maximal length \a max and full domains + GECODE_INT_EXPORT + OpenIntVarSequence(Space& home, int max=Int::Limits::max); + /// Construct a sequence using domain \a d for every position + GECODE_INT_EXPORT + OpenIntVarSequence(Space& home, const IntSet& d, + int max=Int::Limits::max); + /// Construct a sequence using domain \a d and transition function \a t + GECODE_INT_EXPORT + OpenIntVarSequence(Space& home, const IntSet& d, Transition t, + int max=Int::Limits::max); + /// Construct a sequence using \a d to create each position + GECODE_INT_EXPORT + OpenIntVarSequence(Space& home, Domain d, + int max=Int::Limits::max); + /// Construct a sequence using \a d and transition function \a t + GECODE_INT_EXPORT + OpenIntVarSequence(Space& home, Domain d, Transition t, + int max=Int::Limits::max); + /// Update during cloning + GECODE_INT_EXPORT + void update(Space& home, OpenIntVarSequence& s); + /// Return the number of appended variables + GECODE_INT_EXPORT int size(void) const; + /// Return variable at position \a i (\a i must be a valid position) + GECODE_INT_EXPORT IntVar operator [](int i) const; + /// Return the eventual-length variable + GECODE_INT_EXPORT IntVar length(void) const; + /** + * \brief Append variable \a x + * + * Throws an exception of type Int::ArgumentSame if \a x is an + * unassigned variable already in the sequence. + */ + GECODE_INT_EXPORT void append(Space& home, IntVar x); + /** + * \brief Materialize the first \a n variables + * + * The eventual length is constrained to be at least \a n. + */ + GECODE_INT_EXPORT void materialize(Space& home, int n); + /// Return position \a i, materializing positions through \a i + GECODE_INT_EXPORT IntVar get(Space& home, int i); + /// Close the sequence at its current length + GECODE_INT_EXPORT void close(Space& home); + }; + +} + +namespace Gecode { + + /** + * \brief Constrain all materialized variables in \a x to be distinct + * + * The constraint is value consistent and applies to variables added + * after posting. + * + * \ingroup TaskModelIntDistinct + */ + GECODE_INT_EXPORT void + distinct(Home home, OpenIntVarSequence x, + IntPropLevel ipl=IPL_DEF); + + /** + * \brief Constrain consecutive materialized variables in \a x by \a irt + * + * The constraint applies to variables added after posting. + * + * \ingroup TaskModelIntRel + */ + GECODE_INT_EXPORT void + rel(Home home, OpenIntVarSequence x, IntRelType irt, + IntPropLevel ipl=IPL_DEF); + + /** + * \brief Post a sliding sequence constraint on \a x + * + * Each complete window of size \a q, including windows completed after + * posting, contains between \a l and \a u values from \a s. + * + * \ingroup TaskModelIntSequence + */ + GECODE_INT_EXPORT void + sequence(Home home, OpenIntVarSequence x, const IntSet& s, + int q, int l, int u, IntPropLevel ipl=IPL_DEF); + + /** + * \brief Constrain the sum of every complete window in \a x + * + * Each complete window of size \a q, including windows completed after + * posting, has a sum between \a l and \a u. + * + * \ingroup TaskModelIntSequence + */ + GECODE_INT_EXPORT void + slidingsum(Home home, OpenIntVarSequence x, + int q, int l, int u, IntPropLevel ipl=IPL_DEF); + + /** + * \brief Constrain \a y to the minimum of the eventual sequence \a x + * + * The eventual sequence must be nonempty. + * + * \ingroup TaskModelIntArith + */ + GECODE_INT_EXPORT void + min(Home home, OpenIntVarSequence x, IntVar y, + IntPropLevel ipl=IPL_DEF); + + /** + * \brief Constrain \a y to the maximum of the eventual sequence \a x + * + * The eventual sequence must be nonempty. + * + * \ingroup TaskModelIntArith + */ + GECODE_INT_EXPORT void + max(Home home, OpenIntVarSequence x, IntVar y, + IntPropLevel ipl=IPL_DEF); + + /** + * \brief Constrain \a s to precede \a t in the eventual sequence \a x + * + * The constraint applies to variables added after posting. + * + * \ingroup TaskModelIntPrecede + */ + GECODE_INT_EXPORT void + precede(Home home, OpenIntVarSequence x, int s, int t, + IntPropLevel ipl=IPL_DEF); + + /** + * \brief Constrain successive values in \a c to precede each other in \a x + * + * The constraint applies to variables added after posting. + * + * \ingroup TaskModelIntPrecede + */ + GECODE_INT_EXPORT void + precede(Home home, OpenIntVarSequence x, const IntArgs& c, + IntPropLevel ipl=IPL_DEF); + } #include @@ -2841,6 +3029,19 @@ namespace Gecode { extensional(Home home, const BoolVarArgs& x, DFA d, IntPropLevel ipl=IPL_DEF); + /** + * \brief Post an open regular-language constraint + * + * While \a x is open, its materialized prefix must have a continuation + * accepted by \a d. Once its length equals its materialized size, the + * complete sequence must be accepted by \a d. + * + * \ingroup TaskModelIntExt + */ + GECODE_INT_EXPORT void + extensional(Home home, OpenIntVarSequence x, DFA d, + IntPropLevel ipl=IPL_DEF); + /** \brief Post propagator for \f$x\in t\f$. * * \li Supports domain consistency (\a ipl = IPL_DOM, default) only. @@ -4872,6 +5073,15 @@ namespace Gecode { * \ingroup TaskModelInt */ + /** + * \brief Branching order for an open sequence + * \ingroup TaskModelIntBranch + */ + enum OpenIntBranch { + OIB_HORIZON_FIRST, ///< Select the horizon before sequence values + OIB_VALUE_FIRST ///< Select materialized values before the horizon + }; + /** * \brief Branch filter function type for integer variables * @@ -5810,6 +6020,28 @@ namespace Gecode { GECODE_INT_EXPORT void branch(Home home, IntVar x, IntValBranch vals, IntVarValPrint vvp=nullptr); + /** + * \brief Branch over the eventual sequence \a x + * + * The brancher first branches between closing the sequence and adding + * one variable. Once the sequence is closed, it selects the first + * unassigned materialized variable. + * + * \ingroup TaskModelIntBranch + */ + GECODE_INT_EXPORT void + branch(Home home, OpenIntVarSequence x); + /** + * \brief Branch over the eventual sequence \a x using order \a o + * + * \a OIB_HORIZON_FIRST selects the horizon before sequence values. + * \a OIB_VALUE_FIRST selects materialized values before deciding + * whether to close or extend the sequence. + * + * \ingroup TaskModelIntBranch + */ + GECODE_INT_EXPORT void + branch(Home home, OpenIntVarSequence x, OpenIntBranch o); /** * \brief Branch over \a x with variable selection \a vars and value selection \a vals * diff --git a/gecode/int/extensional-open-regular.cpp b/gecode/int/extensional-open-regular.cpp new file mode 100644 index 0000000000..f3e2481829 --- /dev/null +++ b/gecode/int/extensional-open-regular.cpp @@ -0,0 +1,577 @@ +/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */ +/* + * Main authors: + * Mikael Zayenz Lagerkvist + * + * Copyright: + * Mikael Zayenz Lagerkvist, 2026 + * + * This file is part of Gecode, the generic constraint + * development environment: + * http://www.gecode.dev + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + */ + +#include + +#include + +namespace Gecode { + + class OpenIntVarSequence::Sequence : public LocalObject { + public: + class Factory { + public: + Domain domain; + Transition transition; + + Factory(Domain domain0, Transition transition0) + : domain(domain0), transition(transition0) {} + }; + + IntVar length; + IntVar materialized; + IntVar* x; + int n; + int capacity; + SharedData factory; + + static int + maximum(int max) { + Int::Limits::check(max,"OpenIntVarSequence"); + if (max < 0) + throw Int::VariableEmptyDomain("OpenIntVarSequence"); + return max; + } + + static Domain + valid(Domain d) { + if (!d) + throw InvalidFunction("OpenIntVarSequence"); + return d; + } + + static Transition + valid(Transition t) { + if (!t) + throw InvalidFunction("OpenIntVarSequence"); + return t; + } + + Sequence(Home home, Domain d, int max) + : LocalObject(home), + length(home,0,maximum(max)), + materialized(home,0,max), + x(nullptr), n(0), capacity(0), + factory(Factory(valid(d),Transition())) {} + + Sequence(Home home, Domain d, Transition t, int max) + : LocalObject(home), + length(home,0,maximum(max)), + materialized(home,0,max), + x(nullptr), n(0), capacity(0), + factory(Factory(valid(d),valid(t))) {} + + Sequence(Space& home, Sequence& s) + : LocalObject(home,s), x(nullptr), n(s.n), capacity(s.n), + factory(s.factory) { + length.update(home,s.length); + materialized.update(home,s.materialized); + if (capacity > 0) { + x = heap.alloc(capacity); + for (int i=0; i 0) + heap.free(x,capacity); + factory.~SharedData(); + return sizeof(*this); + } + + void + reserve(void) { + if (n == capacity) { + int next = (capacity < 4) ? 4 : capacity + capacity / 2; + x = heap.realloc(x,capacity,next); + capacity = next; + } + } + + void + append(IntVar y) { + x[n++] = y; + } + }; + +} + +namespace Gecode { namespace Int { + + class OpenSequence : public Propagator { + protected: + OpenIntVarSequence sequence; + IntView length; + + OpenSequence(Home home, OpenIntVarSequence sequence0) + : Propagator(home), sequence(sequence0), length(sequence0.length()) { + length.subscribe(home,*this,PC_INT_BND); + } + + OpenSequence(Space& home, OpenSequence& p) + : Propagator(home,p) { + sequence.update(home,p.sequence); + length.update(home,p.length); + } + + public: + virtual Actor* + copy(Space& home) { + return new (home) OpenSequence(home,*this); + } + + virtual PropCost + cost(const Space&, const ModEventDelta&) const { + const int n = length.min()-sequence.size(); + return (n <= 1) ? PropCost::unary(PropCost::LO) : + PropCost::linear(PropCost::LO,n); + } + + virtual void + reschedule(Space& home) { + length.reschedule(home,*this,PC_INT_BND); + } + + virtual ExecStatus + propagate(Space& home, const ModEventDelta&) { + sequence.materialize(home,length.min()); + if (home.failed()) + return ES_FAILED; + if (length.assigned()) + return home.ES_SUBSUMED(*this); + return ES_FIX; + } + + virtual size_t + dispose(Space& home) { + length.cancel(home,*this,PC_INT_BND); + sequence.~OpenIntVarSequence(); + (void) Propagator::dispose(home); + return sizeof(*this); + } + + static void + post(Home home, OpenIntVarSequence sequence) { + if (!sequence.length().assigned()) + (void) new (home) OpenSequence(home,sequence); + } + }; + +}} + +namespace Gecode { + + OpenIntVarSequence::OpenIntVarSequence(void) {} + + OpenIntVarSequence::OpenIntVarSequence(Space& home, int max) + : OpenIntVarSequence(home, + IntSet(Int::Limits::min,Int::Limits::max),max) {} + + OpenIntVarSequence::OpenIntVarSequence(Space& home, const IntSet& d, + int max) + : OpenIntVarSequence(home,[d](int) { return d; },max) {} + + OpenIntVarSequence::OpenIntVarSequence(Space& home, const IntSet& d, + Transition t, int max) + : OpenIntVarSequence(home,[d](int) { return d; },t,max) {} + + OpenIntVarSequence::OpenIntVarSequence(Space& home, Domain d, int max) + : LocalHandle(new (home) Sequence(home,d,max)) { + Int::OpenSequence::post(home,*this); + } + + OpenIntVarSequence::OpenIntVarSequence(Space& home, Domain d, + Transition t, int max) + : LocalHandle(new (home) Sequence(home,d,t,max)) { + Int::OpenSequence::post(home,*this); + } + + void + OpenIntVarSequence::update(Space& home, OpenIntVarSequence& s) { + LocalHandle::update(home,s); + } + + int + OpenIntVarSequence::size(void) const { + return static_cast(object())->n; + } + + IntVar + OpenIntVarSequence::operator [](int i) const { + Sequence* s = static_cast(object()); + assert((i >= 0) && (i < s->n)); + return s->x[i]; + } + + IntVar + OpenIntVarSequence::length(void) const { + return static_cast(object())->length; + } + + IntVar + OpenIntVarSequence::materialized(void) const { + return static_cast(object())->materialized; + } + + void + OpenIntVarSequence::append(Space& home, IntVar y) { + if (home.failed()) + return; + Sequence* s = static_cast(object()); + if (s->n == Int::Limits::max) { + home.fail(); + return; + } + for (int i=0; in; i++) + if (!y.assigned() && !s->x[i].assigned() && + (y.varimp() == s->x[i].varimp())) + throw Int::ArgumentSame("OpenIntVarSequence::append"); + s->reserve(); + const int next = s->n + 1; + Int::IntView l(s->length); + Int::IntView m(s->materialized); + if (me_failed(l.gq(home,next)) || me_failed(m.gq(home,next))) { + home.fail(); + return; + } + s->append(y); + const Transition& transition = s->factory().transition; + if (transition) { + GECODE_VALID_FUNCTION(transition); + transition(home,*this,next-1); + } + } + + void + OpenIntVarSequence::materialize(Space& home, int n) { + if (home.failed()) + return; + Int::Limits::nonnegative(n,"OpenIntVarSequence::materialize"); + Sequence* s = static_cast(object()); + Int::IntView l(s->length); + if (me_failed(l.gq(home,n))) { + home.fail(); + return; + } + while (s->n < n) { + const int i = s->n; + GECODE_VALID_FUNCTION(s->factory().domain); + IntVar y(home,s->factory().domain(i)); + append(home,y); + if (home.failed()) + return; + } + } + + IntVar + OpenIntVarSequence::get(Space& home, int i) { + Int::Limits::nonnegative(i,"OpenIntVarSequence::get"); + if (home.failed()) + return IntVar(); + Sequence* s = static_cast(object()); + if (i >= s->length.max()) + throw Int::OutOfLimits("OpenIntVarSequence::get"); + materialize(home,i+1); + return static_cast(object())->x[i]; + } + + void + OpenIntVarSequence::close(Space& home) { + if (home.failed()) + return; + materialize(home,length().min()); + if (home.failed()) + return; + Sequence* s = static_cast(object()); + if (me_failed(Int::IntView(s->length).eq(home,s->n))) + home.fail(); + } + +} + +namespace Gecode { namespace Int { namespace Extensional { + + class OpenRegular : public Propagator { + protected: + OpenIntVarSequence sequence; + IntView length; + IntView materialized; + DFA dfa; + unsigned char* start; + int offset; + int subscribed; + + OpenRegular(Home home, OpenIntVarSequence sequence0, DFA dfa0) + : Propagator(home), sequence(sequence0), + length(sequence0.length()), + materialized(sequence0.materialized()), dfa(dfa0), + start(static_cast(home).alloc(dfa.n_states())), + offset(0), subscribed(sequence0.size()) { + for (int i=0; i(p.dfa.n_states())), + offset(p.offset), subscribed(p.subscribed) { + sequence.update(home,p.sequence); + length.update(home,p.length); + materialized.update(home,p.materialized); + for (int i=0; i= dfa.final_fst()) && (state < dfa.final_lst()); + } + + bool + viable(void) const { + return (dfa.final_fst() < dfa.final_lst()) || + ((dfa.final_fst() == 0) && (dfa.final_lst() == 0)); + } + + bool + tail(const unsigned char* reachable, bool closed) const { + if (closed) { + for (int i=0; i(n+1) * + static_cast(k); + if (cells > + static_cast + ((std::numeric_limits::max)())) + throw OutOfLimits("Int::extensional"); + + Region r; + unsigned char* backward = + r.alloc(static_cast(cells)); + for (size_t i=0; i(cells); i++) + backward[i] = 0; + + unsigned char* last = backward + static_cast(n)*k; + if (closed) { + for (int s=0; s(i)*k; + unsigned char* out = in+k; + IntView x(sequence[offset+i]); + for (ViewValues v(x); v(); ++v) + for (DFA::Transitions t(dfa,v.val()); t(); ++t) + if (out[t.o_state()] != 0) + in[t.i_state()] = 1; + } + + bool any = false; + for (int s=0; s(k); + unsigned char* next = r.alloc(k); + for (int s=0; s(dfa.n_symbols()); + int n_supported = 0; + unsigned char* out = backward + static_cast(i+1)*k; + for (ViewValues v(x); v(); ++v) { + bool support = false; + for (DFA::Transitions t(dfa,v.val()); t() && !support; ++t) + support = (reachable[t.i_state()] != 0) && + (out[t.o_state()] != 0); + if (support) + supported[n_supported++] = v.val(); + } + if (n_supported == 0) + return ES_FAILED; + Iter::Values::Array v(supported,n_supported); + GECODE_ME_CHECK(x.narrow_v(home,v,false)); + + for (int s=0; s value(x); value(); ++value) + for (DFA::Transitions t(dfa,value.val()); t(); ++t) + if ((reachable[t.i_state()] != 0) && + (out[t.o_state()] != 0)) + next[t.o_state()] = 1; + unsigned char* swap = reachable; + reachable = next; + next = swap; + } + + int consumed = 0; + while ((consumed < n) && sequence[offset+consumed].assigned()) { + unsigned char* live = + backward + static_cast(consumed+1)*k; + unsigned char* next = r.alloc(k); + for (int s=0; s + * + * Copyright: + * Mikael Zayenz Lagerkvist, 2026 + * + * This file is part of Gecode, the generic constraint + * development environment: + * http://www.gecode.dev + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + */ + +#include + +namespace Gecode { namespace Int { + + class OpenSequencePropagator : public Propagator { + protected: + OpenIntVarSequence sequence; + IntView length; + IntView materialized; + int posted; + + OpenSequencePropagator(Home home, OpenIntVarSequence sequence0) + : Propagator(home), sequence(sequence0), + length(sequence0.length()), + materialized(sequence0.materialized()), posted(0) { + length.subscribe(home,*this,PC_INT_BND); + materialized.subscribe(home,*this,PC_INT_BND); + } + + OpenSequencePropagator(Space& home, OpenSequencePropagator& p) + : Propagator(home,p), posted(p.posted) { + sequence.update(home,p.sequence); + length.update(home,p.length); + materialized.update(home,p.materialized); + } + + bool + closed(void) const { + return length.max() == sequence.size(); + } + + void + dispose_base(Space& home) { + length.cancel(home,*this,PC_INT_BND); + materialized.cancel(home,*this,PC_INT_BND); + sequence.~OpenIntVarSequence(); + (void) Propagator::dispose(home); + } + + public: + virtual PropCost + cost(const Space&, const ModEventDelta&) const { + return PropCost::linear(PropCost::LO,sequence.size()-posted); + } + + virtual void + reschedule(Space& home) { + length.reschedule(home,*this,PC_INT_BND); + materialized.reschedule(home,*this,PC_INT_BND); + } + }; + + + class OpenDistinct : public OpenSequencePropagator { + protected: + OpenDistinct(Home home, OpenIntVarSequence sequence) + : OpenSequencePropagator(home,sequence) {} + + OpenDistinct(Space& home, OpenDistinct& p) + : OpenSequencePropagator(home,p) {} + + public: + virtual PropCost + cost(const Space&, const ModEventDelta&) const { + return PropCost::linear(PropCost::LO,sequence.size()); + } + + virtual Actor* + copy(Space& home) { + return new (home) OpenDistinct(home,*this); + } + + virtual ExecStatus + propagate(Space& home, const ModEventDelta&) { + const int size = sequence.size(); + for (int i=posted; i(size); + int n = 0; + for (int i=0; i 1) { + std::sort(values,values+n); + for (int i=1; i + class OpenMinMax : public OpenSequencePropagator { + protected: + IntView result; + IntPropLevel ipl; + + OpenMinMax(Home home, OpenIntVarSequence sequence, + IntView result0, IntPropLevel ipl0) + : OpenSequencePropagator(home,sequence), + result(result0), ipl(ipl0) {} + + OpenMinMax(Space& home, OpenMinMax& p) + : OpenSequencePropagator(home,p), ipl(p.ipl) { + result.update(home,p.result); + } + + public: + virtual Actor* + copy(Space& home) { + return new (home) OpenMinMax(home,*this); + } + + virtual ExecStatus + propagate(Space& home, const ModEventDelta&) { + const int size = sequence.size(); + for (int i=posted; i 0) + seen.update(home,p.seen); + } + + public: + virtual Actor* + copy(Space& home) { + return new (home) OpenPrecede(home,*this); + } + + virtual ExecStatus + propagate(Space& home, const ModEventDelta&) { + if ((posted > 0) && seen.one()) + return home.ES_SUBSUMED(*this); + const int size = sequence.size(); + for (int i=posted; i + class OpenSequenceBrancher : public Brancher { + protected: + class Description : public Choice { + public: + enum Kind { + VALUE, + HORIZON + }; + + const Kind kind; + const int position; + const int value; + + Description(const Brancher& b, Kind kind0, int position0, int value0) + : Choice(b,2), kind(kind0), + position(position0), value(value0) {} + + virtual void + archive(Archive& e) const { + Choice::archive(e); + e << static_cast(kind) << position << value; + } + }; + + OpenIntVarSequence sequence; + + OpenSequenceBrancher(Home home, OpenIntVarSequence sequence0) + : Brancher(home), sequence(sequence0) {} + + OpenSequenceBrancher(Space& home, OpenSequenceBrancher& b) + : Brancher(home,b) { + sequence.update(home,b.sequence); + } + + public: + virtual bool + status(const Space&) const { + if (horizon_first && + (sequence.length().max() > sequence.size())) + return true; + for (int i=0; i sequence.size(); + } + + virtual const Choice* + choice(Space&) { + if (horizon_first && + (sequence.length().max() > sequence.size())) + return new Description(*this,Description::HORIZON, + sequence.size(),0); + for (int i=0; i sequence.size()); + return new Description(*this,Description::HORIZON, + sequence.size(),0); + } + + virtual const Choice* + choice(const Space&, Archive& e) { + unsigned int kind; + int position, value; + e >> kind >> position >> value; + return new Description(*this, + static_cast(kind), + position,value); + } + + virtual ExecStatus + commit(Space& home, const Choice& choice0, unsigned int alternative) { + const Description& choice = + static_cast(choice0); + if (choice.kind == Description::VALUE) { + IntView x(sequence.get(home,choice.position)); + ModEvent me = (alternative == 0) + ? x.eq(home,choice.value) + : x.nq(home,choice.value); + return me_failed(me) ? ES_FAILED : ES_OK; + } + if (alternative == 0) { + IntView length(sequence.length()); + return me_failed(length.eq(home,choice.position)) + ? ES_FAILED : ES_OK; + } + sequence.materialize(home,choice.position+1); + return home.failed() ? ES_FAILED : ES_OK; + } + + virtual void + print(const Space&, const Choice& choice0, unsigned int alternative, + std::ostream& o) const { + const Description& choice = + static_cast(choice0); + if (choice.kind == Description::VALUE) { + o << "sequence[" << choice.position << "] " + << ((alternative == 0) ? "=" : "!=") << " " << choice.value; + } else if (alternative == 0) { + o << "sequence length = " << choice.position; + } else { + o << "sequence length > " << choice.position; + } + } + + virtual Actor* + copy(Space& home) { + return new (home) OpenSequenceBrancher(home,*this); + } + + virtual size_t + dispose(Space& home) { + sequence.~OpenIntVarSequence(); + (void) Brancher::dispose(home); + return sizeof(*this); + } + + static void + post(Home home, OpenIntVarSequence sequence) { + (void) new (home) OpenSequenceBrancher(home,sequence); + } + }; + +}} + +namespace Gecode { + + void + distinct(Home home, OpenIntVarSequence sequence, IntPropLevel) { + GECODE_POST; + Int::OpenDistinct::post(home,sequence); + } + + void + rel(Home home, OpenIntVarSequence sequence, + IntRelType irt, IntPropLevel ipl) { + switch (irt) { + case IRT_EQ: + case IRT_NQ: + case IRT_LQ: + case IRT_LE: + case IRT_GQ: + case IRT_GR: + break; + default: + throw Int::UnknownRelation("Int::rel"); + } + GECODE_POST; + Int::OpenRel::post(home,sequence,irt,ipl); + } + + void + sequence(Home home, OpenIntVarSequence x, const IntSet& values, + int width, int lower, int upper, IntPropLevel ipl) { + Int::Limits::check(values.min(),"Int::sequence"); + Int::Limits::check(values.max(),"Int::sequence"); + Int::Limits::check(width,"Int::sequence"); + Int::Limits::check(lower,"Int::sequence"); + Int::Limits::check(upper,"Int::sequence"); + if (width < 1) + throw Int::OutOfLimits("Int::sequence"); + GECODE_POST; + lower = std::max(0,lower); + upper = std::min(width,upper); + if (upper < lower) { + home.fail(); + return; + } + if ((lower == 0) && (upper == width)) + return; + Int::OpenSliding::post(home,x,values,width,lower,upper,ipl); + } + + void + slidingsum(Home home, OpenIntVarSequence sequence, + int width, int lower, int upper, IntPropLevel ipl) { + Int::Limits::check(width,"Int::slidingsum"); + Int::Limits::check(lower,"Int::slidingsum"); + Int::Limits::check(upper,"Int::slidingsum"); + if (width < 1) + throw Int::OutOfLimits("Int::slidingsum"); + GECODE_POST; + if (upper < lower) { + home.fail(); + return; + } + Int::OpenSlidingSum::post(home,sequence,width,lower,upper,ipl); + } + + void + min(Home home, OpenIntVarSequence sequence, + IntVar result, IntPropLevel ipl) { + GECODE_POST; + Int::OpenMinMax::post(home,sequence,Int::IntView(result),ipl); + } + + void + max(Home home, OpenIntVarSequence sequence, + IntVar result, IntPropLevel ipl) { + GECODE_POST; + Int::OpenMinMax::post(home,sequence,Int::IntView(result),ipl); + } + + void + precede(Home home, OpenIntVarSequence sequence, + int before, int after, IntPropLevel) { + Int::Limits::check(before,"Int::precede"); + Int::Limits::check(after,"Int::precede"); + GECODE_POST; + Int::OpenPrecede::post(home,sequence,before,after); + } + + void + precede(Home home, OpenIntVarSequence sequence, + const IntArgs& values, IntPropLevel ipl) { + if (values.size() < 2) + return; + for (int i=values.size(); i--; ) + Int::Limits::check(values[i],"Int::precede"); + GECODE_POST; + for (int i=values.size()-1; i--; ) + Int::OpenPrecede::post(home,sequence,values[i],values[i+1]); + (void) ipl; + } + + void + branch(Home home, OpenIntVarSequence sequence) { + branch(home,sequence,OIB_HORIZON_FIRST); + } + + void + branch(Home home, OpenIntVarSequence sequence, OpenIntBranch order) { + GECODE_POST; + switch (order) { + case OIB_HORIZON_FIRST: + Int::OpenSequenceBrancher::post(home,sequence); + break; + case OIB_VALUE_FIRST: + Int::OpenSequenceBrancher::post(home,sequence); + break; + default: + throw Int::UnknownBranching("Int::branch"); + } + } + +} + +// STATISTICS: int-prop diff --git a/test/int/extensional.cpp b/test/int/extensional.cpp index be05c3b53b..ad014b0cf3 100755 --- a/test/int/extensional.cpp +++ b/test/int/extensional.cpp @@ -802,6 +802,334 @@ namespace Test { namespace Int { } }; + /// Space used by open regular tests + class OpenRegularSpace : public Gecode::Space { + public: + Gecode::IntVarArray x; + Gecode::OpenIntVarSequence sequence; + + OpenRegularSpace(Gecode::DFA d, int max=8) + : x(*this,3,0,2), sequence(*this,max) { + Gecode::extensional(*this,sequence,d); + } + + OpenRegularSpace(OpenRegularSpace& s) + : Gecode::Space(s) { + x.update(*this,s.x); + sequence.update(*this,s.sequence); + } + + virtual Gecode::Space* + copy(void) { + return new OpenRegularSpace(*this); + } + }; + + /// Space used by open sequence materialization tests + class OpenSequenceSpace : public Gecode::Space { + public: + Gecode::OpenIntVarSequence sequence; + + OpenSequenceSpace(void) + : sequence(*this, + [](int i) { + return Gecode::IntSet(i,i); + },6) {} + + OpenSequenceSpace(OpenSequenceSpace& s) + : Gecode::Space(s) { + sequence.update(*this,s.sequence); + } + + virtual Gecode::Space* + copy(void) { + return new OpenSequenceSpace(*this); + } + }; + + /// Test automatic and explicit sequence materialization + class OpenSequenceMaterialize : public ::Test::Base { + public: + OpenSequenceMaterialize(void) + : ::Test::Base("Int::OpenSequence::Materialize") {} + + virtual bool + run(void) { + using namespace Gecode; + OpenSequenceSpace source; + rel(source,source.sequence.length(),IRT_GQ,3); + if ((source.status() == SS_FAILED) || + (source.sequence.size() != 3)) + return false; + for (int i=0; i<3; i++) + if (!source.sequence[i].assigned() || + (source.sequence[i].val() != i)) + return false; + + OpenSequenceSpace* clone = + static_cast(source.clone()); + rel(*clone,clone->sequence.length(),IRT_GQ,5); + const bool clone_ok = + (clone->status() != SS_FAILED) && + (clone->sequence.size() == 5) && + clone->sequence[4].assigned() && + (clone->sequence[4].val() == 4); + delete clone; + if (!clone_ok || (source.sequence.size() != 3)) + return false; + + OpenSequenceSpace direct; + IntVar x = direct.sequence.get(direct,3); + return (direct.sequence.size() == 4) && + (direct.sequence.length().min() == 4) && + x.assigned() && (x.val() == 3) && + (direct.status() != SS_FAILED); + } + }; + + /// Test appending and closing an open regular sequence + class OpenRegularIncremental : public ::Test::Base { + public: + OpenRegularIncremental(void) + : ::Test::Base("Int::Extensional::OpenReg::Incremental") {} + + virtual bool + run(void) { + using namespace Gecode; + DFA d(0,{{0,0,1},{1,1,2}},{2},false); + OpenRegularSpace s(d); + + if (s.status() == SS_FAILED) + return false; + s.sequence.append(s,s.x[0]); + if ((s.status() == SS_FAILED) || + !s.x[0].assigned() || (s.x[0].val() != 0)) + return false; + s.sequence.append(s,s.x[1]); + if ((s.status() == SS_FAILED) || + !s.x[1].assigned() || (s.x[1].val() != 1)) + return false; + s.sequence.close(s); + return (s.status() != SS_FAILED) && + s.sequence.length().assigned() && + (s.sequence.length().val() == 2); + } + }; + + /// Test notification when the eventual length is already ahead + class OpenRegularLengthWake : public ::Test::Base { + public: + OpenRegularLengthWake(void) + : ::Test::Base("Int::Extensional::OpenReg::LengthWake") {} + + virtual bool + run(void) { + using namespace Gecode; + DFA d(0,{{0,0,1},{1,1,2}},{2},false); + OpenRegularSpace s(d,3); + rel(s,s.sequence.length(),IRT_GQ,2); + if (s.status() == SS_FAILED) + return false; + return (s.sequence.size() == 2) && + s.sequence[0].assigned() && + (s.sequence[0].val() == 0) && + s.sequence[1].assigned() && + (s.sequence[1].val() == 1); + } + }; + + /// Test backward pruning after appending a restricted variable + class OpenRegularBackward : public ::Test::Base { + public: + OpenRegularBackward(void) + : ::Test::Base("Int::Extensional::OpenReg::Backward") {} + + virtual bool + run(void) { + using namespace Gecode; + DFA d(0, + { + {0,0,1}, {0,1,2}, + {1,0,3}, {2,1,4}, + {3,2,5}, {4,2,5} + }, + {5},false); + OpenRegularSpace s(d); + rel(s,s.x[1],IRT_EQ,0); + s.sequence.append(s,s.x[0]); + if ((s.status() == SS_FAILED) || + (s.x[0].min() != 0) || (s.x[0].max() != 1)) + return false; + s.sequence.append(s,s.x[1]); + return (s.status() != SS_FAILED) && + s.x[0].assigned() && (s.x[0].val() == 0); + } + }; + + /// Test domain notification on an appended variable + class OpenRegularDomainWake : public ::Test::Base { + public: + OpenRegularDomainWake(void) + : ::Test::Base("Int::Extensional::OpenReg::DomainWake") {} + + virtual bool + run(void) { + using namespace Gecode; + DFA d(0, + { + {0,0,1}, {0,1,2}, + {1,0,3}, {2,1,4}, + {3,2,5}, {4,2,5} + }, + {5},false); + OpenRegularSpace s(d); + s.sequence.append(s,s.x[0]); + s.sequence.append(s,s.x[1]); + if ((s.status() == SS_FAILED) || s.x[0].assigned()) + return false; + rel(s,s.x[1],IRT_EQ,0); + return (s.status() != SS_FAILED) && + s.x[0].assigned() && (s.x[0].val() == 0); + } + }; + + /// Test independent extension after cloning + class OpenRegularClone : public ::Test::Base { + public: + OpenRegularClone(void) + : ::Test::Base("Int::Extensional::OpenReg::Clone") {} + + virtual bool + run(void) { + using namespace Gecode; + DFA d(0,{{0,0,1},{1,1,2}},{2},false); + OpenRegularSpace source(d); + source.sequence.append(source,source.x[0]); + if (source.status() == SS_FAILED) + return false; + + OpenRegularSpace* clone = + static_cast(source.clone()); + clone->sequence.append(*clone,clone->x[1]); + clone->sequence.close(*clone); + const bool clone_ok = + (clone->status() != SS_FAILED) && + (clone->sequence.size() == 2); + delete clone; + + source.sequence.close(source); + const bool source_failed = source.status() == SS_FAILED; + return clone_ok && source_failed && + (source.sequence.size() == 1); + } + }; + + /// Test closing an empty sequence + class OpenRegularEmpty : public ::Test::Base { + public: + OpenRegularEmpty(void) + : ::Test::Base("Int::Extensional::OpenReg::Empty") {} + + virtual bool + run(void) { + using namespace Gecode; + OpenRegularSpace accepts{DFA()}; + accepts.sequence.close(accepts); + if (accepts.status() == SS_FAILED) + return false; + + DFA d(0,{{0,0,1}},{1},false); + OpenRegularSpace rejects(d); + rejects.sequence.close(rejects); + if (rejects.status() != SS_FAILED) + return false; + + DFA empty(0,{{0,0,0}},std::initializer_list{},false); + OpenRegularSpace no_continuation(empty); + return no_continuation.status() == SS_FAILED; + } + }; + + /// Space used to compare closed open regular with regular + class OpenRegularComparisonSpace : public Gecode::Space { + public: + Gecode::IntVarArray x; + Gecode::OpenIntVarSequence sequence; + + OpenRegularComparisonSpace(Gecode::DFA d, bool open, + int m0, int m1, int m2) + : x(*this,3,0,2), sequence(*this,3) { + using namespace Gecode; + if (open) { + for (int i=0; i + * + * Copyright: + * Mikael Zayenz Lagerkvist, 2026 + * + * This file is part of Gecode, the generic constraint + * development environment: + * http://www.gecode.dev + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + */ + +#include "test/int.hh" + +#include + +namespace Test { namespace Int { + + namespace OpenSequence { + + class BranchSpace : public Gecode::Space { + public: + Gecode::OpenIntVarSequence sequence; + + BranchSpace(void) + : sequence(*this, + [](int i) { + return Gecode::IntSet(i,i+1); + },3) { + Gecode::branch(*this,sequence); + } + + BranchSpace(BranchSpace& s) + : Gecode::Space(s) { + sequence.update(*this,s.sequence); + } + + virtual Gecode::Space* + copy(void) { + return new BranchSpace(*this); + } + }; + + class Branch : public ::Test::Base { + public: + Branch(void) + : ::Test::Base("Int::OpenSequence::Branch") {} + + virtual bool + run(void) { + using namespace Gecode; + Search::Options options; + options.threads = 1; + options.c_d = 1000; + options.a_d = 1000; + BranchSpace* root = new BranchSpace; + DFS engine(root,options); + delete root; + + int solutions = 0; + while (BranchSpace* solution = engine.next()) { + const int size = solution->sequence.size(); + bool valid = + solution->sequence.length().assigned() && + (solution->sequence.length().val() == size); + for (int i=0; isequence[i].assigned(); + delete solution; + if (!valid) + return false; + solutions++; + } + return solutions == 15; + } + }; + + class BranchOrderSpace : public Gecode::Space { + public: + Gecode::OpenIntVarSequence sequence; + + BranchOrderSpace(int order) + : sequence(*this,Gecode::IntSet(0,1),3) { + using namespace Gecode; + DFA accepts_one(0,{ + {0,0,0}, {0,1,1}, + {1,0,1}, {1,1,1} + },{1}); + extensional(*this,sequence,accepts_one); + if (order < 0) + branch(*this,sequence); + else + branch(*this,sequence,static_cast(order)); + } + + BranchOrderSpace(BranchOrderSpace& s) + : Gecode::Space(s) { + sequence.update(*this,s.sequence); + } + + virtual Gecode::Space* + copy(void) { + return new BranchOrderSpace(*this); + } + }; + + class BranchOrder : public ::Test::Base { + protected: + static bool + check(int order, int first_length) { + using namespace Gecode; + Search::Options options; + options.threads = 1; + options.c_d = 1000; + options.a_d = 1000; + BranchOrderSpace* root = new BranchOrderSpace(order); + DFS engine(root,options); + delete root; + + int solutions = 0; + int first = -1; + while (BranchOrderSpace* solution = engine.next()) { + if (solutions == 0) + first = solution->sequence.size(); + solutions++; + delete solution; + } + return (first == first_length) && (solutions == 11); + } + + public: + BranchOrder(void) + : ::Test::Base("Int::OpenSequence::BranchOrder") {} + + virtual bool + run(void) { + using namespace Gecode; + return check(-1,1) && + check(OIB_HORIZON_FIRST,1) && + check(OIB_VALUE_FIRST,3); + } + }; + + class TransitionSpace : public Gecode::Space { + public: + Gecode::OpenIntVarSequence sequence; + + TransitionSpace(void) + : sequence(*this,Gecode::IntSet(0,4), + [](Gecode::Space& home, Gecode::OpenIntVarSequence x, int i) { + using namespace Gecode; + if (i == 0) { + rel(home,x[i],IRT_EQ,0); + } else { + linear(home,IntArgs({-1,1}), + IntVarArgs({x[i-1],x[i]}),IRT_EQ,1); + } + },4) { + Gecode::branch(*this,sequence); + } + + TransitionSpace(TransitionSpace& s) + : Gecode::Space(s) { + sequence.update(*this,s.sequence); + } + + virtual Gecode::Space* + copy(void) { + return new TransitionSpace(*this); + } + }; + + class Transition : public ::Test::Base { + public: + Transition(void) + : ::Test::Base("Int::OpenSequence::Transition") {} + + virtual bool + run(void) { + using namespace Gecode; + Search::Options options; + options.threads = 1; + options.c_d = 1000; + options.a_d = 1000; + TransitionSpace* root = new TransitionSpace; + DFS engine(root,options); + delete root; + + int solutions = 0; + while (TransitionSpace* solution = engine.next()) { + bool valid = + solution->sequence.length().assigned() && + (solution->sequence.length().val() == + solution->sequence.size()); + for (int i=0; isequence.size(); i++) + valid &= solution->sequence[i].assigned() && + (solution->sequence[i].val() == i); + delete solution; + if (!valid) + return false; + solutions++; + } + return solutions == 5; + } + }; + + + class ConstraintSpace : public Gecode::Space { + public: + enum Kind { + DISTINCT, + REL, + SLIDING, + SLIDING_SUM, + MIN_MAX, + PRECEDE + }; + + Gecode::OpenIntVarSequence sequence; + Gecode::IntVar minimum; + Gecode::IntVar maximum; + + ConstraintSpace(Kind kind, int size) + : sequence(*this,Gecode::IntSet(0,2),size), + minimum(*this,0,2), maximum(*this,0,2) { + using namespace Gecode; + switch (kind) { + case DISTINCT: + distinct(*this,sequence); + break; + case REL: + rel(*this,sequence,IRT_LE); + break; + case SLIDING: + Gecode::sequence(*this,sequence,IntSet(1,1),2,1,1); + break; + case SLIDING_SUM: + slidingsum(*this,sequence,2,2,2); + break; + case MIN_MAX: + min(*this,sequence,minimum); + max(*this,sequence,maximum); + rel(*this,minimum,IRT_EQ,0); + rel(*this,maximum,IRT_EQ,2); + break; + case PRECEDE: + precede(*this,sequence,0,1); + break; + } + rel(*this,sequence.length(),IRT_EQ,size); + branch(*this,sequence); + } + + ConstraintSpace(ConstraintSpace& s) + : Gecode::Space(s) { + sequence.update(*this,s.sequence); + minimum.update(*this,s.minimum); + maximum.update(*this,s.maximum); + } + + virtual Gecode::Space* + copy(void) { + return new ConstraintSpace(*this); + } + }; + + int + solutions(ConstraintSpace::Kind kind, int size, + bool (*valid)(const ConstraintSpace&)) { + using namespace Gecode; + ConstraintSpace* root = new ConstraintSpace(kind,size); + DFS engine(root); + delete root; + int n = 0; + while (ConstraintSpace* solution = engine.next()) { + const bool ok = valid(*solution); + delete solution; + if (!ok) + return -1; + n++; + } + return n; + } + + bool + distinct_solution(const ConstraintSpace& s) { + for (int i=0; i= s.sequence[i].val()) + return false; + return true; + } + + bool + sliding_solution(const ConstraintSpace& s) { + for (int i=1; i(source.clone()); + clone->sequence.materialize(*clone,2); + clone->sequence.close(*clone); + const bool valid = + (clone->status() != SS_FAILED) && + clone->sequence[1].assigned() && + (clone->sequence[1].val() == 2) && + clone->minimum.assigned() && (clone->minimum.val() == 0) && + clone->maximum.assigned() && (clone->maximum.val() == 2); + delete clone; + return valid && (source.sequence.size() == 1); + } + }; + + Branch branch; + BranchOrder branch_order; + Transition transition; + Constraint distinct("Distinct",ConstraintSpace::DISTINCT,3,6, + distinct_solution); + Constraint relation("Rel",ConstraintSpace::REL,3,1,rel_solution); + Constraint sliding("Sliding",ConstraintSpace::SLIDING,4,8, + sliding_solution); + Constraint sliding_sum("SlidingSum",ConstraintSpace::SLIDING_SUM,4,3, + sliding_sum_solution); + Constraint min_max("MinMax",ConstraintSpace::MIN_MAX,3,12, + min_max_solution); + Precede precedence; + EmptyMinimum empty_minimum; + IncrementalConstraints incremental_constraints; + + } + +}} + +// STATISTICS: test-int From 2a2f0d2f4afc1130b7119b90a39ae40e86037c00 Mon Sep 17 00:00:00 2001 From: Mikael Zayenz Lagerkvist Date: Sun, 23 Aug 2026 08:50:42 +0200 Subject: [PATCH 09/34] Compact sparse DFA state identifiers --- gecode/int/extensional/dfa.cpp | 36 ++++++++++++++++++++++++---------- test/int/extensional.cpp | 25 +++++++++++++++++++++++ 2 files changed, 51 insertions(+), 10 deletions(-) diff --git a/gecode/int/extensional/dfa.cpp b/gecode/int/extensional/dfa.cpp index 112c75d86d..afe069b246 100755 --- a/gecode/int/extensional/dfa.cpp +++ b/gecode/int/extensional/dfa.cpp @@ -33,6 +33,9 @@ #include +#include +#include + namespace Gecode { namespace Int { namespace Extensional { /** @@ -154,22 +157,35 @@ namespace Gecode { using namespace Extensional; Region region; - // Compute number of states and transitions - int n_states = start; + // Collect the state identifiers before allocating state-indexed storage. + // DFA specifications may use sparse external identifiers; all subsequent + // algorithms operate on a compact internal numbering. + std::vector states; + states.push_back(start); int n_trans = 0; for (Transition* t = &t_spec[0]; t->i_state >= 0; t++) { - n_states = std::max(n_states,t->i_state); - n_states = std::max(n_states,t->o_state); + states.push_back(t->i_state); + states.push_back(t->o_state); n_trans++; } for (int* f = &f_spec[0]; *f >= 0; f++) - n_states = std::max(n_states,*f); - n_states++; + states.push_back(*f); + std::sort(states.begin(),states.end()); + states.erase(std::unique(states.begin(),states.end()),states.end()); + const auto compact = [&states](int state) { + return static_cast( + std::lower_bound(states.begin(),states.end(),state)-states.begin()); + }; + int n_states = static_cast(states.size()); + start = compact(start); // Temporary structure for transitions Transition* trans = region.alloc(n_trans); - for (int i=0; i(n_states+1); bool* is_final = region.alloc(n_states+1); @@ -177,8 +193,9 @@ namespace Gecode { for (int i=0; i Date: Sun, 4 Oct 2026 19:12:20 +0200 Subject: [PATCH 10/34] Fix open sequence lifetime and materialization --- gecode/int.hh | 49 +++- gecode/int/extensional-open-regular.cpp | 301 +---------------------- gecode/int/open-sequence.cpp | 304 ++++++++++++++++++++++++ test/int/open-sequence.cpp | 95 ++++++++ 4 files changed, 447 insertions(+), 302 deletions(-) diff --git a/gecode/int.hh b/gecode/int.hh index 71472609d1..f269b03a76 100755 --- a/gecode/int.hh +++ b/gecode/int.hh @@ -2425,7 +2425,7 @@ namespace Gecode { }; namespace Int { - class OpenSequence; + class OpenMaterialize; class OpenSequencePropagator; namespace Extensional { class OpenRegular; @@ -2436,7 +2436,27 @@ namespace Gecode { * \brief Space-local sequence of integer variables with an open length * * Variables can be appended until the sequence is closed. The length - * variable denotes the eventual sequence length. + * variable denotes the eventual sequence length. Propagation materializes + * positions required by its minimum. + * + * A sequence can be used in an ordinary Space: + * \code + * class Model : public Space { + * public: + * OpenIntVarSequence x; + * Model(void) : x(*this,IntSet(0,1),3) { + * rel(*this,x.length(),IRT_EQ,2); + * distinct(*this,x); + * branch(*this,x); + * } + * Model(Model& s) : Space(s) { + * x.update(*this,s.x); + * } + * virtual Space* copy(void) { + * return new Model(*this); + * } + * }; + * \endcode * * \ingroup TaskModelInt */ @@ -2446,7 +2466,7 @@ namespace Gecode { class Sequence; /// Return the materialized-length variable IntVar materialized(void) const; - friend class Int::OpenSequence; + friend class Int::OpenMaterialize; friend class Int::OpenSequencePropagator; friend class Int::Extensional::OpenRegular; friend void extensional(Home, OpenIntVarSequence, DFA, IntPropLevel); @@ -2454,8 +2474,9 @@ namespace Gecode { /** * \brief Function returning the domain for position \a i * - * The function must be deterministic so that recomputation creates - * the same variables. + * The function object is shared between clones. It must be + * deterministic so that recomputation creates the same variables, + * and must not capture space-local data. */ typedef std::function Domain; /** @@ -2508,12 +2529,24 @@ namespace Gecode { /** * \brief Materialize the first \a n variables * - * The eventual length is constrained to be at least \a n. + * The eventual length is constrained to be at least \a n. Positions + * required by its minimum are materialized, including any increase + * imposed by the transition function. */ GECODE_INT_EXPORT void materialize(Space& home, int n); - /// Return position \a i, materializing positions through \a i + /** + * \brief Return position \a i, materializing positions through \a i + * + * Returns an uninitialized IntVar if \a home is failed or + * materialization fails. + */ GECODE_INT_EXPORT IntVar get(Space& home, int i); - /// Close the sequence at its current length + /** + * \brief Close the sequence at its materialized length + * + * First materializes any positions required by the minimum eventual + * length, then assigns the eventual length to the number of positions. + */ GECODE_INT_EXPORT void close(Space& home); }; diff --git a/gecode/int/extensional-open-regular.cpp b/gecode/int/extensional-open-regular.cpp index f3e2481829..2fc96a3c27 100644 --- a/gecode/int/extensional-open-regular.cpp +++ b/gecode/int/extensional-open-regular.cpp @@ -35,297 +35,6 @@ #include -namespace Gecode { - - class OpenIntVarSequence::Sequence : public LocalObject { - public: - class Factory { - public: - Domain domain; - Transition transition; - - Factory(Domain domain0, Transition transition0) - : domain(domain0), transition(transition0) {} - }; - - IntVar length; - IntVar materialized; - IntVar* x; - int n; - int capacity; - SharedData factory; - - static int - maximum(int max) { - Int::Limits::check(max,"OpenIntVarSequence"); - if (max < 0) - throw Int::VariableEmptyDomain("OpenIntVarSequence"); - return max; - } - - static Domain - valid(Domain d) { - if (!d) - throw InvalidFunction("OpenIntVarSequence"); - return d; - } - - static Transition - valid(Transition t) { - if (!t) - throw InvalidFunction("OpenIntVarSequence"); - return t; - } - - Sequence(Home home, Domain d, int max) - : LocalObject(home), - length(home,0,maximum(max)), - materialized(home,0,max), - x(nullptr), n(0), capacity(0), - factory(Factory(valid(d),Transition())) {} - - Sequence(Home home, Domain d, Transition t, int max) - : LocalObject(home), - length(home,0,maximum(max)), - materialized(home,0,max), - x(nullptr), n(0), capacity(0), - factory(Factory(valid(d),valid(t))) {} - - Sequence(Space& home, Sequence& s) - : LocalObject(home,s), x(nullptr), n(s.n), capacity(s.n), - factory(s.factory) { - length.update(home,s.length); - materialized.update(home,s.materialized); - if (capacity > 0) { - x = heap.alloc(capacity); - for (int i=0; i 0) - heap.free(x,capacity); - factory.~SharedData(); - return sizeof(*this); - } - - void - reserve(void) { - if (n == capacity) { - int next = (capacity < 4) ? 4 : capacity + capacity / 2; - x = heap.realloc(x,capacity,next); - capacity = next; - } - } - - void - append(IntVar y) { - x[n++] = y; - } - }; - -} - -namespace Gecode { namespace Int { - - class OpenSequence : public Propagator { - protected: - OpenIntVarSequence sequence; - IntView length; - - OpenSequence(Home home, OpenIntVarSequence sequence0) - : Propagator(home), sequence(sequence0), length(sequence0.length()) { - length.subscribe(home,*this,PC_INT_BND); - } - - OpenSequence(Space& home, OpenSequence& p) - : Propagator(home,p) { - sequence.update(home,p.sequence); - length.update(home,p.length); - } - - public: - virtual Actor* - copy(Space& home) { - return new (home) OpenSequence(home,*this); - } - - virtual PropCost - cost(const Space&, const ModEventDelta&) const { - const int n = length.min()-sequence.size(); - return (n <= 1) ? PropCost::unary(PropCost::LO) : - PropCost::linear(PropCost::LO,n); - } - - virtual void - reschedule(Space& home) { - length.reschedule(home,*this,PC_INT_BND); - } - - virtual ExecStatus - propagate(Space& home, const ModEventDelta&) { - sequence.materialize(home,length.min()); - if (home.failed()) - return ES_FAILED; - if (length.assigned()) - return home.ES_SUBSUMED(*this); - return ES_FIX; - } - - virtual size_t - dispose(Space& home) { - length.cancel(home,*this,PC_INT_BND); - sequence.~OpenIntVarSequence(); - (void) Propagator::dispose(home); - return sizeof(*this); - } - - static void - post(Home home, OpenIntVarSequence sequence) { - if (!sequence.length().assigned()) - (void) new (home) OpenSequence(home,sequence); - } - }; - -}} - -namespace Gecode { - - OpenIntVarSequence::OpenIntVarSequence(void) {} - - OpenIntVarSequence::OpenIntVarSequence(Space& home, int max) - : OpenIntVarSequence(home, - IntSet(Int::Limits::min,Int::Limits::max),max) {} - - OpenIntVarSequence::OpenIntVarSequence(Space& home, const IntSet& d, - int max) - : OpenIntVarSequence(home,[d](int) { return d; },max) {} - - OpenIntVarSequence::OpenIntVarSequence(Space& home, const IntSet& d, - Transition t, int max) - : OpenIntVarSequence(home,[d](int) { return d; },t,max) {} - - OpenIntVarSequence::OpenIntVarSequence(Space& home, Domain d, int max) - : LocalHandle(new (home) Sequence(home,d,max)) { - Int::OpenSequence::post(home,*this); - } - - OpenIntVarSequence::OpenIntVarSequence(Space& home, Domain d, - Transition t, int max) - : LocalHandle(new (home) Sequence(home,d,t,max)) { - Int::OpenSequence::post(home,*this); - } - - void - OpenIntVarSequence::update(Space& home, OpenIntVarSequence& s) { - LocalHandle::update(home,s); - } - - int - OpenIntVarSequence::size(void) const { - return static_cast(object())->n; - } - - IntVar - OpenIntVarSequence::operator [](int i) const { - Sequence* s = static_cast(object()); - assert((i >= 0) && (i < s->n)); - return s->x[i]; - } - - IntVar - OpenIntVarSequence::length(void) const { - return static_cast(object())->length; - } - - IntVar - OpenIntVarSequence::materialized(void) const { - return static_cast(object())->materialized; - } - - void - OpenIntVarSequence::append(Space& home, IntVar y) { - if (home.failed()) - return; - Sequence* s = static_cast(object()); - if (s->n == Int::Limits::max) { - home.fail(); - return; - } - for (int i=0; in; i++) - if (!y.assigned() && !s->x[i].assigned() && - (y.varimp() == s->x[i].varimp())) - throw Int::ArgumentSame("OpenIntVarSequence::append"); - s->reserve(); - const int next = s->n + 1; - Int::IntView l(s->length); - Int::IntView m(s->materialized); - if (me_failed(l.gq(home,next)) || me_failed(m.gq(home,next))) { - home.fail(); - return; - } - s->append(y); - const Transition& transition = s->factory().transition; - if (transition) { - GECODE_VALID_FUNCTION(transition); - transition(home,*this,next-1); - } - } - - void - OpenIntVarSequence::materialize(Space& home, int n) { - if (home.failed()) - return; - Int::Limits::nonnegative(n,"OpenIntVarSequence::materialize"); - Sequence* s = static_cast(object()); - Int::IntView l(s->length); - if (me_failed(l.gq(home,n))) { - home.fail(); - return; - } - while (s->n < n) { - const int i = s->n; - GECODE_VALID_FUNCTION(s->factory().domain); - IntVar y(home,s->factory().domain(i)); - append(home,y); - if (home.failed()) - return; - } - } - - IntVar - OpenIntVarSequence::get(Space& home, int i) { - Int::Limits::nonnegative(i,"OpenIntVarSequence::get"); - if (home.failed()) - return IntVar(); - Sequence* s = static_cast(object()); - if (i >= s->length.max()) - throw Int::OutOfLimits("OpenIntVarSequence::get"); - materialize(home,i+1); - return static_cast(object())->x[i]; - } - - void - OpenIntVarSequence::close(Space& home) { - if (home.failed()) - return; - materialize(home,length().min()); - if (home.failed()) - return; - Sequence* s = static_cast(object()); - if (me_failed(Int::IntView(s->length).eq(home,s->n))) - home.fail(); - } - -} - namespace Gecode { namespace Int { namespace Extensional { class OpenRegular : public Propagator { @@ -344,6 +53,7 @@ namespace Gecode { namespace Int { namespace Extensional { materialized(sequence0.materialized()), dfa(dfa0), start(static_cast(home).alloc(dfa.n_states())), offset(0), subscribed(sequence0.size()) { + home.notice(*this,AP_DISPOSE); for (int i=0; i +namespace Gecode { + + class OpenIntVarSequence::Sequence : public LocalObject { + public: + class Factory { + public: + Domain domain; + Transition transition; + + Factory(Domain domain0, Transition transition0) + : domain(domain0), transition(transition0) {} + }; + + IntVar length; + IntVar materialized; + IntVar* x; + int n; + int capacity; + SharedData factory; + + static int + maximum(int max) { + Int::Limits::check(max,"OpenIntVarSequence"); + if (max < 0) + throw Int::VariableEmptyDomain("OpenIntVarSequence"); + return max; + } + + static Domain + valid(Domain d) { + if (!d) + throw InvalidFunction("OpenIntVarSequence"); + return d; + } + + static Transition + valid(Transition t) { + if (!t) + throw InvalidFunction("OpenIntVarSequence"); + return t; + } + + Sequence(Home home, Domain d, int max) + : LocalObject(home), + length(home,0,maximum(max)), + materialized(home,0,max), + x(nullptr), n(0), capacity(0), + factory(Factory(valid(d),Transition())) { + home.notice(*this,AP_DISPOSE); + } + + Sequence(Home home, Domain d, Transition t, int max) + : LocalObject(home), + length(home,0,maximum(max)), + materialized(home,0,max), + x(nullptr), n(0), capacity(0), + factory(Factory(valid(d),valid(t))) { + home.notice(*this,AP_DISPOSE); + } + + Sequence(Space& home, Sequence& s) + : LocalObject(home,s), x(nullptr), n(s.n), capacity(s.n), + factory(s.factory) { + length.update(home,s.length); + materialized.update(home,s.materialized); + if (capacity > 0) { + x = heap.alloc(capacity); + try { + for (int i=0; i(x,capacity); + throw; + } + } + } + + virtual Actor* + copy(Space& home) { + return new (home) Sequence(home,*this); + } + + virtual size_t + dispose(Space& home) { + home.ignore(*this,AP_DISPOSE); + if (capacity > 0) + heap.free(x,capacity); + factory.~SharedData(); + return sizeof(*this); + } + + void + reserve(void) { + if (n == capacity) { + int next = (capacity < 4) ? 4 : capacity + capacity / 2; + x = heap.realloc(x,capacity,next); + capacity = next; + } + } + + void + append(IntVar y) { + x[n++] = y; + } + }; + +} + +namespace Gecode { namespace Int { + + /// Materialize positions required by the minimum eventual length + class OpenMaterialize : public Propagator { + protected: + OpenIntVarSequence sequence; + IntView length; + + OpenMaterialize(Home home, OpenIntVarSequence sequence0) + : Propagator(home), sequence(sequence0), length(sequence0.length()) { + length.subscribe(home,*this,PC_INT_BND); + } + + OpenMaterialize(Space& home, OpenMaterialize& p) + : Propagator(home,p) { + sequence.update(home,p.sequence); + length.update(home,p.length); + } + + public: + virtual Actor* + copy(Space& home) { + return new (home) OpenMaterialize(home,*this); + } + + virtual PropCost + cost(const Space&, const ModEventDelta&) const { + const int n = length.min()-sequence.size(); + return (n <= 1) ? PropCost::unary(PropCost::LO) : + PropCost::linear(PropCost::LO,n); + } + + virtual void + reschedule(Space& home) { + length.reschedule(home,*this,PC_INT_BND); + } + + virtual ExecStatus + propagate(Space& home, const ModEventDelta&) { + sequence.materialize(home,length.min()); + if (home.failed()) + return ES_FAILED; + if (length.assigned()) + return home.ES_SUBSUMED(*this); + return ES_FIX; + } + + virtual size_t + dispose(Space& home) { + length.cancel(home,*this,PC_INT_BND); + sequence.~OpenIntVarSequence(); + (void) Propagator::dispose(home); + return sizeof(*this); + } + + static void + post(Home home, OpenIntVarSequence sequence) { + if (!sequence.length().assigned()) + (void) new (home) OpenMaterialize(home,sequence); + } + }; + +}} + +namespace Gecode { + + OpenIntVarSequence::OpenIntVarSequence(void) {} + + OpenIntVarSequence::OpenIntVarSequence(Space& home, int max) + : OpenIntVarSequence(home, + IntSet(Int::Limits::min,Int::Limits::max),max) {} + + OpenIntVarSequence::OpenIntVarSequence(Space& home, const IntSet& d, + int max) + : OpenIntVarSequence(home,[d](int) { return d; },max) {} + + OpenIntVarSequence::OpenIntVarSequence(Space& home, const IntSet& d, + Transition t, int max) + : OpenIntVarSequence(home,[d](int) { return d; },t,max) {} + + OpenIntVarSequence::OpenIntVarSequence(Space& home, Domain d, int max) + : LocalHandle(new (home) Sequence(home,d,max)) { + Int::OpenMaterialize::post(home,*this); + } + + OpenIntVarSequence::OpenIntVarSequence(Space& home, Domain d, + Transition t, int max) + : LocalHandle(new (home) Sequence(home,d,t,max)) { + Int::OpenMaterialize::post(home,*this); + } + + void + OpenIntVarSequence::update(Space& home, OpenIntVarSequence& s) { + LocalHandle::update(home,s); + } + + int + OpenIntVarSequence::size(void) const { + return static_cast(object())->n; + } + + IntVar + OpenIntVarSequence::operator [](int i) const { + Sequence* s = static_cast(object()); + assert((i >= 0) && (i < s->n)); + return s->x[i]; + } + + IntVar + OpenIntVarSequence::length(void) const { + return static_cast(object())->length; + } + + IntVar + OpenIntVarSequence::materialized(void) const { + return static_cast(object())->materialized; + } + + void + OpenIntVarSequence::append(Space& home, IntVar y) { + if (home.failed()) + return; + Sequence* s = static_cast(object()); + if (s->n == Int::Limits::max) { + home.fail(); + return; + } + for (int i=0; in; i++) + if (!y.assigned() && !s->x[i].assigned() && + (y.varimp() == s->x[i].varimp())) + throw Int::ArgumentSame("OpenIntVarSequence::append"); + s->reserve(); + const int next = s->n + 1; + Int::IntView l(s->length); + Int::IntView m(s->materialized); + if (me_failed(l.gq(home,next)) || me_failed(m.gq(home,next))) { + home.fail(); + return; + } + s->append(y); + const Transition& transition = s->factory().transition; + if (transition) { + GECODE_VALID_FUNCTION(transition); + transition(home,*this,next-1); + } + } + + void + OpenIntVarSequence::materialize(Space& home, int n) { + if (home.failed()) + return; + Int::Limits::nonnegative(n,"OpenIntVarSequence::materialize"); + Sequence* s = static_cast(object()); + Int::IntView l(s->length); + if (me_failed(l.gq(home,n))) { + home.fail(); + return; + } + while (s->n < l.min()) { + const int i = s->n; + GECODE_VALID_FUNCTION(s->factory().domain); + IntVar y(home,s->factory().domain(i)); + append(home,y); + if (home.failed()) + return; + } + } + + IntVar + OpenIntVarSequence::get(Space& home, int i) { + Int::Limits::nonnegative(i,"OpenIntVarSequence::get"); + if (home.failed()) + return IntVar(); + Sequence* s = static_cast(object()); + if (i >= s->length.max()) + throw Int::OutOfLimits("OpenIntVarSequence::get"); + materialize(home,i+1); + if (home.failed()) + return IntVar(); + return static_cast(object())->x[i]; + } + + void + OpenIntVarSequence::close(Space& home) { + if (home.failed()) + return; + materialize(home,length().min()); + if (home.failed()) + return; + Sequence* s = static_cast(object()); + if (me_failed(Int::IntView(s->length).eq(home,s->n))) + home.fail(); + } + +} + namespace Gecode { namespace Int { class OpenSequencePropagator : public Propagator { diff --git a/test/int/open-sequence.cpp b/test/int/open-sequence.cpp index 867a896830..cd2033a950 100644 --- a/test/int/open-sequence.cpp +++ b/test/int/open-sequence.cpp @@ -35,6 +35,8 @@ #include +#include + namespace Test { namespace Int { namespace OpenSequence { @@ -499,6 +501,99 @@ namespace Test { namespace Int { } }; + class CallbackSpace : public Gecode::Space { + public: + Gecode::OpenIntVarSequence sequence; + + CallbackSpace(Gecode::OpenIntVarSequence::Domain domain, + Gecode::OpenIntVarSequence::Transition transition) + : sequence(*this,domain,transition,8) {} + + CallbackSpace(CallbackSpace& s) : Gecode::Space(s) { + sequence.update(*this,s.sequence); + } + + virtual Gecode::Space* + copy(void) { + return new CallbackSpace(*this); + } + }; + + class Dispose : public ::Test::Base { + public: + Dispose(void) + : ::Test::Base("Int::OpenSequence::Dispose") {} + + virtual bool + run(void) { + using namespace Gecode; + std::shared_ptr domain(new int(0)); + std::shared_ptr transition(new int(0)); + CallbackSpace* source = new CallbackSpace( + [domain](int) { return IntSet(0,1); }, + [transition](Space&, OpenIntVarSequence, int) {}); + source->sequence.materialize(*source,2); + DFA dfa(0,{{0,0,0},{0,1,0}},{0}); + extensional(*source,source->sequence,dfa); + if (source->status() == SS_FAILED) { + delete source; + return false; + } + CallbackSpace* clone = static_cast(source->clone()); + delete source; + const bool retained = (domain.use_count() > 1) && + (transition.use_count() > 1); + delete clone; + return retained && (domain.use_count() == 1) && + (transition.use_count() == 1); + } + }; + + class CallbackLength : public ::Test::Base { + public: + CallbackLength(void) + : ::Test::Base("Int::OpenSequence::CallbackLength") {} + + virtual bool + run(void) { + using namespace Gecode; + for (int assign=0; assign<2; assign++) + for (int close=0; close<2; close++) { + CallbackSpace source([](int) { return IntSet(0,1); }, + [assign](Space& home, OpenIntVarSequence sequence, int i) { + if (i == 0) + rel(home,sequence.length(),assign ? IRT_EQ : IRT_GQ,3); + }); + rel(source,source.sequence.length(),IRT_GQ,1); + if (close) + source.sequence.close(source); + if ((source.status() == SS_FAILED) || + (source.sequence.size() != 3)) + return false; + } + return true; + } + }; + + class FailedGet : public ::Test::Base { + public: + FailedGet(void) + : ::Test::Base("Int::OpenSequence::FailedGet") {} + + virtual bool + run(void) { + using namespace Gecode; + CallbackSpace source([](int) { return IntSet(0,1); }, + [](Space& home, OpenIntVarSequence, int) { home.fail(); }); + IntVar x = source.sequence.get(source,4); + return source.failed() && (x.varimp() == nullptr); + } + }; + + Dispose disposal; + CallbackLength callback_length; + FailedGet failed_get; + Branch branch; BranchOrder branch_order; Transition transition; From f046593c94f2341390cc37001876c67af0919528 Mon Sep 17 00:00:00 2001 From: Mikael Zayenz Lagerkvist Date: Sun, 4 Oct 2026 19:57:11 +0200 Subject: [PATCH 11/34] Fix open sequence commits and regular edge cases --- gecode/int/extensional-open-regular.cpp | 78 ++++++++++++++----------- gecode/int/extensional/dfa.cpp | 6 +- gecode/int/open-sequence.cpp | 6 +- test/int/extensional.cpp | 26 +++++++++ test/int/open-sequence.cpp | 64 ++++++++++++++++++++ 5 files changed, 141 insertions(+), 39 deletions(-) diff --git a/gecode/int/extensional-open-regular.cpp b/gecode/int/extensional-open-regular.cpp index 2fc96a3c27..58908ce79f 100644 --- a/gecode/int/extensional-open-regular.cpp +++ b/gecode/int/extensional-open-regular.cpp @@ -104,6 +104,47 @@ namespace Gecode { namespace Int { namespace Extensional { return false; } + private: + /// Compute backward state support in region-owned storage + const unsigned char* + compute_backward_support(Region& r, bool closed) const { + const int n = sequence.size()-offset; + const int k = dfa.n_states(); + const unsigned long long cells = + static_cast(n+1) * + static_cast(k); + if (cells > + static_cast + ((std::numeric_limits::max)())) + throw OutOfLimits("Int::extensional"); + + unsigned char* backward = + r.alloc(static_cast(cells)); + for (size_t i=0; i(cells); i++) + backward[i] = 0; + + unsigned char* last = backward + static_cast(n)*k; + if (closed) { + for (int s=0; s(i)*k; + unsigned char* out = in+k; + IntView x(sequence[offset+i]); + for (ViewValues v(x); v(); ++v) + for (DFA::Transitions t(dfa,v.val()); t(); ++t) + if (out[t.o_state()] != 0) + in[t.i_state()] = 1; + } + return backward; + } + public: virtual Actor* copy(Space& home) { @@ -148,39 +189,8 @@ namespace Gecode { namespace Int { namespace Extensional { return closed ? home.ES_SUBSUMED(*this) : ES_FIX; } - const unsigned long long cells = - static_cast(n+1) * - static_cast(k); - if (cells > - static_cast - ((std::numeric_limits::max)())) - throw OutOfLimits("Int::extensional"); - Region r; - unsigned char* backward = - r.alloc(static_cast(cells)); - for (size_t i=0; i(cells); i++) - backward[i] = 0; - - unsigned char* last = backward + static_cast(n)*k; - if (closed) { - for (int s=0; s(i)*k; - unsigned char* out = in+k; - IntView x(sequence[offset+i]); - for (ViewValues v(x); v(); ++v) - for (DFA::Transitions t(dfa,v.val()); t(); ++t) - if (out[t.o_state()] != 0) - in[t.i_state()] = 1; - } + const unsigned char* backward = compute_backward_support(r,closed); bool any = false; for (int s=0; s(dfa.n_symbols()); int n_supported = 0; - unsigned char* out = backward + static_cast(i+1)*k; + const unsigned char* out = backward + static_cast(i+1)*k; for (ViewValues v(x); v(); ++v) { bool support = false; for (DFA::Transitions t(dfa,v.val()); t() && !support; ++t) @@ -225,7 +235,7 @@ namespace Gecode { namespace Int { namespace Extensional { int consumed = 0; while ((consumed < n) && sequence[offset+consumed].assigned()) { - unsigned char* live = + const unsigned char* live = backward + static_cast(consumed+1)*k; unsigned char* next = r.alloc(k); for (int s=0; s(choice0); if (choice.kind == Description::VALUE) { - IntView x(sequence.get(home,choice.position)); + IntView x(sequence[choice.position]); ModEvent me = (alternative == 0) ? x.eq(home,choice.value) : x.nq(home,choice.value); @@ -923,7 +923,7 @@ namespace Gecode { lower = std::max(0,lower); upper = std::min(width,upper); if (upper < lower) { - home.fail(); + rel(home,x.length(),IRT_LE,width); return; } if ((lower == 0) && (upper == width)) @@ -941,7 +941,7 @@ namespace Gecode { throw Int::OutOfLimits("Int::slidingsum"); GECODE_POST; if (upper < lower) { - home.fail(); + rel(home,sequence.length(),IRT_LE,width); return; } Int::OpenSlidingSum::post(home,sequence,width,lower,upper,ipl); diff --git a/test/int/extensional.cpp b/test/int/extensional.cpp index 7f0cc4f156..da6ebd5f55 100755 --- a/test/int/extensional.cpp +++ b/test/int/extensional.cpp @@ -474,6 +474,30 @@ namespace Test { namespace Int { } }; + /// %Test repeated final states in a sparse DFA specification + class RegDuplicateFinals : public Test { + protected: + bool minimize; + public: + RegDuplicateFinals(bool minimize0) + : Test(std::string("Extensional::Reg::DuplicateFinals::")+ + (minimize0 ? "Minimize" : "Keep"), + 1,0,1,false,Gecode::IPL_DOM), minimize(minimize0) {} + + virtual bool + solution(const Assignment& x) const { + return x[0] == 0; + } + + virtual void + post(Gecode::Space& home, Gecode::IntVarArray& x) { + using namespace Gecode; + DFA d(100,{{100,0,200}}, + {200,200,200,200,200,200,200,200},minimize); + extensional(home,x,d); + } + }; + /// %Test the Boolean-view regular posting route class RegBoolCyclicFrontier : public Test { public: @@ -2508,6 +2532,8 @@ namespace Test { namespace Int { RegAcyclicReconvergence reg_sparse_acyclic_reconvergence; RegCyclicFrontier reg_sparse_cyclic_frontier; RegSparseStateNumbering reg_sparse_state_numbering; + RegDuplicateFinals reg_duplicate_finals_minimize(true); + RegDuplicateFinals reg_duplicate_finals_keep(false); RegBoolCyclicFrontier reg_sparse_bool_cyclic_frontier; RegRandomDifferential reg_sparse_random_differential_1(1); RegRandomDifferential reg_sparse_random_differential_2(2); diff --git a/test/int/open-sequence.cpp b/test/int/open-sequence.cpp index cd2033a950..294273962e 100644 --- a/test/int/open-sequence.cpp +++ b/test/int/open-sequence.cpp @@ -590,6 +590,70 @@ namespace Test { namespace Int { } }; + class ValueCommit : public ::Test::Base { + public: + ValueCommit(void) + : ::Test::Base("Int::OpenSequence::ValueCommit") {} + + virtual bool + run(void) { + using namespace Gecode; + CallbackSpace source([](int) { return IntSet(0,1); }, + [](Space& home, OpenIntVarSequence, int i) { + if (i == 1) + home.fail(); + }); + source.sequence.materialize(source,1); + branch(source,source.sequence,OIB_VALUE_FIRST); + if (source.status() != SS_BRANCH) + return false; + const Choice* choice = source.choice(); + bool valid = true; + for (unsigned int alternative=0; alternative<2; alternative++) { + CallbackSpace* clone = static_cast(source.clone()); + rel(*clone,clone->sequence.length(),IRT_GQ,2); + clone->commit(*choice,alternative); + valid &= !clone->failed() && (clone->sequence.size() == 1) && + clone->sequence[0].assigned() && + (clone->sequence[0].val() == static_cast(alternative)); + valid &= clone->status() == SS_FAILED; + delete clone; + } + delete choice; + return valid; + } + }; + + class ImpossibleWindow : public ::Test::Base { + public: + ImpossibleWindow(void) + : ::Test::Base("Int::OpenSequence::ImpossibleWindow") {} + + virtual bool + run(void) { + using namespace Gecode; + for (int sum=0; sum<2; sum++) + for (int size=0; size<3; size++) { + CallbackSpace source([](int) { return IntSet(0,1); }, + [](Space&, OpenIntVarSequence, int) {}); + if (sum) + slidingsum(source,source.sequence,2,2,1); + else + Gecode::sequence(source,source.sequence,IntSet(0,1),2,3,3); + rel(source,source.sequence.length(),IRT_EQ,size); + const bool failed = source.status() == SS_FAILED; + if (failed != (size == 2)) + return false; + if (!failed && (source.sequence.size() != size)) + return false; + } + return true; + } + }; + + ValueCommit value_commit; + ImpossibleWindow impossible_window; + Dispose disposal; CallbackLength callback_length; FailedGet failed_get; From 60613ad64a2675f8b2794d28bb85977402319c0f Mon Sep 17 00:00:00 2001 From: Mikael Zayenz Lagerkvist Date: Sun, 4 Oct 2026 20:13:55 +0200 Subject: [PATCH 12/34] Fix open sequence compilation on Windows --- gecode/int.hh | 3 ++- gecode/int/extensional-open-regular.cpp | 4 ++-- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/gecode/int.hh b/gecode/int.hh index f269b03a76..944bf064d8 100755 --- a/gecode/int.hh +++ b/gecode/int.hh @@ -2469,7 +2469,8 @@ namespace Gecode { friend class Int::OpenMaterialize; friend class Int::OpenSequencePropagator; friend class Int::Extensional::OpenRegular; - friend void extensional(Home, OpenIntVarSequence, DFA, IntPropLevel); + friend GECODE_INT_EXPORT + void extensional(Home, OpenIntVarSequence, DFA, IntPropLevel); public: /** * \brief Function returning the domain for position \a i diff --git a/gecode/int/extensional-open-regular.cpp b/gecode/int/extensional-open-regular.cpp index 58908ce79f..041684f545 100644 --- a/gecode/int/extensional-open-regular.cpp +++ b/gecode/int/extensional-open-regular.cpp @@ -115,11 +115,11 @@ namespace Gecode { namespace Int { namespace Extensional { static_cast(k); if (cells > static_cast - ((std::numeric_limits::max)())) + ((std::numeric_limits::max)())) throw OutOfLimits("Int::extensional"); unsigned char* backward = - r.alloc(static_cast(cells)); + r.alloc(static_cast(cells)); for (size_t i=0; i(cells); i++) backward[i] = 0; From 2572b1df6bf0815d97f0f9833c2d2cf4aa0d58ac Mon Sep 17 00:00:00 2001 From: Mikael Zayenz Lagerkvist Date: Mon, 5 Oct 2026 04:48:24 +0200 Subject: [PATCH 13/34] Generalize open sequences and reuse standard branching selectors --- Makefile.in | 1 + gecode/int.hh | 227 +++++--- gecode/int/extensional-open-regular.cpp | 54 +- gecode/int/open-sequence.cpp | 663 +++++++++++------------- gecode/int/open-sequence.hpp | 364 +++++++++++++ test/int/open-sequence.cpp | 338 +++++++++++- 6 files changed, 1179 insertions(+), 468 deletions(-) create mode 100644 gecode/int/open-sequence.hpp diff --git a/Makefile.in b/Makefile.in index 0a9e87a49d..746ed460f4 100755 --- a/Makefile.in +++ b/Makefile.in @@ -350,6 +350,7 @@ INTSRC0 = \ exception.cpp INTHDR0 = \ + open-sequence.hpp \ limits.hpp support-values.hh support-values.hpp \ idx-view.hh idx-view.hpp div.hh div.hpp \ exec.hh exec/when.hpp \ diff --git a/gecode/int.hh b/gecode/int.hh index 944bf064d8..d64652afee 100755 --- a/gecode/int.hh +++ b/gecode/int.hh @@ -2424,21 +2424,19 @@ namespace Gecode { std::size_t hash(void) const; }; - namespace Int { - class OpenMaterialize; - class OpenSequencePropagator; - namespace Extensional { - class OpenRegular; - } - } - /** - * \brief Space-local sequence of integer variables with an open length + * \brief Space-local sequence of variables with an open length * * Variables can be appended until the sequence is closed. The length * variable denotes the eventual sequence length. Propagation materializes * positions required by its minimum. * + * OpenIntVarSequence and OpenBoolVarSequence provide standard factories. + * Other variable types use a factory passed to OpenVarSequence, for + * example a function returning SetVar or FloatVar. Storage, cloning, and + * materialization are shared; constraint and branching overloads remain + * specific to the variable type. + * * A sequence can be used in an ordinary Space: * \code * class Model : public Space { @@ -2460,26 +2458,20 @@ namespace Gecode { * * \ingroup TaskModelInt */ - class OpenIntVarSequence : public LocalHandle { + template + class OpenVarSequence : public LocalHandle { private: /// Space-local sequence implementation class Sequence; - /// Return the materialized-length variable - IntVar materialized(void) const; - friend class Int::OpenMaterialize; - friend class Int::OpenSequencePropagator; - friend class Int::Extensional::OpenRegular; - friend GECODE_INT_EXPORT - void extensional(Home, OpenIntVarSequence, DFA, IntPropLevel); public: /** - * \brief Function returning the domain for position \a i + * \brief Function creating the variable at position \a i in \a home * - * The function object is shared between clones. It must be - * deterministic so that recomputation creates the same variables, - * and must not capture space-local data. + * The function object is shared between clones. It must be deterministic + * and must not capture space-local data. Returned variables must belong + * to \a home and be initialized. */ - typedef std::function Domain; + typedef std::function Factory; /** * \brief Function called after materializing position \a i * @@ -2487,46 +2479,31 @@ namespace Gecode { * deterministic and must not capture space-local data; \a home and * \a x refer to the current space. */ - typedef std::function + typedef std::function x, int i)> Transition; /// Construct an uninitialized sequence - GECODE_INT_EXPORT - OpenIntVarSequence(void); - /// Construct a sequence with maximal length \a max and full domains - GECODE_INT_EXPORT - OpenIntVarSequence(Space& home, int max=Int::Limits::max); - /// Construct a sequence using domain \a d for every position - GECODE_INT_EXPORT - OpenIntVarSequence(Space& home, const IntSet& d, - int max=Int::Limits::max); - /// Construct a sequence using domain \a d and transition function \a t - GECODE_INT_EXPORT - OpenIntVarSequence(Space& home, const IntSet& d, Transition t, - int max=Int::Limits::max); - /// Construct a sequence using \a d to create each position - GECODE_INT_EXPORT - OpenIntVarSequence(Space& home, Domain d, - int max=Int::Limits::max); - /// Construct a sequence using \a d and transition function \a t - GECODE_INT_EXPORT - OpenIntVarSequence(Space& home, Domain d, Transition t, - int max=Int::Limits::max); + OpenVarSequence(void); + /// Construct a sequence using \a create for each position + OpenVarSequence(Space& home, Factory create, + int max=Int::Limits::max); + /// Construct a sequence using \a create and transition function \a t + OpenVarSequence(Space& home, Factory create, Transition t, + int max=Int::Limits::max); /// Update during cloning - GECODE_INT_EXPORT - void update(Space& home, OpenIntVarSequence& s); + void update(Space& home, OpenVarSequence& s); /// Return the number of appended variables - GECODE_INT_EXPORT int size(void) const; + int size(void) const; /// Return variable at position \a i (\a i must be a valid position) - GECODE_INT_EXPORT IntVar operator [](int i) const; + Var operator [](int i) const; /// Return the eventual-length variable - GECODE_INT_EXPORT IntVar length(void) const; + IntVar length(void) const; /** * \brief Append variable \a x * * Throws an exception of type Int::ArgumentSame if \a x is an * unassigned variable already in the sequence. */ - GECODE_INT_EXPORT void append(Space& home, IntVar x); + void append(Space& home, Var x); /** * \brief Materialize the first \a n variables * @@ -2534,21 +2511,90 @@ namespace Gecode { * required by its minimum are materialized, including any increase * imposed by the transition function. */ - GECODE_INT_EXPORT void materialize(Space& home, int n); + void materialize(Space& home, int n); /** * \brief Return position \a i, materializing positions through \a i * - * Returns an uninitialized IntVar if \a home is failed or + * Returns an uninitialized variable if \a home is failed or * materialization fails. */ - GECODE_INT_EXPORT IntVar get(Space& home, int i); + Var get(Space& home, int i); /** * \brief Close the sequence at its materialized length * * First materializes any positions required by the minimum eventual * length, then assigns the eventual length to the number of positions. */ - GECODE_INT_EXPORT void close(Space& home); + void close(Space& home); + /// Subscribe \a p to the addition of positions + void subscribe(Space& home, Propagator& p); + /// Cancel the subscription of \a p to the addition of positions + void cancel(Space& home, Propagator& p); + /// Reschedule \a p for the addition of positions + void reschedule(Space& home, Propagator& p); + }; + + + /** + * \brief Open sequence of integer variables + * \ingroup TaskModelInt + */ + class OpenIntVarSequence : public OpenVarSequence { + public: + /** + * \brief Function returning the domain for position \a i + * + * Like Factory, it must be deterministic and must not capture space-local + * data. The function object is shared between clones. + */ + typedef std::function Domain; + using OpenVarSequence::OpenVarSequence; + /// Construct an uninitialized sequence + GECODE_INT_EXPORT OpenIntVarSequence(void); + /// Share an integer sequence constructed through a variable factory + OpenIntVarSequence(const OpenVarSequence& x); + /// Construct a sequence with maximal length \a max and full domains + GECODE_INT_EXPORT + OpenIntVarSequence(Space& home, int max=Int::Limits::max); + /// Construct a sequence using domain \a d for every position + GECODE_INT_EXPORT + OpenIntVarSequence(Space& home, const IntSet& d, + int max=Int::Limits::max); + /// Construct a sequence using domain \a d and transition function \a t + GECODE_INT_EXPORT + OpenIntVarSequence(Space& home, const IntSet& d, Transition t, + int max=Int::Limits::max); + /// Construct a sequence using \a d to create each position + GECODE_INT_EXPORT + OpenIntVarSequence(Space& home, Domain d, + int max=Int::Limits::max); + /// Construct a sequence using \a d and transition function \a t + GECODE_INT_EXPORT + OpenIntVarSequence(Space& home, Domain d, Transition t, + int max=Int::Limits::max); + private: + /// Convert a position-dependent domain to a variable factory + static Factory factory(Domain d); + }; + + /** + * \brief Open sequence of Boolean variables + * \ingroup TaskModelInt + */ + class OpenBoolVarSequence : public OpenVarSequence { + public: + using OpenVarSequence::OpenVarSequence; + /// Construct an uninitialized sequence + GECODE_INT_EXPORT OpenBoolVarSequence(void); + /// Share a Boolean sequence constructed through a variable factory + OpenBoolVarSequence(const OpenVarSequence& x); + /// Construct a sequence with maximal length \a max and domains 0..1 + GECODE_INT_EXPORT + OpenBoolVarSequence(Space& home, int max=Int::Limits::max); + /// Construct a sequence with domains 0..1 and transition function \a t + GECODE_INT_EXPORT + OpenBoolVarSequence(Space& home, Transition t, + int max=Int::Limits::max); }; } @@ -2648,6 +2694,8 @@ namespace Gecode { } +#include + #include namespace Gecode { namespace Int { namespace Extensional { @@ -3076,6 +3124,14 @@ namespace Gecode { extensional(Home home, OpenIntVarSequence x, DFA d, IntPropLevel ipl=IPL_DEF); + /** + * \brief Post an open regular-language constraint on Boolean variables + * \ingroup TaskModelIntExt + */ + GECODE_INT_EXPORT void + extensional(Home home, OpenBoolVarSequence x, DFA d, + IntPropLevel ipl=IPL_DEF); + /** \brief Post propagator for \f$x\in t\f$. * * \li Supports domain consistency (\a ipl = IPL_DOM, default) only. @@ -5111,9 +5167,9 @@ namespace Gecode { * \brief Branching order for an open sequence * \ingroup TaskModelIntBranch */ - enum OpenIntBranch { - OIB_HORIZON_FIRST, ///< Select the horizon before sequence values - OIB_VALUE_FIRST ///< Select materialized values before the horizon + enum OpenVarBranch { + OVB_HORIZON_FIRST, ///< Select the horizon before sequence values + OVB_VALUE_FIRST ///< Select materialized values before the horizon }; /** @@ -6055,27 +6111,62 @@ namespace Gecode { branch(Home home, IntVar x, IntValBranch vals, IntVarValPrint vvp=nullptr); /** - * \brief Branch over the eventual sequence \a x - * - * The brancher first branches between closing the sequence and adding - * one variable. Once the sequence is closed, it selects the first - * unassigned materialized variable. + * \brief Branch over the eventual integer sequence \a x * + * The default selects the horizon first, then the first unassigned + * variable and its minimum value. + * \ingroup TaskModelIntBranch + */ + GECODE_INT_EXPORT void + branch(Home home, OpenIntVarSequence x, + OpenVarBranch o=OVB_HORIZON_FIRST); + /** + * \brief Branch over the eventual Boolean sequence \a x * \ingroup TaskModelIntBranch */ GECODE_INT_EXPORT void - branch(Home home, OpenIntVarSequence x); + branch(Home home, OpenBoolVarSequence x, + OpenVarBranch o=OVB_HORIZON_FIRST); /** - * \brief Branch over the eventual sequence \a x using order \a o + * \brief Branch over an open integer sequence with standard selectors * - * \a OIB_HORIZON_FIRST selects the horizon before sequence values. - * \a OIB_VALUE_FIRST selects materialized values before deciding - * whether to close or extend the sequence. + * Selectors consider all materialized positions. \a OVB_HORIZON_FIRST + * decides the length before values; \a OVB_VALUE_FIRST selects values + * before closing or extending the sequence. Filters and callbacks receive + * the position in the sequence. * + * Action and CHB selection require the complete sequence to be materialized + * when posting; otherwise Int::UnknownBranching is thrown. * \ingroup TaskModelIntBranch */ GECODE_INT_EXPORT void - branch(Home home, OpenIntVarSequence x, OpenIntBranch o); + branch(Home home, OpenIntVarSequence x, + IntVarBranch vars, IntValBranch vals, + OpenVarBranch o=OVB_HORIZON_FIRST, + IntBranchFilter bf=nullptr, IntVarValPrint vvp=nullptr); + /// Branch over an open integer sequence with tie-breaking selectors + GECODE_INT_EXPORT void + branch(Home home, OpenIntVarSequence x, + TieBreak vars, IntValBranch vals, + OpenVarBranch o=OVB_HORIZON_FIRST, + IntBranchFilter bf=nullptr, IntVarValPrint vvp=nullptr); + /** + * \brief Branch over an open Boolean sequence with standard selectors + * + * The order, filter, and Action/CHB restrictions are as for integers. + * \ingroup TaskModelIntBranch + */ + GECODE_INT_EXPORT void + branch(Home home, OpenBoolVarSequence x, + BoolVarBranch vars, BoolValBranch vals, + OpenVarBranch o=OVB_HORIZON_FIRST, + BoolBranchFilter bf=nullptr, BoolVarValPrint vvp=nullptr); + /// Branch over an open Boolean sequence with tie-breaking selectors + GECODE_INT_EXPORT void + branch(Home home, OpenBoolVarSequence x, + TieBreak vars, BoolValBranch vals, + OpenVarBranch o=OVB_HORIZON_FIRST, + BoolBranchFilter bf=nullptr, BoolVarValPrint vvp=nullptr); /** * \brief Branch over \a x with variable selection \a vars and value selection \a vals * diff --git a/gecode/int/extensional-open-regular.cpp b/gecode/int/extensional-open-regular.cpp index 041684f545..79d99b9807 100644 --- a/gecode/int/extensional-open-regular.cpp +++ b/gecode/int/extensional-open-regular.cpp @@ -37,20 +37,21 @@ namespace Gecode { namespace Int { namespace Extensional { + template class OpenRegular : public Propagator { protected: - OpenIntVarSequence sequence; + OpenVarSequence sequence; IntView length; - IntView materialized; DFA dfa; unsigned char* start; int offset; int subscribed; - OpenRegular(Home home, OpenIntVarSequence sequence0, DFA dfa0) + OpenRegular(Home home, + OpenVarSequence sequence0, DFA dfa0) : Propagator(home), sequence(sequence0), length(sequence0.length()), - materialized(sequence0.materialized()), dfa(dfa0), + dfa(dfa0), start(static_cast(home).alloc(dfa.n_states())), offset(0), subscribed(sequence0.size()) { home.notice(*this,AP_DISPOSE); @@ -58,10 +59,10 @@ namespace Gecode { namespace Int { namespace Extensional { start[i] = 0; start[0] = 1; length.subscribe(home,*this,PC_INT_VAL); - materialized.subscribe(home,*this,PC_INT_BND); + sequence.subscribe(home,*this); for (int i=0; i(i)*k; unsigned char* out = in+k; - IntView x(sequence[offset+i]); - for (ViewValues v(x); v(); ++v) + View x(sequence[offset+i]); + for (ViewValues v(x); v(); ++v) for (DFA::Transitions t(dfa,v.val()); t(); ++t) if (out[t.o_state()] != 0) in[t.i_state()] = 1; @@ -159,24 +159,23 @@ namespace Gecode { namespace Int { namespace Extensional { virtual void reschedule(Space& home) { length.reschedule(home,*this,PC_INT_VAL); - materialized.reschedule(home,*this,PC_INT_BND); + sequence.reschedule(home,*this); for (int i=offset; i(dfa.n_symbols()); int n_supported = 0; const unsigned char* out = backward + static_cast(i+1)*k; - for (ViewValues v(x); v(); ++v) { + for (ViewValues v(x); v(); ++v) { bool support = false; for (DFA::Transitions t(dfa,v.val()); t() && !support; ++t) support = (reachable[t.i_state()] != 0) && @@ -223,7 +222,7 @@ namespace Gecode { namespace Int { namespace Extensional { for (int s=0; s value(x); value(); ++value) + for (ViewValues value(x); value(); ++value) for (DFA::Transitions t(dfa,value.val()); t(); ++t) if ((reachable[t.i_state()] != 0) && (out[t.o_state()] != 0)) @@ -260,23 +259,23 @@ namespace Gecode { namespace Int { namespace Extensional { dispose(Space& home) { home.ignore(*this,AP_DISPOSE); length.cancel(home,*this,PC_INT_VAL); - materialized.cancel(home,*this,PC_INT_BND); + sequence.cancel(home,*this); // On space deletion, the sequence buffer can already be disposed. if (!home.failed()) for (int i=offset; i sequence, DFA dfa) { for (int i=0; i + ::post(home,sequence,dfa))); + } + + void + extensional(Home home, OpenBoolVarSequence sequence, DFA dfa, + IntPropLevel) { + GECODE_POST; + GECODE_ES_FAIL((Int::Extensional::OpenRegular + ::post(home,sequence,dfa))); } } diff --git a/gecode/int/open-sequence.cpp b/gecode/int/open-sequence.cpp index 5d9ecdc8bd..8602119eb7 100644 --- a/gecode/int/open-sequence.cpp +++ b/gecode/int/open-sequence.cpp @@ -31,184 +31,19 @@ * */ -#include - -namespace Gecode { - - class OpenIntVarSequence::Sequence : public LocalObject { - public: - class Factory { - public: - Domain domain; - Transition transition; - - Factory(Domain domain0, Transition transition0) - : domain(domain0), transition(transition0) {} - }; - - IntVar length; - IntVar materialized; - IntVar* x; - int n; - int capacity; - SharedData factory; - - static int - maximum(int max) { - Int::Limits::check(max,"OpenIntVarSequence"); - if (max < 0) - throw Int::VariableEmptyDomain("OpenIntVarSequence"); - return max; - } - - static Domain - valid(Domain d) { - if (!d) - throw InvalidFunction("OpenIntVarSequence"); - return d; - } - - static Transition - valid(Transition t) { - if (!t) - throw InvalidFunction("OpenIntVarSequence"); - return t; - } - - Sequence(Home home, Domain d, int max) - : LocalObject(home), - length(home,0,maximum(max)), - materialized(home,0,max), - x(nullptr), n(0), capacity(0), - factory(Factory(valid(d),Transition())) { - home.notice(*this,AP_DISPOSE); - } - - Sequence(Home home, Domain d, Transition t, int max) - : LocalObject(home), - length(home,0,maximum(max)), - materialized(home,0,max), - x(nullptr), n(0), capacity(0), - factory(Factory(valid(d),valid(t))) { - home.notice(*this,AP_DISPOSE); - } - - Sequence(Space& home, Sequence& s) - : LocalObject(home,s), x(nullptr), n(s.n), capacity(s.n), - factory(s.factory) { - length.update(home,s.length); - materialized.update(home,s.materialized); - if (capacity > 0) { - x = heap.alloc(capacity); - try { - for (int i=0; i(x,capacity); - throw; - } - } - } - - virtual Actor* - copy(Space& home) { - return new (home) Sequence(home,*this); - } - - virtual size_t - dispose(Space& home) { - home.ignore(*this,AP_DISPOSE); - if (capacity > 0) - heap.free(x,capacity); - factory.~SharedData(); - return sizeof(*this); - } - - void - reserve(void) { - if (n == capacity) { - int next = (capacity < 4) ? 4 : capacity + capacity / 2; - x = heap.realloc(x,capacity,next); - capacity = next; - } - } - - void - append(IntVar y) { - x[n++] = y; - } - }; - -} - -namespace Gecode { namespace Int { - - /// Materialize positions required by the minimum eventual length - class OpenMaterialize : public Propagator { - protected: - OpenIntVarSequence sequence; - IntView length; - - OpenMaterialize(Home home, OpenIntVarSequence sequence0) - : Propagator(home), sequence(sequence0), length(sequence0.length()) { - length.subscribe(home,*this,PC_INT_BND); - } - - OpenMaterialize(Space& home, OpenMaterialize& p) - : Propagator(home,p) { - sequence.update(home,p.sequence); - length.update(home,p.length); - } - - public: - virtual Actor* - copy(Space& home) { - return new (home) OpenMaterialize(home,*this); - } - - virtual PropCost - cost(const Space&, const ModEventDelta&) const { - const int n = length.min()-sequence.size(); - return (n <= 1) ? PropCost::unary(PropCost::LO) : - PropCost::linear(PropCost::LO,n); - } - - virtual void - reschedule(Space& home) { - length.reschedule(home,*this,PC_INT_BND); - } - - virtual ExecStatus - propagate(Space& home, const ModEventDelta&) { - sequence.materialize(home,length.min()); - if (home.failed()) - return ES_FAILED; - if (length.assigned()) - return home.ES_SUBSUMED(*this); - return ES_FIX; - } - - virtual size_t - dispose(Space& home) { - length.cancel(home,*this,PC_INT_BND); - sequence.~OpenIntVarSequence(); - (void) Propagator::dispose(home); - return sizeof(*this); - } - - static void - post(Home home, OpenIntVarSequence sequence) { - if (!sequence.length().assigned()) - (void) new (home) OpenMaterialize(home,sequence); - } - }; - -}} +#include namespace Gecode { OpenIntVarSequence::OpenIntVarSequence(void) {} + OpenIntVarSequence::Factory + OpenIntVarSequence::factory(Domain d) { + if (!d) + throw InvalidFunction("OpenIntVarSequence"); + return [d](Space& home, int i) { return IntVar(home,d(i)); }; + } + OpenIntVarSequence::OpenIntVarSequence(Space& home, int max) : OpenIntVarSequence(home, IntSet(Int::Limits::min,Int::Limits::max),max) {} @@ -222,118 +57,22 @@ namespace Gecode { : OpenIntVarSequence(home,[d](int) { return d; },t,max) {} OpenIntVarSequence::OpenIntVarSequence(Space& home, Domain d, int max) - : LocalHandle(new (home) Sequence(home,d,max)) { - Int::OpenMaterialize::post(home,*this); - } + : OpenVarSequence(home,factory(d),max) {} OpenIntVarSequence::OpenIntVarSequence(Space& home, Domain d, Transition t, int max) - : LocalHandle(new (home) Sequence(home,d,t,max)) { - Int::OpenMaterialize::post(home,*this); - } - - void - OpenIntVarSequence::update(Space& home, OpenIntVarSequence& s) { - LocalHandle::update(home,s); - } - - int - OpenIntVarSequence::size(void) const { - return static_cast(object())->n; - } + : OpenVarSequence(home,factory(d),t,max) {} - IntVar - OpenIntVarSequence::operator [](int i) const { - Sequence* s = static_cast(object()); - assert((i >= 0) && (i < s->n)); - return s->x[i]; - } - - IntVar - OpenIntVarSequence::length(void) const { - return static_cast(object())->length; - } + OpenBoolVarSequence::OpenBoolVarSequence(void) {} - IntVar - OpenIntVarSequence::materialized(void) const { - return static_cast(object())->materialized; - } - - void - OpenIntVarSequence::append(Space& home, IntVar y) { - if (home.failed()) - return; - Sequence* s = static_cast(object()); - if (s->n == Int::Limits::max) { - home.fail(); - return; - } - for (int i=0; in; i++) - if (!y.assigned() && !s->x[i].assigned() && - (y.varimp() == s->x[i].varimp())) - throw Int::ArgumentSame("OpenIntVarSequence::append"); - s->reserve(); - const int next = s->n + 1; - Int::IntView l(s->length); - Int::IntView m(s->materialized); - if (me_failed(l.gq(home,next)) || me_failed(m.gq(home,next))) { - home.fail(); - return; - } - s->append(y); - const Transition& transition = s->factory().transition; - if (transition) { - GECODE_VALID_FUNCTION(transition); - transition(home,*this,next-1); - } - } - - void - OpenIntVarSequence::materialize(Space& home, int n) { - if (home.failed()) - return; - Int::Limits::nonnegative(n,"OpenIntVarSequence::materialize"); - Sequence* s = static_cast(object()); - Int::IntView l(s->length); - if (me_failed(l.gq(home,n))) { - home.fail(); - return; - } - while (s->n < l.min()) { - const int i = s->n; - GECODE_VALID_FUNCTION(s->factory().domain); - IntVar y(home,s->factory().domain(i)); - append(home,y); - if (home.failed()) - return; - } - } - - IntVar - OpenIntVarSequence::get(Space& home, int i) { - Int::Limits::nonnegative(i,"OpenIntVarSequence::get"); - if (home.failed()) - return IntVar(); - Sequence* s = static_cast(object()); - if (i >= s->length.max()) - throw Int::OutOfLimits("OpenIntVarSequence::get"); - materialize(home,i+1); - if (home.failed()) - return IntVar(); - return static_cast(object())->x[i]; - } + OpenBoolVarSequence::OpenBoolVarSequence(Space& home, int max) + : OpenVarSequence(home, + [](Space& home, int) { return BoolVar(home,0,1); },max) {} - void - OpenIntVarSequence::close(Space& home) { - if (home.failed()) - return; - materialize(home,length().min()); - if (home.failed()) - return; - Sequence* s = static_cast(object()); - if (me_failed(Int::IntView(s->length).eq(home,s->n))) - home.fail(); - } + OpenBoolVarSequence::OpenBoolVarSequence(Space& home, Transition t, + int max) + : OpenVarSequence(home, + [](Space& home, int) { return BoolVar(home,0,1); },t,max) {} } @@ -343,22 +82,20 @@ namespace Gecode { namespace Int { protected: OpenIntVarSequence sequence; IntView length; - IntView materialized; int posted; OpenSequencePropagator(Home home, OpenIntVarSequence sequence0) : Propagator(home), sequence(sequence0), length(sequence0.length()), - materialized(sequence0.materialized()), posted(0) { + posted(0) { length.subscribe(home,*this,PC_INT_BND); - materialized.subscribe(home,*this,PC_INT_BND); + sequence.subscribe(home,*this); } OpenSequencePropagator(Space& home, OpenSequencePropagator& p) : Propagator(home,p), posted(p.posted) { sequence.update(home,p.sequence); length.update(home,p.length); - materialized.update(home,p.materialized); } bool @@ -369,7 +106,7 @@ namespace Gecode { namespace Int { void dispose_base(Space& home) { length.cancel(home,*this,PC_INT_BND); - materialized.cancel(home,*this,PC_INT_BND); + sequence.cancel(home,*this); sequence.~OpenIntVarSequence(); (void) Propagator::dispose(home); } @@ -383,7 +120,7 @@ namespace Gecode { namespace Int { virtual void reschedule(Space& home) { length.reschedule(home,*this,PC_INT_BND); - materialized.reschedule(home,*this,PC_INT_BND); + sequence.reschedule(home,*this); } }; @@ -756,131 +493,291 @@ namespace Gecode { namespace Int { }; - template + /// Standard view/value selectors over the materialized prefix + template class OpenSequenceBrancher : public Brancher { protected: - class Description : public Choice { - public: - enum Kind { - VALUE, - HORIZON - }; - - const Kind kind; - const int position; - const int value; - - Description(const Brancher& b, Kind kind0, int position0, int value0) - : Choice(b,2), kind(kind0), - position(position0), value(value0) {} - - virtual void - archive(Archive& e) const { - Choice::archive(e); - e << static_cast(kind) << position << value; - } - }; - - OpenIntVarSequence sequence; - - OpenSequenceBrancher(Home home, OpenIntVarSequence sequence0) - : Brancher(home), sequence(sequence0) {} + typedef typename View::VarType Var; + OpenVarSequence sequence; + ViewSel* vs[n]; + ValSelCommitBase* vsc; + BrancherFilter filter; + SharedData> printer; + OpenVarBranch order; + IntValBranch::Select values; + mutable int start; + + OpenSequenceBrancher(Home home, OpenVarSequence sequence0, + ViewSel* vs0[n], + ValSelCommitBase* vsc0, + OpenVarBranch order0, IntValBranch::Select values0, + BranchFilter bf, VarValPrint vvp) + : Brancher(home), sequence(sequence0), vsc(vsc0), + filter(bf ? bf : [](const Space&, Var, int) { return true; }), + printer(vvp), order(order0), values(values0), start(0) { + for (int i=0; icopy(home) : nullptr), + filter(b.filter), printer(b.printer), order(b.order), + values(b.values), start(b.start) { sequence.update(home,b.sequence); + for (int i=0; icopy(home); + } + + /// Select from a temporary array, keeping positions stable across growth + int + position(Space& home) { + Region r; + ViewArray x(r,sequence.size()); + for (int i=0; iselect(home,x,start,filter); + int* ties = r.alloc(x.size()-start); + int n_ties; + vs[0]->ties(home,x,start,ties,n_ties,filter); + for (int i=1; (i1); i++) + vs[i]->brk(home,x,ties,n_ties); + return (n_ties > 1) ? vs[n-1]->select(home,x,ties,n_ties) : ties[0]; + } + + static const Choice* + value_choice(const Brancher& b, int i, IntView x) { + return new Branch::PosValuesChoice(b,Pos(i),x); + } + + static const Choice* + value_choice(const Brancher&, int, BoolView) { + GECODE_NEVER; + return nullptr; + } + + int + value(const Choice& c, unsigned int a) const { + const Branch::PosValuesChoice& pvc = + static_cast(c); + return pvc.val(values == IntValBranch::SEL_VALUES_MIN + ? a : pvc.alternatives()-1-a); } public: virtual bool - status(const Space&) const { - if (horizon_first && + status(const Space& home) const { + if ((order == OVB_HORIZON_FIRST) && (sequence.length().max() > sequence.size())) return true; - for (int i=0; i sequence.size(); } virtual const Choice* - choice(Space&) { - if (horizon_first && + choice(Space& home) { + if ((order == OVB_HORIZON_FIRST) && (sequence.length().max() > sequence.size())) - return new Description(*this,Description::HORIZON, - sequence.size(),0); - for (int i=0; i sequence.size()); - return new Description(*this,Description::HORIZON, - sequence.size(),0); + return new PosValChoice(*this,2,Pos(-1),sequence.size()); + for (int i=start; i(*this,2,Pos(p),vsc->val(home,x,p)) + : value_choice(*this,p,x); + } + return new PosValChoice(*this,2,Pos(-1),sequence.size()); } virtual const Choice* choice(const Space&, Archive& e) { - unsigned int kind; - int position, value; - e >> kind >> position >> value; - return new Description(*this, - static_cast(kind), - position,value); + int p; + e >> p; + if ((p < 0) || vsc) { + int v; + e >> v; + return new PosValChoice(*this,2,Pos(p),v); + } + unsigned int a; + e >> a; + return new Branch::PosValuesChoice(*this,a,Pos(p),e); } virtual ExecStatus - commit(Space& home, const Choice& choice0, unsigned int alternative) { - const Description& choice = - static_cast(choice0); - if (choice.kind == Description::VALUE) { - IntView x(sequence[choice.position]); - ModEvent me = (alternative == 0) - ? x.eq(home,choice.value) - : x.nq(home,choice.value); + commit(Space& home, const Choice& c, unsigned int a) { + const int p = static_cast(c).pos().pos; + if (p >= 0) { + View x(sequence[p]); + const ModEvent me = vsc + ? vsc->commit(home,a,x,p,static_cast&>(c).val()) + : x.eq(home,value(c,a)); return me_failed(me) ? ES_FAILED : ES_OK; } - if (alternative == 0) { - IntView length(sequence.length()); - return me_failed(length.eq(home,choice.position)) + const int size = static_cast&>(c).val(); + if (a == 0) + return me_failed(IntView(sequence.length()).eq(home,size)) ? ES_FAILED : ES_OK; - } - sequence.materialize(home,choice.position+1); + sequence.materialize(home,size+1); return home.failed() ? ES_FAILED : ES_OK; } + virtual NGL* + ngl(Space& home, const Choice& c, unsigned int a) const { + const int p = static_cast(c).pos().pos; + if (p < 0) + return (a == 0) ? new (home) Branch::EqNGL + (home,IntView(sequence.length()), + static_cast&>(c).val()) : nullptr; + View x(sequence[p]); + return vsc + ? vsc->ngl(home,a,x,static_cast&>(c).val()) + : new (home) Branch::EqNGL(home,x,value(c,a)); + } + virtual void - print(const Space&, const Choice& choice0, unsigned int alternative, + print(const Space& home, const Choice& c, unsigned int a, std::ostream& o) const { - const Description& choice = - static_cast(choice0); - if (choice.kind == Description::VALUE) { - o << "sequence[" << choice.position << "] " - << ((alternative == 0) ? "=" : "!=") << " " << choice.value; - } else if (alternative == 0) { - o << "sequence length = " << choice.position; + const int p = static_cast(c).pos().pos; + if (p < 0) { + o << "sequence length " << ((a == 0) ? "=" : ">") << " " + << static_cast&>(c).val(); } else { - o << "sequence length > " << choice.position; + View x(sequence[p]); + const int v = vsc ? static_cast&>(c).val() + : value(c,a); + if (printer()) + printer()(home,*this,a,sequence[p],p,v,o); + else if (vsc) + vsc->print(home,a,x,p,v,o); + else + o << "sequence[" << p << "] = " << v; } } virtual Actor* copy(Space& home) { - return new (home) OpenSequenceBrancher(home,*this); + return new (home) OpenSequenceBrancher(home,*this); } virtual size_t dispose(Space& home) { - sequence.~OpenIntVarSequence(); + home.ignore(*this,AP_DISPOSE,true); + for (int i=0; idispose(home); + if (vsc) + vsc->dispose(home); + filter.dispose(home); + printer.~SharedData>(); + sequence.~OpenVarSequence(); (void) Brancher::dispose(home); return sizeof(*this); } + template static void - post(Home home, OpenIntVarSequence sequence) { - (void) new (home) OpenSequenceBrancher(home,sequence); + post(Home home, OpenVarSequence sequence, VarBranch vars[n], + ValSelCommitBase* vsc, + OpenVarBranch order, IntValBranch::Select values, + BranchFilter bf, VarValPrint vvp) { + ViewSel* vs[n]; + for (int i=0; i* + open_valselcommit(Home home, IntValBranch vals) { + return ((vals.select() == IntValBranch::SEL_VALUES_MIN) || + (vals.select() == IntValBranch::SEL_VALUES_MAX)) + ? nullptr : Branch::valselcommit(home,vals); + } + + ValSelCommitBase* + open_valselcommit(Home home, BoolValBranch vals) { + return Branch::valselcommit(home,vals); + } + + template + void + post_open_brancher(Home home, OpenVarSequence sequence, + TieBreak vars, ValBranch vals, + OpenVarBranch order, + BranchFilter bf, + VarValPrint vvp) { + if ((order != OVB_HORIZON_FIRST) && (order != OVB_VALUE_FIRST)) + throw UnknownBranching("Int::branch"); + VarBranch selectors[4] = {vars.a,vars.b,vars.c,vars.d}; + int n = 1; + while ((n < 4) && (selectors[n-1].select() != VarBranch::SEL_NONE) && + (selectors[n-1].select() != VarBranch::SEL_RND) && + (selectors[n].select() != VarBranch::SEL_NONE)) + n++; + typedef typename View::VarType Var; + typename ArrayTraits>::ArgsType x(sequence.size()); + for (int i=0; i sequence.size()); + selectors[i].expand(home,x); + } + const IntValBranch::Select values = + static_cast(vals.select()); + ValSelCommitBase* vsc = open_valselcommit(home,vals); + switch (n) { + case 1: + OpenSequenceBrancher::post + (home,sequence,selectors,vsc,order,values,bf,vvp); + break; + case 2: + OpenSequenceBrancher::post + (home,sequence,selectors,vsc,order,values,bf,vvp); + break; + case 3: + OpenSequenceBrancher::post + (home,sequence,selectors,vsc,order,values,bf,vvp); + break; + case 4: + OpenSequenceBrancher::post + (home,sequence,selectors,vsc,order,values,bf,vvp); + break; + } + } + }} namespace Gecode { @@ -984,23 +881,43 @@ namespace Gecode { } void - branch(Home home, OpenIntVarSequence sequence) { - branch(home,sequence,OIB_HORIZON_FIRST); + branch(Home home, OpenIntVarSequence sequence, OpenVarBranch order) { + branch(home,sequence,INT_VAR_NONE(),INT_VAL_MIN(),order); + } + + void + branch(Home home, OpenBoolVarSequence sequence, OpenVarBranch order) { + branch(home,sequence,BOOL_VAR_NONE(),BOOL_VAL_MIN(),order); + } + + void + branch(Home home, OpenIntVarSequence sequence, + IntVarBranch vars, IntValBranch vals, OpenVarBranch order, + IntBranchFilter bf, IntVarValPrint vvp) { + branch(home,sequence,TieBreak(vars),vals,order,bf,vvp); } void - branch(Home home, OpenIntVarSequence sequence, OpenIntBranch order) { + branch(Home home, OpenIntVarSequence sequence, + TieBreak vars, IntValBranch vals, OpenVarBranch order, + IntBranchFilter bf, IntVarValPrint vvp) { GECODE_POST; - switch (order) { - case OIB_HORIZON_FIRST: - Int::OpenSequenceBrancher::post(home,sequence); - break; - case OIB_VALUE_FIRST: - Int::OpenSequenceBrancher::post(home,sequence); - break; - default: - throw Int::UnknownBranching("Int::branch"); - } + Int::post_open_brancher(home,sequence,vars,vals,order,bf,vvp); + } + + void + branch(Home home, OpenBoolVarSequence sequence, + BoolVarBranch vars, BoolValBranch vals, OpenVarBranch order, + BoolBranchFilter bf, BoolVarValPrint vvp) { + branch(home,sequence,TieBreak(vars),vals,order,bf,vvp); + } + + void + branch(Home home, OpenBoolVarSequence sequence, + TieBreak vars, BoolValBranch vals, OpenVarBranch order, + BoolBranchFilter bf, BoolVarValPrint vvp) { + GECODE_POST; + Int::post_open_brancher(home,sequence,vars,vals,order,bf,vvp); } } diff --git a/gecode/int/open-sequence.hpp b/gecode/int/open-sequence.hpp new file mode 100644 index 0000000000..319443d084 --- /dev/null +++ b/gecode/int/open-sequence.hpp @@ -0,0 +1,364 @@ +/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */ +/* + * Main author: + * Mikael Zayenz Lagerkvist + * + * Copyright: + * Mikael Zayenz Lagerkvist, 2026 + * + * This file is part of Gecode, the generic constraint + * development environment: + * http://www.gecode.dev + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + */ + +namespace Gecode { + + template + class OpenVarSequence::Sequence : public LocalObject { + public: + class Functions { + public: + Factory create; + Transition transition; + + Functions(Factory create0, Transition transition0) + : create(create0), transition(transition0) {} + }; + + IntVar length; + IntVar materialized; + Var* x; + int n; + int capacity; + SharedData functions; + + static int + maximum(int max) { + Int::Limits::check(max,"OpenVarSequence"); + if (max < 0) + throw Int::VariableEmptyDomain("OpenVarSequence"); + return max; + } + + static Factory + valid(Factory create) { + if (!create) + throw InvalidFunction("OpenVarSequence"); + return create; + } + + static Transition + valid(Transition t) { + if (!t) + throw InvalidFunction("OpenVarSequence"); + return t; + } + + Sequence(Home home, Factory create, int max) + : LocalObject(home), + length(home,0,maximum(max)), + materialized(home,0,max), + x(nullptr), n(0), capacity(0), + functions(Functions(valid(create),Transition())) { + home.notice(*this,AP_DISPOSE); + } + + Sequence(Home home, Factory create, Transition t, int max) + : LocalObject(home), + length(home,0,maximum(max)), + materialized(home,0,max), + x(nullptr), n(0), capacity(0), + functions(Functions(valid(create),valid(t))) { + home.notice(*this,AP_DISPOSE); + } + + Sequence(Space& home, Sequence& s) + : LocalObject(home,s), x(nullptr), n(s.n), capacity(s.n), + functions(s.functions) { + length.update(home,s.length); + materialized.update(home,s.materialized); + if (capacity > 0) { + x = heap.alloc(capacity); + try { + for (int i=0; i(x,capacity); + throw; + } + } + } + + virtual Actor* + copy(Space& home) { + return new (home) Sequence(home,*this); + } + + virtual size_t + dispose(Space& home) { + home.ignore(*this,AP_DISPOSE); + if (capacity > 0) + heap.free(x,capacity); + functions.~SharedData(); + return sizeof(*this); + } + + void + reserve(void) { + if (n == capacity) { + int next = (capacity < 4) ? 4 : + capacity + std::min(capacity / 2,Int::Limits::max-capacity); + x = heap.realloc(x,capacity,next); + capacity = next; + } + } + + void + append(Var y) { + x[n++] = y; + } + }; + +} + +namespace Gecode { namespace Int { + + /// Materialize positions required by the minimum eventual length + template + class OpenMaterialize : public Propagator { + protected: + OpenVarSequence sequence; + IntView length; + + OpenMaterialize(Home home, OpenVarSequence sequence0) + : Propagator(home), sequence(sequence0), length(sequence0.length()) { + length.subscribe(home,*this,PC_INT_BND); + } + + OpenMaterialize(Space& home, OpenMaterialize& p) + : Propagator(home,p) { + sequence.update(home,p.sequence); + length.update(home,p.length); + } + + public: + virtual Actor* + copy(Space& home) { + return new (home) OpenMaterialize(home,*this); + } + + virtual PropCost + cost(const Space&, const ModEventDelta&) const { + const int n = length.min()-sequence.size(); + return (n <= 1) ? PropCost::unary(PropCost::LO) : + PropCost::linear(PropCost::LO,n); + } + + virtual void + reschedule(Space& home) { + length.reschedule(home,*this,PC_INT_BND); + } + + virtual ExecStatus + propagate(Space& home, const ModEventDelta&) { + sequence.materialize(home,length.min()); + if (home.failed()) + return ES_FAILED; + if (length.assigned()) + return home.ES_SUBSUMED(*this); + return ES_FIX; + } + + virtual size_t + dispose(Space& home) { + length.cancel(home,*this,PC_INT_BND); + sequence.~OpenVarSequence(); + (void) Propagator::dispose(home); + return sizeof(*this); + } + + static void + post(Home home, OpenVarSequence sequence) { + if (!sequence.length().assigned()) + (void) new (home) OpenMaterialize(home,sequence); + } + }; + +}} + +namespace Gecode { + + template + OpenVarSequence::OpenVarSequence(void) {} + + template + OpenVarSequence::OpenVarSequence(Space& home, Factory create, int max) + : LocalHandle(new (home) Sequence(home,create,max)) { + Int::OpenMaterialize::post(home,*this); + } + + template + OpenVarSequence::OpenVarSequence(Space& home, Factory create, + Transition t, int max) + : LocalHandle(new (home) Sequence(home,create,t,max)) { + Int::OpenMaterialize::post(home,*this); + } + + forceinline + OpenIntVarSequence::OpenIntVarSequence(const OpenVarSequence& x) + : OpenVarSequence(x) {} + + forceinline + OpenBoolVarSequence::OpenBoolVarSequence(const OpenVarSequence& x) + : OpenVarSequence(x) {} + + template + void + OpenVarSequence::update(Space& home, OpenVarSequence& s) { + LocalHandle::update(home,s); + } + + template + int + OpenVarSequence::size(void) const { + return static_cast(object())->n; + } + + template + Var + OpenVarSequence::operator [](int i) const { + Sequence* s = static_cast(object()); + assert((i >= 0) && (i < s->n)); + return s->x[i]; + } + + template + IntVar + OpenVarSequence::length(void) const { + return static_cast(object())->length; + } + + template + void + OpenVarSequence::append(Space& home, Var y) { + if (home.failed()) + return; + Sequence* s = static_cast(object()); + if (s->n == Int::Limits::max) { + home.fail(); + return; + } + for (int i=0; in; i++) + if (!y.assigned() && !s->x[i].assigned() && + (y.varimp() == s->x[i].varimp())) + throw Int::ArgumentSame("OpenVarSequence::append"); + s->reserve(); + const int next = s->n + 1; + Int::IntView l(s->length); + Int::IntView m(s->materialized); + if (me_failed(l.gq(home,next)) || me_failed(m.gq(home,next))) { + home.fail(); + return; + } + s->append(y); + const Transition& transition = s->functions().transition; + if (transition) { + GECODE_VALID_FUNCTION(transition); + transition(home,*this,next-1); + } + } + + template + void + OpenVarSequence::materialize(Space& home, int n) { + if (home.failed()) + return; + Int::Limits::nonnegative(n,"OpenVarSequence::materialize"); + Sequence* s = static_cast(object()); + Int::IntView l(s->length); + if (me_failed(l.gq(home,n))) { + home.fail(); + return; + } + while (s->n < l.min()) { + const int i = s->n; + GECODE_VALID_FUNCTION(s->functions().create); + Var y = s->functions().create(home,i); + append(home,y); + if (home.failed()) + return; + } + } + + template + Var + OpenVarSequence::get(Space& home, int i) { + Int::Limits::nonnegative(i,"OpenVarSequence::get"); + if (home.failed()) + return Var(); + Sequence* s = static_cast(object()); + if (i >= s->length.max()) + throw Int::OutOfLimits("OpenVarSequence::get"); + materialize(home,i+1); + if (home.failed()) + return Var(); + return static_cast(object())->x[i]; + } + + template + void + OpenVarSequence::close(Space& home) { + if (home.failed()) + return; + materialize(home,length().min()); + if (home.failed()) + return; + Sequence* s = static_cast(object()); + if (me_failed(Int::IntView(s->length).eq(home,s->n))) + home.fail(); + } + + template + void + OpenVarSequence::subscribe(Space& home, Propagator& p) { + Sequence* s = static_cast(object()); + Int::IntView(s->materialized).subscribe(home,p,Int::PC_INT_BND); + } + + template + void + OpenVarSequence::cancel(Space& home, Propagator& p) { + Sequence* s = static_cast(object()); + Int::IntView(s->materialized).cancel(home,p,Int::PC_INT_BND); + } + + template + void + OpenVarSequence::reschedule(Space& home, Propagator& p) { + Sequence* s = static_cast(object()); + Int::IntView(s->materialized).reschedule(home,p,Int::PC_INT_BND); + } + +} + +// STATISTICS: int-var diff --git a/test/int/open-sequence.cpp b/test/int/open-sequence.cpp index 294273962e..2f4490ce1f 100644 --- a/test/int/open-sequence.cpp +++ b/test/int/open-sequence.cpp @@ -35,6 +35,13 @@ #include +#ifdef GECODE_HAS_SET_VARS +#include +#endif +#ifdef GECODE_HAS_FLOAT_VARS +#include +#endif + #include namespace Test { namespace Int { @@ -112,7 +119,7 @@ namespace Test { namespace Int { if (order < 0) branch(*this,sequence); else - branch(*this,sequence,static_cast(order)); + branch(*this,sequence,static_cast(order)); } BranchOrderSpace(BranchOrderSpace& s) @@ -158,11 +165,334 @@ namespace Test { namespace Int { run(void) { using namespace Gecode; return check(-1,1) && - check(OIB_HORIZON_FIRST,1) && - check(OIB_VALUE_FIRST,3); + check(OVB_HORIZON_FIRST,1) && + check(OVB_VALUE_FIRST,3); + } + }; + + class SelectorSpace : public Gecode::Space { + public: + Gecode::OpenIntVarSequence sequence; + + SelectorSpace(Gecode::IntValBranch vals, Gecode::OpenVarBranch order) + : sequence(*this,[](int i) { return Gecode::IntSet(i,i+1); },3) { + using namespace Gecode; + branch(*this,sequence,tiebreak(INT_VAR_SIZE_MIN(),INT_VAR_MAX_MAX()), + vals,order); + } + + SelectorSpace(SelectorSpace& s) : Gecode::Space(s) { + sequence.update(*this,s.sequence); + } + + virtual Gecode::Space* + copy(void) { + return new SelectorSpace(*this); + } + }; + + class Selectors : public ::Test::Base { + public: + Selectors(void) : ::Test::Base("Int::OpenSequence::Selectors") {} + + virtual bool + run(void) { + using namespace Gecode; + const IntValBranch values[] = { + INT_VAL_MIN(), INT_VAL_MAX(), INT_VAL_MED(), INT_VAL_RND(Rnd(1)), + INT_VAL_SPLIT_MIN(), INT_VAL_SPLIT_MAX(), + INT_VAL_RANGE_MIN(), INT_VAL_RANGE_MAX(), + INT_VALUES_MIN(), INT_VALUES_MAX(), + INT_VAL([](const Space&, IntVar x, int) { return x.max(); }) + }; + for (const IntValBranch& vals : values) + for (int order=0; order<2; order++) { + SelectorSpace root(vals,static_cast(order)); + Search::Options options; + options.threads = 1; + options.c_d = 1000; + options.a_d = 1000; + DFS engine(&root,options); + int solutions = 0; + while (SelectorSpace* solution = engine.next()) { + bool valid = solution->sequence.length().assigned() && + (solution->sequence.length().val() == solution->sequence.size()); + for (int i=0; isequence.size(); i++) + valid &= solution->sequence[i].assigned() && + (solution->sequence[i].val() >= i) && + (solution->sequence[i].val() <= i+1); + delete solution; + if (!valid) + return false; + solutions++; + } + if (solutions != 15) + return false; + } + return true; + } + }; + + class SelectorChoiceSpace : public Gecode::Space { + public: + Gecode::OpenIntVarSequence sequence; + + SelectorChoiceSpace(Gecode::IntValBranch vals) + : sequence(*this,Gecode::IntSet({0,2,5}),3) { + using namespace Gecode; + sequence.materialize(*this,3); + branch(*this,sequence, + tiebreak(INT_VAR_SIZE_MIN(), + INT_VAR_MERIT_MAX([](const Space&, IntVar, int i) { + return i; + })),vals,OVB_VALUE_FIRST, + [](const Space&, IntVar, int i) { return i != 1; }, + [](const Space&, const Brancher&, unsigned int, IntVar, + int i, const int& value, std::ostream& out) { + out << i << ":" << value; + }); + } + + SelectorChoiceSpace(SelectorChoiceSpace& s) : Gecode::Space(s) { + sequence.update(*this,s.sequence); + } + + virtual Gecode::Space* + copy(void) { + return new SelectorChoiceSpace(*this); + } + }; + + class SelectorChoice : public ::Test::Base { + public: + SelectorChoice(void) : ::Test::Base("Int::OpenSequence::SelectorChoice") {} + + virtual bool + run(void) { + using namespace Gecode; + for (int multi=0; multi<2; multi++) { + SelectorChoiceSpace source(multi ? INT_VALUES_MAX() : INT_VAL_MAX()); + if (source.status() != SS_BRANCH) + return false; + const Choice* original = source.choice(); + Archive archive; + original->archive(archive); + const Choice* restored = source.choice(archive); + bool valid = restored->alternatives() == (multi ? 3U : 2U); + for (unsigned int a=0; aalternatives(); a++) { + SelectorChoiceSpace* clone = + static_cast(source.clone()); + clone->commit(*restored,a); + const int expected[] = {5,2,0}; + valid &= !clone->failed() && !clone->sequence[0].assigned() && + !clone->sequence[1].assigned(); + if (multi || (a == 0)) + valid &= clone->sequence[2].assigned() && + (clone->sequence[2].val() == expected[a]); + else + valid &= !clone->sequence[2].in(5); + delete clone; + } + SelectorChoiceSpace* excluded = + static_cast(source.clone()); + NGL* literal = excluded->ngl(*restored,0); + valid &= (literal != nullptr) && (literal->status(*excluded) == NGL::NONE); + if (literal) + valid &= (literal->prune(*excluded) != ES_FAILED) && + !excluded->sequence[2].in(5); + delete excluded; + std::ostringstream printed; + source.print(*restored,0,printed); + valid &= printed.str() == "2:5"; + delete restored; + delete original; + if (!valid) + return false; + } + return true; + } + }; + + class BoolSpace : public Gecode::Space { + public: + Gecode::OpenBoolVarSequence sequence; + + BoolSpace(Gecode::OpenVarBranch order) + : sequence(*this,3) { + using namespace Gecode; + DFA accepts_one(0,{{0,0,0},{0,1,1},{1,0,1},{1,1,1}},{1}); + extensional(*this,sequence,accepts_one); + branch(*this,sequence, + BOOL_VAR_MERIT_MAX([](const Space&, BoolVar, int i) { return i; }), + BOOL_VAL_MAX(),order); + } + + BoolSpace(BoolSpace& s) : Gecode::Space(s) { + sequence.update(*this,s.sequence); + } + + virtual Gecode::Space* + copy(void) { + return new BoolSpace(*this); + } + }; + + class BoolSequence : public ::Test::Base { + public: + BoolSequence(void) : ::Test::Base("Int::OpenSequence::Bool") {} + + virtual bool + run(void) { + using namespace Gecode; + for (int order=0; order<2; order++) + for (int recompute=0; recompute<2; recompute++) { + BoolSpace root(static_cast(order)); + Search::Options options; + options.threads = 1; + options.c_d = recompute ? 1000 : 1; + options.a_d = options.c_d; + DFS engine(&root,options); + int solutions = 0; + while (BoolSpace* solution = engine.next()) { + bool valid = solution->sequence.length().assigned() && + (solution->sequence.length().val() == solution->sequence.size()); + int ones = 0; + for (int i=0; isequence.size(); i++) { + valid &= solution->sequence[i].assigned(); + ones += solution->sequence[i].val(); + } + delete solution; + if (!valid || (ones == 0)) + return false; + solutions++; + } + if (solutions != 11) + return false; + } + return true; + } + }; + + class FactorySpace : public Gecode::Space { + public: +#ifdef GECODE_HAS_SET_VARS + Gecode::OpenVarSequence sets; +#endif +#ifdef GECODE_HAS_FLOAT_VARS + Gecode::OpenVarSequence floats; +#endif + + FactorySpace(void) { + using namespace Gecode; +#ifdef GECODE_HAS_SET_VARS + sets = OpenVarSequence(*this, + [](Space& home, int i) { + return SetVar(home,IntSet(i,i),IntSet(i,i)); + },3); + sets.materialize(*this,1); +#endif +#ifdef GECODE_HAS_FLOAT_VARS + floats = OpenVarSequence(*this, + [](Space& home, int i) { return FloatVar(home,i,i); },3); + floats.materialize(*this,1); +#endif + } + + FactorySpace(FactorySpace& s) : Gecode::Space(s) { +#ifdef GECODE_HAS_SET_VARS + sets.update(*this,s.sets); +#endif +#ifdef GECODE_HAS_FLOAT_VARS + floats.update(*this,s.floats); +#endif + } + + virtual Gecode::Space* + copy(void) { + return new FactorySpace(*this); + } + }; + + class Factory : public ::Test::Base { + public: + Factory(void) : ::Test::Base("Int::OpenSequence::Factory") {} + + virtual bool + run(void) { + using namespace Gecode; + FactorySpace source; + if (source.status() == SS_FAILED) + return false; + FactorySpace* clone = static_cast(source.clone()); +#ifdef GECODE_HAS_SET_VARS + clone->sets.materialize(*clone,3); + clone->sets.close(*clone); + source.sets.close(source); +#endif +#ifdef GECODE_HAS_FLOAT_VARS + clone->floats.materialize(*clone,3); + clone->floats.close(*clone); + source.floats.close(source); +#endif + bool valid = (clone->status() != SS_FAILED) && + (source.status() != SS_FAILED); +#ifdef GECODE_HAS_SET_VARS + valid &= (source.sets.size() == 1) && (clone->sets.size() == 3) && + (clone->sets.length().val() == 3) && + clone->sets[2].assigned() && (clone->sets[2].glbMin() == 2); +#endif +#ifdef GECODE_HAS_FLOAT_VARS + valid &= (source.floats.size() == 1) && (clone->floats.size() == 3) && + (clone->floats.length().val() == 3) && + clone->floats[2].assigned() && (clone->floats[2].min() == 2); +#endif + delete clone; + return valid; } }; + class FixedStatistics : public ::Test::Base { + public: + FixedStatistics(void) : ::Test::Base("Int::OpenSequence::FixedStatistics") {} + + virtual bool + run(void) { + using namespace Gecode; + for (int chb=0; chb<2; chb++) { + SelectorSpace open(INT_VAL_MIN(),OVB_VALUE_FIRST); + bool rejected = false; + try { + branch(open,open.sequence, + chb ? INT_VAR_CHB_MIN() : INT_VAR_ACTION_MIN(1.0), + INT_VAL_MIN()); + } catch (const Gecode::Int::UnknownBranching&) { + rejected = true; + } + if (!rejected) + return false; + SelectorChoiceSpace fixed(INT_VAL_MIN()); + branch(fixed,fixed.sequence, + chb ? INT_VAR_CHB_MIN() : INT_VAR_ACTION_MIN(1.0), + INT_VAL_MIN()); + DFS engine(&fixed); + int solutions = 0; + while (SelectorChoiceSpace* solution = engine.next()) { + solutions++; + delete solution; + } + if (solutions != 27) + return false; + } + return true; + } + }; + + Factory factory; + FixedStatistics fixed_statistics; + Selectors selectors; + SelectorChoice selector_choice; + BoolSequence bool_sequence; + class TransitionSpace : public Gecode::Space { public: Gecode::OpenIntVarSequence sequence; @@ -604,7 +934,7 @@ namespace Test { namespace Int { home.fail(); }); source.sequence.materialize(source,1); - branch(source,source.sequence,OIB_VALUE_FIRST); + branch(source,source.sequence,OVB_VALUE_FIRST); if (source.status() != SS_BRANCH) return false; const Choice* choice = source.choice(); From acfcd47787f2557e339d58516cae8918d6430180 Mon Sep 17 00:00:00 2001 From: Mikael Zayenz Lagerkvist Date: Mon, 5 Oct 2026 05:02:37 +0200 Subject: [PATCH 14/34] Fix open sequence no-good extraction and clone cleanup --- gecode/int/open-sequence.cpp | 20 ++++++++++++++--- test/int/open-sequence.cpp | 42 ++++++++++++++++++++++++++++++++++++ 2 files changed, 59 insertions(+), 3 deletions(-) diff --git a/gecode/int/open-sequence.cpp b/gecode/int/open-sequence.cpp index 8602119eb7..fb2b6d1da1 100644 --- a/gecode/int/open-sequence.cpp +++ b/gecode/int/open-sequence.cpp @@ -521,12 +521,23 @@ namespace Gecode { namespace Int { } OpenSequenceBrancher(Space& home, OpenSequenceBrancher& b) - : Brancher(home,b), vsc(b.vsc ? b.vsc->copy(home) : nullptr), + : Brancher(home,b), vsc(nullptr), filter(b.filter), printer(b.printer), order(b.order), values(b.values), start(b.start) { sequence.update(home,b.sequence); - for (int i=0; icopy(home); + int copied = 0; + try { + if (b.vsc) + vsc = b.vsc->copy(home); + for (; copiedcopy(home); + } catch (...) { + for (int i=0; idispose(home); + if (vsc) + vsc->dispose(home); + throw; + } } /// Select from a temporary array, keeping positions stable across growth @@ -634,6 +645,9 @@ namespace Gecode { namespace Int { return (a == 0) ? new (home) Branch::EqNGL (home,IntView(sequence.length()), static_cast&>(c).val()) : nullptr; + // No-good extraction can run in an ancestor with a shorter prefix. + if (p >= sequence.size()) + return nullptr; View x(sequence[p]); return vsc ? vsc->ngl(home,a,x,static_cast&>(c).val()) diff --git a/test/int/open-sequence.cpp b/test/int/open-sequence.cpp index 2f4490ce1f..5cb881cfed 100644 --- a/test/int/open-sequence.cpp +++ b/test/int/open-sequence.cpp @@ -233,6 +233,47 @@ namespace Test { namespace Int { } }; + class NoGoods : public ::Test::Base { + public: + NoGoods(void) : ::Test::Base("Int::OpenSequence::NoGoods") {} + + virtual bool + run(void) { + using namespace Gecode; + SelectorSpace root(INT_VAL_MIN(),OVB_VALUE_FIRST); + root.sequence.materialize(root,1); + Search::NodeStop stop(6); + Search::Options options; + options.stop = &stop; + options.threads = 1; + options.nogoods_limit = 100; + std::unique_ptr engine + (Search::dfsengine(&root,options)); + bool found[16] = {}; + const auto record = [&found](SelectorSpace* solution) { + int code = 1; + for (int i=0; isequence.size(); i++) + code = 2*code + solution->sequence[i].val()-i; + found[code] = true; + delete solution; + }; + while (Space* solution = engine->next()) + record(static_cast(solution)); + if (!engine->stopped()) + return false; + // Deeper choices refer to positions absent from the restart root. + engine->nogoods().post(root); + DFS restarted(&root); + while (SelectorSpace* solution = restarted.next()) + record(solution); + // Extraction may omit literals, but must retain every unvisited word. + for (int code=2; code<16; code++) + if (!found[code]) + return false; + return true; + } + }; + class SelectorChoiceSpace : public Gecode::Space { public: Gecode::OpenIntVarSequence sequence; @@ -490,6 +531,7 @@ namespace Test { namespace Int { Factory factory; FixedStatistics fixed_statistics; Selectors selectors; + NoGoods no_goods; SelectorChoice selector_choice; BoolSequence bool_sequence; From 6c768fd6b28f7eaad3024719bf41340b92287cdd Mon Sep 17 00:00:00 2001 From: Mikael Zayenz Lagerkvist Date: Mon, 5 Oct 2026 08:18:01 +0200 Subject: [PATCH 15/34] Keep delayed open-sequence constraints in their posting group --- Makefile.dep | 1034 ++++++++++++++++++++-------------- gecode/int/open-sequence.cpp | 30 +- test/int/open-sequence.cpp | 81 +++ 3 files changed, 717 insertions(+), 428 deletions(-) diff --git a/Makefile.dep b/Makefile.dep index e6c20d7d10..bbd2349183 100644 --- a/Makefile.dep +++ b/Makefile.dep @@ -1042,7 +1042,7 @@ gecode/search/cpprofiler/tracer$(OBJSUFFIX) gecode/search/cpprofiler/tracer$(SBJ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/int/int-set$(OBJSUFFIX) gecode/int/int-set$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -1105,7 +1105,7 @@ gecode/int/int-set$(OBJSUFFIX) gecode/int/int-set$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/var-imp/int$(OBJSUFFIX) gecode/int/var-imp/int$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -1168,7 +1168,7 @@ gecode/int/var-imp/int$(OBJSUFFIX) gecode/int/var-imp/int$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/var-imp/bool$(OBJSUFFIX) gecode/int/var-imp/bool$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -1231,7 +1231,7 @@ gecode/int/var-imp/bool$(OBJSUFFIX) gecode/int/var-imp/bool$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/var/int$(OBJSUFFIX) gecode/int/var/int$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -1294,7 +1294,7 @@ gecode/int/var/int$(OBJSUFFIX) gecode/int/var/int$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/var/bool$(OBJSUFFIX) gecode/int/var/bool$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -1357,7 +1357,7 @@ gecode/int/var/bool$(OBJSUFFIX) gecode/int/var/bool$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/array$(OBJSUFFIX) gecode/int/array$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -1420,7 +1420,7 @@ gecode/int/array$(OBJSUFFIX) gecode/int/array$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/bool$(OBJSUFFIX) gecode/int/bool$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/bool.hh ./gecode/int/bool/base.hpp ./gecode/int/bool/clause.hpp \ ./gecode/int/bool/eq.hpp ./gecode/int/bool/eqv.hpp ./gecode/int/bool/ite.hpp \ ./gecode/int/bool/lq.hpp ./gecode/int/bool/or.hpp ./gecode/int/branch.hpp \ @@ -1487,7 +1487,7 @@ gecode/int/bool$(OBJSUFFIX) gecode/int/bool$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/bool/eqv$(OBJSUFFIX) gecode/int/bool/eqv$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/bool.hh ./gecode/int/bool/base.hpp ./gecode/int/bool/clause.hpp \ ./gecode/int/bool/eq.hpp ./gecode/int/bool/eqv.hpp ./gecode/int/bool/ite.hpp \ ./gecode/int/bool/lq.hpp ./gecode/int/bool/or.hpp ./gecode/int/branch.hpp \ @@ -1554,7 +1554,7 @@ gecode/int/bool/eqv$(OBJSUFFIX) gecode/int/bool/eqv$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/extensional/dfa$(OBJSUFFIX) gecode/int/extensional/dfa$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -1617,7 +1617,7 @@ gecode/int/extensional/dfa$(OBJSUFFIX) gecode/int/extensional/dfa$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/extensional/tuple-set$(OBJSUFFIX) gecode/int/extensional/tuple-set$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -1680,7 +1680,7 @@ gecode/int/extensional/tuple-set$(OBJSUFFIX) gecode/int/extensional/tuple-set$(S ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/extensional-regular$(OBJSUFFIX) gecode/int/extensional-regular$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -1746,7 +1746,7 @@ gecode/int/extensional-regular$(OBJSUFFIX) gecode/int/extensional-regular$(SBJSU ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/extensional-tuple-set$(OBJSUFFIX) gecode/int/extensional-tuple-set$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -1812,7 +1812,7 @@ gecode/int/extensional-tuple-set$(OBJSUFFIX) gecode/int/extensional-tuple-set$(S ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/dom$(OBJSUFFIX) gecode/int/dom$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -1878,7 +1878,7 @@ gecode/int/dom$(OBJSUFFIX) gecode/int/dom$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/int/rel$(OBJSUFFIX) gecode/int/rel$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/bool.hh ./gecode/int/bool/base.hpp ./gecode/int/bool/clause.hpp \ ./gecode/int/bool/eq.hpp ./gecode/int/bool/eqv.hpp ./gecode/int/bool/ite.hpp \ ./gecode/int/bool/lq.hpp ./gecode/int/bool/or.hpp ./gecode/int/branch.hpp \ @@ -1945,7 +1945,7 @@ gecode/int/rel$(OBJSUFFIX) gecode/int/rel$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/precede$(OBJSUFFIX) gecode/int/precede$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -2009,7 +2009,7 @@ gecode/int/precede$(OBJSUFFIX) gecode/int/precede$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/int/element$(OBJSUFFIX) gecode/int/element$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -2076,7 +2076,7 @@ gecode/int/element$(OBJSUFFIX) gecode/int/element$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/int/count$(OBJSUFFIX) gecode/int/count$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -2146,7 +2146,7 @@ gecode/int/count$(OBJSUFFIX) gecode/int/count$(SBJSUFFIX): \ gecode/int/arithmetic$(OBJSUFFIX) gecode/int/arithmetic$(SBJSUFFIX): \ ./gecode/int/arithmetic/gcd.hpp ./gecode/int/arithmetic/divides.hpp \ ./gecode/int/arithmetic/product.hpp ./gecode/int/arithmetic/product-mod.hpp \ - ./gecode/int.hh ./gecode/int/arithmetic.hh ./gecode/int/arithmetic/abs.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/arithmetic.hh ./gecode/int/arithmetic/abs.hpp \ ./gecode/int/arithmetic/argmax.hpp ./gecode/int/arithmetic/divmod.hpp ./gecode/int/arithmetic/max.hpp \ ./gecode/int/arithmetic/mult.hpp ./gecode/int/arithmetic/nroot.hpp ./gecode/int/arithmetic/pow-ops.hpp \ ./gecode/int/arithmetic/pow.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ @@ -2221,7 +2221,7 @@ gecode/int/arithmetic$(OBJSUFFIX) gecode/int/arithmetic$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/exec$(OBJSUFFIX) gecode/int/exec$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -2285,7 +2285,7 @@ gecode/int/exec$(OBJSUFFIX) gecode/int/exec$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/int/exec/when$(OBJSUFFIX) gecode/int/exec/when$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -2349,7 +2349,7 @@ gecode/int/exec/when$(OBJSUFFIX) gecode/int/exec/when$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/int/element/pair$(OBJSUFFIX) gecode/int/element/pair$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -2416,7 +2416,7 @@ gecode/int/element/pair$(OBJSUFFIX) gecode/int/element/pair$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/int/linear/int-post$(OBJSUFFIX) gecode/int/linear/int-post$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/bool.hh ./gecode/int/bool/base.hpp ./gecode/int/bool/clause.hpp \ ./gecode/int/bool/eq.hpp ./gecode/int/bool/eqv.hpp ./gecode/int/bool/ite.hpp \ ./gecode/int/bool/lq.hpp ./gecode/int/bool/or.hpp ./gecode/int/branch.hpp \ @@ -2487,7 +2487,7 @@ gecode/int/linear/int-post$(OBJSUFFIX) gecode/int/linear/int-post$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/int/linear-int$(OBJSUFFIX) gecode/int/linear-int$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/bool.hh ./gecode/int/bool/base.hpp ./gecode/int/bool/clause.hpp \ ./gecode/int/bool/eq.hpp ./gecode/int/bool/eqv.hpp ./gecode/int/bool/ite.hpp \ ./gecode/int/bool/lq.hpp ./gecode/int/bool/or.hpp ./gecode/int/branch.hpp \ @@ -2558,7 +2558,7 @@ gecode/int/linear-int$(OBJSUFFIX) gecode/int/linear-int$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/int/linear/bool-post$(OBJSUFFIX) gecode/int/linear/bool-post$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/bool.hh ./gecode/int/bool/base.hpp ./gecode/int/bool/clause.hpp \ ./gecode/int/bool/eq.hpp ./gecode/int/bool/eqv.hpp ./gecode/int/bool/ite.hpp \ ./gecode/int/bool/lq.hpp ./gecode/int/bool/or.hpp ./gecode/int/branch.hpp \ @@ -2629,7 +2629,7 @@ gecode/int/linear/bool-post$(OBJSUFFIX) gecode/int/linear/bool-post$(SBJSUFFIX): ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/int/linear-bool$(OBJSUFFIX) gecode/int/linear-bool$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/bool.hh ./gecode/int/bool/base.hpp ./gecode/int/bool/clause.hpp \ ./gecode/int/bool/eq.hpp ./gecode/int/bool/eqv.hpp ./gecode/int/bool/ite.hpp \ ./gecode/int/bool/lq.hpp ./gecode/int/bool/or.hpp ./gecode/int/branch.hpp \ @@ -2700,7 +2700,7 @@ gecode/int/linear-bool$(OBJSUFFIX) gecode/int/linear-bool$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/int/branch$(OBJSUFFIX) gecode/int/branch$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hh ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/cbs.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/merit.hpp ./gecode/int/branch/ngl.hpp \ @@ -2765,7 +2765,7 @@ gecode/int/branch$(OBJSUFFIX) gecode/int/branch$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/distinct/eqite$(OBJSUFFIX) gecode/int/distinct/eqite$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -2835,7 +2835,7 @@ gecode/int/distinct/eqite$(OBJSUFFIX) gecode/int/distinct/eqite$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/distinct/cbs$(OBJSUFFIX) gecode/int/distinct/cbs$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -2905,7 +2905,7 @@ gecode/int/distinct/cbs$(OBJSUFFIX) gecode/int/distinct/cbs$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/distinct$(OBJSUFFIX) gecode/int/distinct$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/bool.hh ./gecode/int/bool/base.hpp ./gecode/int/bool/clause.hpp \ ./gecode/int/bool/eq.hpp ./gecode/int/bool/eqv.hpp ./gecode/int/bool/ite.hpp \ ./gecode/int/bool/lq.hpp ./gecode/int/bool/or.hpp ./gecode/int/branch.hpp \ @@ -2978,7 +2978,7 @@ gecode/int/distinct$(OBJSUFFIX) gecode/int/distinct$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/int/sorted$(OBJSUFFIX) gecode/int/sorted$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -3050,7 +3050,7 @@ gecode/int/sorted$(OBJSUFFIX) gecode/int/sorted$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/gcc$(OBJSUFFIX) gecode/int/gcc$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/bool.hh ./gecode/int/bool/base.hpp ./gecode/int/bool/clause.hpp \ ./gecode/int/bool/eq.hpp ./gecode/int/bool/eqv.hpp ./gecode/int/bool/ite.hpp \ ./gecode/int/bool/lq.hpp ./gecode/int/bool/or.hpp ./gecode/int/branch.hpp \ @@ -3129,7 +3129,7 @@ gecode/int/gcc$(OBJSUFFIX) gecode/int/gcc$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/int/channel$(OBJSUFFIX) gecode/int/channel$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hh \ @@ -3201,7 +3201,7 @@ gecode/int/channel$(OBJSUFFIX) gecode/int/channel$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/channel/link-single$(OBJSUFFIX) gecode/int/channel/link-single$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hh \ @@ -3273,7 +3273,7 @@ gecode/int/channel/link-single$(OBJSUFFIX) gecode/int/channel/link-single$(SBJSU ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/channel/link-multi$(OBJSUFFIX) gecode/int/channel/link-multi$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hh \ @@ -3345,7 +3345,7 @@ gecode/int/channel/link-multi$(OBJSUFFIX) gecode/int/channel/link-multi$(SBJSUFF ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/unshare$(OBJSUFFIX) gecode/int/unshare$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/bool.hh ./gecode/int/bool/base.hpp ./gecode/int/bool/clause.hpp \ ./gecode/int/bool/eq.hpp ./gecode/int/bool/eqv.hpp ./gecode/int/bool/ite.hpp \ ./gecode/int/bool/lq.hpp ./gecode/int/bool/or.hpp ./gecode/int/branch.hpp \ @@ -3412,7 +3412,7 @@ gecode/int/unshare$(OBJSUFFIX) gecode/int/unshare$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/sequence$(OBJSUFFIX) gecode/int/sequence$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -3478,7 +3478,7 @@ gecode/int/sequence$(OBJSUFFIX) gecode/int/sequence$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/bin-packing$(OBJSUFFIX) gecode/int/bin-packing$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/bin-packing.hh ./gecode/int/bin-packing/conflict-graph.hpp ./gecode/int/bin-packing/propagate.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ @@ -3549,7 +3549,7 @@ gecode/int/bin-packing$(OBJSUFFIX) gecode/int/bin-packing$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/bin-packing/propagate$(OBJSUFFIX) gecode/int/bin-packing/propagate$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/bin-packing.hh ./gecode/int/bin-packing/conflict-graph.hpp ./gecode/int/bin-packing/propagate.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ @@ -3620,7 +3620,7 @@ gecode/int/bin-packing/propagate$(OBJSUFFIX) gecode/int/bin-packing/propagate$(S ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/bin-packing/conflict-graph$(OBJSUFFIX) gecode/int/bin-packing/conflict-graph$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/bin-packing.hh ./gecode/int/bin-packing/conflict-graph.hpp ./gecode/int/bin-packing/propagate.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ @@ -3691,7 +3691,7 @@ gecode/int/bin-packing/conflict-graph$(OBJSUFFIX) gecode/int/bin-packing/conflic ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/order$(OBJSUFFIX) gecode/int/order$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -3756,7 +3756,7 @@ gecode/int/order$(OBJSUFFIX) gecode/int/order$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/order/propagate$(OBJSUFFIX) gecode/int/order/propagate$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -3821,7 +3821,7 @@ gecode/int/order/propagate$(OBJSUFFIX) gecode/int/order/propagate$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/unary$(OBJSUFFIX) gecode/int/unary$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -3899,7 +3899,7 @@ gecode/int/unary$(OBJSUFFIX) gecode/int/unary$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/int/cumulative$(OBJSUFFIX) gecode/int/cumulative$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -3974,7 +3974,7 @@ gecode/int/cumulative$(OBJSUFFIX) gecode/int/cumulative$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/cumulatives$(OBJSUFFIX) gecode/int/cumulatives$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -4038,7 +4038,7 @@ gecode/int/cumulatives$(OBJSUFFIX) gecode/int/cumulatives$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/int/circuit$(OBJSUFFIX) gecode/int/circuit$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -4109,7 +4109,7 @@ gecode/int/circuit$(OBJSUFFIX) gecode/int/circuit$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/no-overlap$(OBJSUFFIX) gecode/int/no-overlap$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -4174,7 +4174,7 @@ gecode/int/no-overlap$(OBJSUFFIX) gecode/int/no-overlap$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/nvalues$(OBJSUFFIX) gecode/int/nvalues$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/bool.hh ./gecode/int/bool/base.hpp ./gecode/int/bool/clause.hpp \ ./gecode/int/bool/eq.hpp ./gecode/int/bool/eqv.hpp ./gecode/int/bool/ite.hpp \ ./gecode/int/bool/lq.hpp ./gecode/int/bool/or.hpp ./gecode/int/branch.hpp \ @@ -4251,7 +4251,7 @@ gecode/int/nvalues$(OBJSUFFIX) gecode/int/nvalues$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/member$(OBJSUFFIX) gecode/int/member$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -4317,7 +4317,7 @@ gecode/int/member$(OBJSUFFIX) gecode/int/member$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/branch/action$(OBJSUFFIX) gecode/int/branch/action$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -4380,7 +4380,7 @@ gecode/int/branch/action$(OBJSUFFIX) gecode/int/branch/action$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/branch/chb$(OBJSUFFIX) gecode/int/branch/chb$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -4445,7 +4445,7 @@ gecode/int/branch/chb$(OBJSUFFIX) gecode/int/branch/chb$(SBJSUFFIX): \ gecode/int/arithmetic/mult$(OBJSUFFIX) gecode/int/arithmetic/mult$(SBJSUFFIX): \ ./gecode/int/arithmetic/gcd.hpp ./gecode/int/arithmetic/divides.hpp \ ./gecode/int/arithmetic/product.hpp ./gecode/int/arithmetic/product-mod.hpp \ - ./gecode/int.hh ./gecode/int/arithmetic.hh ./gecode/int/arithmetic/abs.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/arithmetic.hh ./gecode/int/arithmetic/abs.hpp \ ./gecode/int/arithmetic/argmax.hpp ./gecode/int/arithmetic/divmod.hpp ./gecode/int/arithmetic/max.hpp \ ./gecode/int/arithmetic/mult.hpp ./gecode/int/arithmetic/nroot.hpp ./gecode/int/arithmetic/pow-ops.hpp \ ./gecode/int/arithmetic/pow.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ @@ -4520,7 +4520,7 @@ gecode/int/arithmetic/mult$(OBJSUFFIX) gecode/int/arithmetic/mult$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/branch/view-sel$(OBJSUFFIX) gecode/int/branch/view-sel$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hh ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/cbs.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/merit.hpp ./gecode/int/branch/ngl.hpp \ @@ -4585,7 +4585,7 @@ gecode/int/branch/view-sel$(OBJSUFFIX) gecode/int/branch/view-sel$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/branch/val-sel-commit$(OBJSUFFIX) gecode/int/branch/val-sel-commit$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hh ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/cbs.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/merit.hpp ./gecode/int/branch/ngl.hpp \ @@ -4650,7 +4650,7 @@ gecode/int/branch/val-sel-commit$(OBJSUFFIX) gecode/int/branch/val-sel-commit$(S ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/branch/view-values$(OBJSUFFIX) gecode/int/branch/view-values$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hh ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/cbs.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/merit.hpp ./gecode/int/branch/ngl.hpp \ @@ -4715,7 +4715,7 @@ gecode/int/branch/view-values$(OBJSUFFIX) gecode/int/branch/view-values$(SBJSUFF ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/relax$(OBJSUFFIX) gecode/int/relax$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -4778,7 +4778,7 @@ gecode/int/relax$(OBJSUFFIX) gecode/int/relax$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/ldsb$(OBJSUFFIX) gecode/int/ldsb$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hh ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/cbs.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/merit.hpp ./gecode/int/branch/ngl.hpp \ @@ -4844,7 +4844,7 @@ gecode/int/ldsb$(OBJSUFFIX) gecode/int/ldsb$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/ldsb/sym-imp$(OBJSUFFIX) gecode/int/ldsb/sym-imp$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hh ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/cbs.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/merit.hpp ./gecode/int/branch/ngl.hpp \ @@ -4910,7 +4910,7 @@ gecode/int/ldsb/sym-imp$(OBJSUFFIX) gecode/int/ldsb/sym-imp$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/ldsb/sym-obj$(OBJSUFFIX) gecode/int/ldsb/sym-obj$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -4974,7 +4974,7 @@ gecode/int/ldsb/sym-obj$(OBJSUFFIX) gecode/int/ldsb/sym-obj$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/trace$(OBJSUFFIX) gecode/int/trace$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -5037,7 +5037,7 @@ gecode/int/trace$(OBJSUFFIX) gecode/int/trace$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/trace/tracer$(OBJSUFFIX) gecode/int/trace/tracer$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -5100,7 +5100,7 @@ gecode/int/trace/tracer$(OBJSUFFIX) gecode/int/trace/tracer$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/exception$(OBJSUFFIX) gecode/int/exception$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -5174,7 +5174,7 @@ gecode/float/var/float$(OBJSUFFIX) gecode/float/var/float$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -5248,7 +5248,7 @@ gecode/float/var-imp/float$(OBJSUFFIX) gecode/float/var-imp/float$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -5326,7 +5326,7 @@ gecode/float/arithmetic$(OBJSUFFIX) gecode/float/arithmetic$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -5400,7 +5400,7 @@ gecode/float/array$(OBJSUFFIX) gecode/float/array$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -5475,7 +5475,7 @@ gecode/float/branch$(OBJSUFFIX) gecode/float/branch$(SBJSUFFIX): \ ./gecode/float/var-imp/delta.hpp ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp \ ./gecode/float/var/print.hpp ./gecode/float/view.hpp ./gecode/float/view/float.hpp \ ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp \ - ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp ./gecode/int.hh \ + ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -5551,7 +5551,7 @@ gecode/float/rel$(OBJSUFFIX) gecode/float/rel$(SBJSUFFIX): \ ./gecode/float/var-imp/delta.hpp ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp \ ./gecode/float/var/print.hpp ./gecode/float/view.hpp ./gecode/float/view/float.hpp \ ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp \ - ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp ./gecode/int.hh \ + ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -5627,7 +5627,7 @@ gecode/float/linear$(OBJSUFFIX) gecode/float/linear$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -5703,7 +5703,7 @@ gecode/float/linear/post$(OBJSUFFIX) gecode/float/linear/post$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -5779,7 +5779,7 @@ gecode/float/bool$(OBJSUFFIX) gecode/float/bool$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -5854,7 +5854,7 @@ gecode/float/channel$(OBJSUFFIX) gecode/float/channel$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -5929,7 +5929,7 @@ gecode/float/transcendental$(OBJSUFFIX) gecode/float/transcendental$(SBJSUFFIX): ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -6004,7 +6004,7 @@ gecode/float/trigonometric$(OBJSUFFIX) gecode/float/trigonometric$(SBJSUFFIX): \ ./gecode/float/var-imp/delta.hpp ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp \ ./gecode/float/var/print.hpp ./gecode/float/view.hpp ./gecode/float/view/float.hpp \ ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp \ - ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp ./gecode/int.hh \ + ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -6079,7 +6079,7 @@ gecode/float/branch/action$(OBJSUFFIX) gecode/float/branch/action$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -6153,7 +6153,7 @@ gecode/float/branch/chb$(OBJSUFFIX) gecode/float/branch/chb$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -6227,7 +6227,7 @@ gecode/float/rounding$(OBJSUFFIX) gecode/float/rounding$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -6301,7 +6301,7 @@ gecode/float/exec$(OBJSUFFIX) gecode/float/exec$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -6376,7 +6376,7 @@ gecode/float/branch/val-sel-commit$(OBJSUFFIX) gecode/float/branch/val-sel-commi ./gecode/float/var-imp/delta.hpp ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp \ ./gecode/float/var/print.hpp ./gecode/float/view.hpp ./gecode/float/view/float.hpp \ ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp \ - ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp ./gecode/int.hh \ + ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -6452,7 +6452,7 @@ gecode/float/branch/view-sel$(OBJSUFFIX) gecode/float/branch/view-sel$(SBJSUFFIX ./gecode/float/var-imp/delta.hpp ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp \ ./gecode/float/var/print.hpp ./gecode/float/view.hpp ./gecode/float/view/float.hpp \ ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp \ - ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp ./gecode/int.hh \ + ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -6528,7 +6528,7 @@ gecode/float/dom$(OBJSUFFIX) gecode/float/dom$(SBJSUFFIX): \ ./gecode/float/var-imp/delta.hpp ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp \ ./gecode/float/var/print.hpp ./gecode/float/view.hpp ./gecode/float/view/float.hpp \ ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp \ - ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp ./gecode/int.hh \ + ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -6603,7 +6603,7 @@ gecode/float/relax$(OBJSUFFIX) gecode/float/relax$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -6678,7 +6678,7 @@ gecode/float/trace$(OBJSUFFIX) gecode/float/trace$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -6752,7 +6752,7 @@ gecode/float/trace/tracer$(OBJSUFFIX) gecode/float/trace/tracer$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -6826,7 +6826,7 @@ gecode/float/exception$(OBJSUFFIX) gecode/float/exception$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -6889,7 +6889,7 @@ gecode/float/exception$(OBJSUFFIX) gecode/float/exception$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/set/branch$(OBJSUFFIX) gecode/set/branch$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -6964,7 +6964,7 @@ gecode/set/branch$(OBJSUFFIX) gecode/set/branch$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/set/cardinality$(OBJSUFFIX) gecode/set/cardinality$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -7039,7 +7039,7 @@ gecode/set/cardinality$(OBJSUFFIX) gecode/set/cardinality$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/set/convex$(OBJSUFFIX) gecode/set/convex$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -7114,7 +7114,7 @@ gecode/set/convex$(OBJSUFFIX) gecode/set/convex$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/convex/conv$(OBJSUFFIX) gecode/set/convex/conv$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -7189,7 +7189,7 @@ gecode/set/convex/conv$(OBJSUFFIX) gecode/set/convex/conv$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/convex/hull$(OBJSUFFIX) gecode/set/convex/hull$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -7264,7 +7264,7 @@ gecode/set/convex/hull$(OBJSUFFIX) gecode/set/convex/hull$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/dom$(OBJSUFFIX) gecode/set/dom$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -7341,7 +7341,7 @@ gecode/set/dom$(OBJSUFFIX) gecode/set/dom$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/set/rel$(OBJSUFFIX) gecode/set/rel$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -7422,7 +7422,7 @@ gecode/set/rel$(OBJSUFFIX) gecode/set/rel$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/set/rel-op$(OBJSUFFIX) gecode/set/rel-op$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -7502,7 +7502,7 @@ gecode/set/rel-op$(OBJSUFFIX) gecode/set/rel-op$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/rel-op-ternary$(OBJSUFFIX) gecode/set/rel-op-ternary$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -7582,7 +7582,7 @@ gecode/set/rel-op-ternary$(OBJSUFFIX) gecode/set/rel-op-ternary$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/rel-op-singleton$(OBJSUFFIX) gecode/set/rel-op-singleton$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -7662,7 +7662,7 @@ gecode/set/rel-op-singleton$(OBJSUFFIX) gecode/set/rel-op-singleton$(SBJSUFFIX): ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/rel-op/post-compl$(OBJSUFFIX) gecode/set/rel-op/post-compl$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -7742,7 +7742,7 @@ gecode/set/rel-op/post-compl$(OBJSUFFIX) gecode/set/rel-op/post-compl$(SBJSUFFIX ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/rel-op/post-nocompl$(OBJSUFFIX) gecode/set/rel-op/post-nocompl$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -7822,7 +7822,7 @@ gecode/set/rel-op/post-nocompl$(OBJSUFFIX) gecode/set/rel-op/post-nocompl$(SBJSU ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/rel-op/post-compl-cvv$(OBJSUFFIX) gecode/set/rel-op/post-compl-cvv$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -7902,7 +7902,7 @@ gecode/set/rel-op/post-compl-cvv$(OBJSUFFIX) gecode/set/rel-op/post-compl-cvv$(S ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/rel-op/post-nocompl-cvv$(OBJSUFFIX) gecode/set/rel-op/post-nocompl-cvv$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -7982,7 +7982,7 @@ gecode/set/rel-op/post-nocompl-cvv$(OBJSUFFIX) gecode/set/rel-op/post-nocompl-cv ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/rel-op/post-compl-vvc$(OBJSUFFIX) gecode/set/rel-op/post-compl-vvc$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -8062,7 +8062,7 @@ gecode/set/rel-op/post-compl-vvc$(OBJSUFFIX) gecode/set/rel-op/post-compl-vvc$(S ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/rel-op/post-nocompl-vvc$(OBJSUFFIX) gecode/set/rel-op/post-nocompl-vvc$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -8142,7 +8142,7 @@ gecode/set/rel-op/post-nocompl-vvc$(OBJSUFFIX) gecode/set/rel-op/post-nocompl-vv ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/rel-op/post-compl-cvc$(OBJSUFFIX) gecode/set/rel-op/post-compl-cvc$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -8222,7 +8222,7 @@ gecode/set/rel-op/post-compl-cvc$(OBJSUFFIX) gecode/set/rel-op/post-compl-cvc$(S ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/rel-op/post-nocompl-cvc$(OBJSUFFIX) gecode/set/rel-op/post-nocompl-cvc$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -8302,7 +8302,7 @@ gecode/set/rel-op/post-nocompl-cvc$(OBJSUFFIX) gecode/set/rel-op/post-nocompl-cv ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/rel-op-const-vvc$(OBJSUFFIX) gecode/set/rel-op-const-vvc$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -8382,7 +8382,7 @@ gecode/set/rel-op-const-vvc$(OBJSUFFIX) gecode/set/rel-op-const-vvc$(SBJSUFFIX): ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/rel-op-const-vcv$(OBJSUFFIX) gecode/set/rel-op-const-vcv$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -8462,7 +8462,7 @@ gecode/set/rel-op-const-vcv$(OBJSUFFIX) gecode/set/rel-op-const-vcv$(SBJSUFFIX): ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/rel-op-const-vcc$(OBJSUFFIX) gecode/set/rel-op-const-vcc$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -8542,7 +8542,7 @@ gecode/set/rel-op-const-vcc$(OBJSUFFIX) gecode/set/rel-op-const-vcc$(SBJSUFFIX): ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/rel-op-const-cvc$(OBJSUFFIX) gecode/set/rel-op-const-cvc$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -8622,7 +8622,7 @@ gecode/set/rel-op-const-cvc$(OBJSUFFIX) gecode/set/rel-op-const-cvc$(SBJSUFFIX): ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/rel-op-const-cvv$(OBJSUFFIX) gecode/set/rel-op-const-cvv$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -8702,7 +8702,7 @@ gecode/set/rel-op-const-cvv$(OBJSUFFIX) gecode/set/rel-op-const-cvv$(SBJSUFFIX): ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/int$(OBJSUFFIX) gecode/set/int$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -8780,7 +8780,7 @@ gecode/set/int$(OBJSUFFIX) gecode/set/int$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/set/channel$(OBJSUFFIX) gecode/set/channel$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -8859,7 +8859,7 @@ gecode/set/channel$(OBJSUFFIX) gecode/set/channel$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/bool$(OBJSUFFIX) gecode/set/bool$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -8933,7 +8933,7 @@ gecode/set/bool$(OBJSUFFIX) gecode/set/bool$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/element$(OBJSUFFIX) gecode/set/element$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -9018,7 +9018,7 @@ gecode/set/element$(OBJSUFFIX) gecode/set/element$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/set/sequence$(OBJSUFFIX) gecode/set/sequence$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -9097,7 +9097,7 @@ gecode/set/sequence$(OBJSUFFIX) gecode/set/sequence$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/distinct$(OBJSUFFIX) gecode/set/distinct$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -9171,7 +9171,7 @@ gecode/set/distinct$(OBJSUFFIX) gecode/set/distinct$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/set/distinct/atmostOne$(OBJSUFFIX) gecode/set/distinct/atmostOne$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -9245,7 +9245,7 @@ gecode/set/distinct/atmostOne$(OBJSUFFIX) gecode/set/distinct/atmostOne$(SBJSUFF ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/set/precede$(OBJSUFFIX) gecode/set/precede$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -9319,7 +9319,7 @@ gecode/set/precede$(OBJSUFFIX) gecode/set/precede$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/set/sequence/seq$(OBJSUFFIX) gecode/set/sequence/seq$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -9398,7 +9398,7 @@ gecode/set/sequence/seq$(OBJSUFFIX) gecode/set/sequence/seq$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/sequence/seq-u$(OBJSUFFIX) gecode/set/sequence/seq-u$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -9477,7 +9477,7 @@ gecode/set/sequence/seq-u$(OBJSUFFIX) gecode/set/sequence/seq-u$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/array$(OBJSUFFIX) gecode/set/array$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -9551,7 +9551,7 @@ gecode/set/array$(OBJSUFFIX) gecode/set/array$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/var-imp/set$(OBJSUFFIX) gecode/set/var-imp/set$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -9625,7 +9625,7 @@ gecode/set/var-imp/set$(OBJSUFFIX) gecode/set/var-imp/set$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/var-imp/integerset$(OBJSUFFIX) gecode/set/var-imp/integerset$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -9699,7 +9699,7 @@ gecode/set/var-imp/integerset$(OBJSUFFIX) gecode/set/var-imp/integerset$(SBJSUFF ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/var/set$(OBJSUFFIX) gecode/set/var/set$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -9773,7 +9773,7 @@ gecode/set/var/set$(OBJSUFFIX) gecode/set/var/set$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/exec$(OBJSUFFIX) gecode/set/exec$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -9847,7 +9847,7 @@ gecode/set/exec$(OBJSUFFIX) gecode/set/exec$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/branch/action$(OBJSUFFIX) gecode/set/branch/action$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -9921,7 +9921,7 @@ gecode/set/branch/action$(OBJSUFFIX) gecode/set/branch/action$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/branch/chb$(OBJSUFFIX) gecode/set/branch/chb$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -9995,7 +9995,7 @@ gecode/set/branch/chb$(OBJSUFFIX) gecode/set/branch/chb$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/branch/view-sel$(OBJSUFFIX) gecode/set/branch/view-sel$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -10070,7 +10070,7 @@ gecode/set/branch/view-sel$(OBJSUFFIX) gecode/set/branch/view-sel$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/set/branch/val-sel-commit$(OBJSUFFIX) gecode/set/branch/val-sel-commit$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -10145,7 +10145,7 @@ gecode/set/branch/val-sel-commit$(OBJSUFFIX) gecode/set/branch/val-sel-commit$(S ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/set/branch/ngl$(OBJSUFFIX) gecode/set/branch/ngl$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -10220,7 +10220,7 @@ gecode/set/branch/ngl$(OBJSUFFIX) gecode/set/branch/ngl$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/set/ldsb$(OBJSUFFIX) gecode/set/ldsb$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -10297,7 +10297,7 @@ gecode/set/ldsb$(OBJSUFFIX) gecode/set/ldsb$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/set/ldsb/sym-imp$(OBJSUFFIX) gecode/set/ldsb/sym-imp$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -10372,7 +10372,7 @@ gecode/set/ldsb/sym-imp$(OBJSUFFIX) gecode/set/ldsb/sym-imp$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/set/relax$(OBJSUFFIX) gecode/set/relax$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -10446,7 +10446,7 @@ gecode/set/relax$(OBJSUFFIX) gecode/set/relax$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/set/trace$(OBJSUFFIX) gecode/set/trace$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -10520,7 +10520,7 @@ gecode/set/trace$(OBJSUFFIX) gecode/set/trace$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/trace/tracer$(OBJSUFFIX) gecode/set/trace/tracer$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -10594,7 +10594,7 @@ gecode/set/trace/tracer$(OBJSUFFIX) gecode/set/trace/tracer$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/exception$(OBJSUFFIX) gecode/set/exception$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -10679,7 +10679,7 @@ gecode/minimodel/int-expr$(OBJSUFFIX) gecode/minimodel/int-expr$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/bool.hh ./gecode/int/bool/base.hpp \ ./gecode/int/bool/clause.hpp ./gecode/int/bool/eq.hpp ./gecode/int/bool/eqv.hpp \ ./gecode/int/bool/ite.hpp ./gecode/int/bool/lq.hpp ./gecode/int/bool/or.hpp \ @@ -10777,7 +10777,7 @@ gecode/minimodel/int-rel$(OBJSUFFIX) gecode/minimodel/int-rel$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -10867,7 +10867,7 @@ gecode/minimodel/int-arith$(OBJSUFFIX) gecode/minimodel/int-arith$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -10957,7 +10957,7 @@ gecode/minimodel/bool-expr$(OBJSUFFIX) gecode/minimodel/bool-expr$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -11047,7 +11047,7 @@ gecode/minimodel/set-expr$(OBJSUFFIX) gecode/minimodel/set-expr$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -11137,7 +11137,7 @@ gecode/minimodel/set-rel$(OBJSUFFIX) gecode/minimodel/set-rel$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -11227,7 +11227,7 @@ gecode/minimodel/dom$(OBJSUFFIX) gecode/minimodel/dom$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -11318,7 +11318,7 @@ gecode/minimodel/float-expr$(OBJSUFFIX) gecode/minimodel/float-expr$(SBJSUFFIX): ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -11408,7 +11408,7 @@ gecode/minimodel/float-rel$(OBJSUFFIX) gecode/minimodel/float-rel$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -11498,7 +11498,7 @@ gecode/minimodel/float-arith$(OBJSUFFIX) gecode/minimodel/float-arith$(SBJSUFFIX ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -11588,7 +11588,7 @@ gecode/minimodel/reg$(OBJSUFFIX) gecode/minimodel/reg$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -11678,7 +11678,7 @@ gecode/minimodel/optimize$(OBJSUFFIX) gecode/minimodel/optimize$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -11768,7 +11768,7 @@ gecode/minimodel/exception$(OBJSUFFIX) gecode/minimodel/exception$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -11858,7 +11858,7 @@ gecode/minimodel/ipl$(OBJSUFFIX) gecode/minimodel/ipl$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -11950,7 +11950,7 @@ gecode/driver/options$(OBJSUFFIX) gecode/driver/options$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -12042,7 +12042,7 @@ gecode/driver/script$(OBJSUFFIX) gecode/driver/script$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -12134,7 +12134,7 @@ examples/alpha$(OBJSUFFIX) examples/alpha$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -12226,7 +12226,7 @@ examples/bacp$(OBJSUFFIX) examples/bacp$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hh ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/cbs.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/merit.hpp ./gecode/int/branch/ngl.hpp \ @@ -12320,7 +12320,7 @@ examples/bibd$(OBJSUFFIX) examples/bibd$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -12412,7 +12412,7 @@ examples/donald$(OBJSUFFIX) examples/donald$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -12504,7 +12504,7 @@ examples/efpa$(OBJSUFFIX) examples/efpa$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -12596,7 +12596,7 @@ examples/eq20$(OBJSUFFIX) examples/eq20$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -12688,7 +12688,7 @@ examples/golomb-ruler$(OBJSUFFIX) examples/golomb-ruler$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -12780,7 +12780,7 @@ examples/graph-color$(OBJSUFFIX) examples/graph-color$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -12872,7 +12872,7 @@ examples/grocery$(OBJSUFFIX) examples/grocery$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -12964,7 +12964,7 @@ examples/ind-set$(OBJSUFFIX) examples/ind-set$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -13056,7 +13056,7 @@ examples/magic-sequence$(OBJSUFFIX) examples/magic-sequence$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -13148,7 +13148,7 @@ examples/magic-square$(OBJSUFFIX) examples/magic-square$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -13240,7 +13240,7 @@ examples/money$(OBJSUFFIX) examples/money$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -13332,7 +13332,7 @@ examples/ortho-latin$(OBJSUFFIX) examples/ortho-latin$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -13424,7 +13424,7 @@ examples/partition$(OBJSUFFIX) examples/partition$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -13516,7 +13516,7 @@ examples/photo$(OBJSUFFIX) examples/photo$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -13608,7 +13608,7 @@ examples/queens$(OBJSUFFIX) examples/queens$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -13700,7 +13700,7 @@ examples/sudoku$(OBJSUFFIX) examples/sudoku$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -13792,7 +13792,7 @@ examples/sudoku-advanced$(OBJSUFFIX) examples/sudoku-advanced$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -13884,7 +13884,7 @@ examples/kakuro$(OBJSUFFIX) examples/kakuro$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -13976,7 +13976,7 @@ examples/nonogram$(OBJSUFFIX) examples/nonogram$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -14068,7 +14068,7 @@ examples/pentominoes$(OBJSUFFIX) examples/pentominoes$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -14160,7 +14160,7 @@ examples/crowded-chess$(OBJSUFFIX) examples/crowded-chess$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -14252,7 +14252,7 @@ examples/black-hole$(OBJSUFFIX) examples/black-hole$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -14344,7 +14344,7 @@ examples/minesweeper$(OBJSUFFIX) examples/minesweeper$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -14436,7 +14436,7 @@ examples/domino$(OBJSUFFIX) examples/domino$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -14528,7 +14528,7 @@ examples/steel-mill$(OBJSUFFIX) examples/steel-mill$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -14620,7 +14620,7 @@ examples/sports-league$(OBJSUFFIX) examples/sports-league$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -14712,7 +14712,7 @@ examples/all-interval$(OBJSUFFIX) examples/all-interval$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -14804,7 +14804,7 @@ examples/langford-number$(OBJSUFFIX) examples/langford-number$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -14896,7 +14896,7 @@ examples/warehouses$(OBJSUFFIX) examples/warehouses$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -14988,7 +14988,7 @@ examples/radiotherapy$(OBJSUFFIX) examples/radiotherapy$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -15080,7 +15080,7 @@ examples/word-square$(OBJSUFFIX) examples/word-square$(SBJSUFFIX): \ ./gecode/float/var/print.hpp ./gecode/float/view.hpp ./gecode/float/view/float.hpp \ ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp \ ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp ./gecode/gist.hh \ - ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -15172,7 +15172,7 @@ examples/crossword$(OBJSUFFIX) examples/crossword$(SBJSUFFIX): \ ./gecode/float/var/print.hpp ./gecode/float/view.hpp ./gecode/float/view/float.hpp \ ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp \ ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp ./gecode/gist.hh \ - ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -15264,7 +15264,7 @@ examples/open-shop$(OBJSUFFIX) examples/open-shop$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -15356,7 +15356,7 @@ examples/car-sequencing$(OBJSUFFIX) examples/car-sequencing$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -15448,7 +15448,7 @@ examples/sat$(OBJSUFFIX) examples/sat$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -15540,7 +15540,7 @@ examples/bin-packing$(OBJSUFFIX) examples/bin-packing$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -15632,7 +15632,7 @@ examples/knights$(OBJSUFFIX) examples/knights$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -15724,7 +15724,7 @@ examples/tsp$(OBJSUFFIX) examples/tsp$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -15816,7 +15816,7 @@ examples/perfect-square$(OBJSUFFIX) examples/perfect-square$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -15908,7 +15908,7 @@ examples/schurs-lemma$(OBJSUFFIX) examples/schurs-lemma$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -16000,7 +16000,7 @@ examples/dominating-queens$(OBJSUFFIX) examples/dominating-queens$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -16092,7 +16092,7 @@ examples/colored-matrix$(OBJSUFFIX) examples/colored-matrix$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -16184,7 +16184,7 @@ examples/multi-bin-packing$(OBJSUFFIX) examples/multi-bin-packing$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -16276,7 +16276,7 @@ examples/qcp$(OBJSUFFIX) examples/qcp$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -16368,7 +16368,7 @@ examples/job-shop$(OBJSUFFIX) examples/job-shop$(SBJSUFFIX): \ ./gecode/float/var/print.hpp ./gecode/float/view.hpp ./gecode/float/view/float.hpp \ ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp \ ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp ./gecode/gist.hh \ - ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -16460,7 +16460,7 @@ examples/crew$(OBJSUFFIX) examples/crew$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -16552,7 +16552,7 @@ examples/golf$(OBJSUFFIX) examples/golf$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -16644,7 +16644,7 @@ examples/hamming$(OBJSUFFIX) examples/hamming$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -16736,7 +16736,7 @@ examples/steiner$(OBJSUFFIX) examples/steiner$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -16828,7 +16828,7 @@ examples/queen-armies$(OBJSUFFIX) examples/queen-armies$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -16920,7 +16920,7 @@ examples/cartesian-heart$(OBJSUFFIX) examples/cartesian-heart$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -17012,7 +17012,7 @@ examples/descartes-folium$(OBJSUFFIX) examples/descartes-folium$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -17104,7 +17104,7 @@ examples/archimedean-spiral$(OBJSUFFIX) examples/archimedean-spiral$(SBJSUFFIX): ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -17196,7 +17196,7 @@ examples/golden-spiral$(OBJSUFFIX) examples/golden-spiral$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -17321,7 +17321,7 @@ gecode/gist/gist$(OBJSUFFIX) gecode/gist/gist$(SBJSUFFIX): \ ./gecode/gist/nodestats.hh ./gecode/gist/qtgist.hh ./gecode/gist/spacenode.hh \ ./gecode/gist/spacenode.hpp ./gecode/gist/stopbrancher.hh ./gecode/gist/textoutput.hh \ ./gecode/gist/treecanvas.hh ./gecode/gist/visualnode.hh ./gecode/gist/visualnode.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -17439,7 +17439,7 @@ gecode/gist/spacenode$(OBJSUFFIX) gecode/gist/spacenode$(SBJSUFFIX): \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ ./gecode/gist/node.hh ./gecode/gist/node.hpp ./gecode/gist/spacenode.hh \ ./gecode/gist/spacenode.hpp ./gecode/gist/stopbrancher.hh ./gecode/gist/visualnode.hh \ - ./gecode/gist/visualnode.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/gist/visualnode.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -17532,7 +17532,7 @@ gecode/gist/treecanvas$(OBJSUFFIX) gecode/gist/treecanvas$(SBJSUFFIX): \ ./gecode/gist/nodecursor.hh ./gecode/gist/nodecursor.hpp ./gecode/gist/nodevisitor.hh \ ./gecode/gist/nodevisitor.hpp ./gecode/gist/spacenode.hh ./gecode/gist/spacenode.hpp \ ./gecode/gist/treecanvas.hh ./gecode/gist/visualnode.hh ./gecode/gist/visualnode.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -17622,7 +17622,7 @@ gecode/gist/qtgist$(OBJSUFFIX) gecode/gist/qtgist$(SBJSUFFIX): \ ./gecode/gist/nodecursor.hpp ./gecode/gist/nodestats.hh ./gecode/gist/nodevisitor.hh \ ./gecode/gist/nodevisitor.hpp ./gecode/gist/qtgist.hh ./gecode/gist/spacenode.hh \ ./gecode/gist/spacenode.hpp ./gecode/gist/treecanvas.hh ./gecode/gist/visualnode.hh \ - ./gecode/gist/visualnode.hpp ./gecode/gist/zoomToFitIcon.hpp ./gecode/int.hh \ + ./gecode/gist/visualnode.hpp ./gecode/gist/zoomToFitIcon.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -17744,7 +17744,7 @@ gecode/gist/nodestats$(OBJSUFFIX) gecode/gist/nodestats$(SBJSUFFIX): \ ./gecode/gist/nodevisitor.hh ./gecode/gist/nodevisitor.hpp ./gecode/gist/nodewidget.hh \ ./gecode/gist/qtgist.hh ./gecode/gist/spacenode.hh ./gecode/gist/spacenode.hpp \ ./gecode/gist/treecanvas.hh ./gecode/gist/visualnode.hh ./gecode/gist/visualnode.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -17835,7 +17835,7 @@ gecode/gist/nodewidget$(OBJSUFFIX) gecode/gist/nodewidget$(SBJSUFFIX): \ ./gecode/gist/nodecursor.hh ./gecode/gist/nodecursor.hpp ./gecode/gist/nodestats.hh \ ./gecode/gist/nodewidget.hh ./gecode/gist/qtgist.hh ./gecode/gist/spacenode.hh \ ./gecode/gist/spacenode.hpp ./gecode/gist/treecanvas.hh ./gecode/gist/visualnode.hh \ - ./gecode/gist/visualnode.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/gist/visualnode.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -17927,7 +17927,7 @@ gecode/gist/mainwindow$(OBJSUFFIX) gecode/gist/mainwindow$(SBJSUFFIX): \ ./gecode/gist/nodecursor.hpp ./gecode/gist/nodestats.hh ./gecode/gist/nodewidget.hh \ ./gecode/gist/preferences.hh ./gecode/gist/qtgist.hh ./gecode/gist/spacenode.hh \ ./gecode/gist/spacenode.hpp ./gecode/gist/treecanvas.hh ./gecode/gist/visualnode.hh \ - ./gecode/gist/visualnode.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/gist/visualnode.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -18013,7 +18013,7 @@ gecode/gist/preferences$(OBJSUFFIX) gecode/gist/preferences$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/gist/preferences.hh ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/gist/preferences.hh ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -18099,7 +18099,7 @@ gecode/gist/stopbrancher$(OBJSUFFIX) gecode/gist/stopbrancher$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/gist/stopbrancher.hh ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/gist/stopbrancher.hh ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -18189,7 +18189,7 @@ gecode/flatzinc/flatzinc$(OBJSUFFIX) gecode/flatzinc/flatzinc$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hh ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/cbs.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/merit.hpp ./gecode/int/branch/ngl.hpp \ @@ -18285,7 +18285,7 @@ gecode/flatzinc/registry$(OBJSUFFIX) gecode/flatzinc/registry$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -18379,7 +18379,7 @@ gecode/flatzinc/branch$(OBJSUFFIX) gecode/flatzinc/branch$(SBJSUFFIX): \ ./gecode/float/var/print.hpp ./gecode/float/view.hpp ./gecode/float/view/float.hpp \ ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp \ ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp ./gecode/gist.hh \ - ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hh ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/cbs.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/merit.hpp \ @@ -18475,7 +18475,7 @@ tools/flatzinc/fzn-gecode$(OBJSUFFIX) tools/flatzinc/fzn-gecode$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -18571,7 +18571,7 @@ gecode/flatzinc/parser.tab$(OBJSUFFIX) gecode/flatzinc/parser.tab$(SBJSUFFIX): \ ./gecode/float/var/print.hpp ./gecode/float/view.hpp ./gecode/float/view/float.hpp \ ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp \ ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp ./gecode/gist.hh \ - ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -18677,7 +18677,7 @@ gecode/flatzinc/lexer.yy$(OBJSUFFIX) gecode/flatzinc/lexer.yy$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -18757,7 +18757,7 @@ gecode/flatzinc/lexer.yy$(OBJSUFFIX) gecode/flatzinc/lexer.yy$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp test/test$(OBJSUFFIX) test/test$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -18821,7 +18821,7 @@ test/test$(OBJSUFFIX) test/test$(SBJSUFFIX): \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp ./test/test.hh \ ./test/test.hpp test/afc$(OBJSUFFIX) test/afc$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -18896,7 +18896,7 @@ test/ldsb$(OBJSUFFIX) test/ldsb$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hh ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/cbs.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/merit.hpp \ @@ -18980,7 +18980,7 @@ test/ldsb$(OBJSUFFIX) test/ldsb$(SBJSUFFIX): \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp \ ./test/test.hh ./test/test.hpp test/region$(OBJSUFFIX) test/region$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -19044,7 +19044,7 @@ test/region$(OBJSUFFIX) test/region$(SBJSUFFIX): \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp ./test/test.hh \ ./test/test.hpp test/groups$(OBJSUFFIX) test/groups$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -19108,7 +19108,7 @@ test/groups$(OBJSUFFIX) test/groups$(SBJSUFFIX): \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp ./test/test.hh \ ./test/test.hpp test/int$(OBJSUFFIX) test/int$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -19183,7 +19183,7 @@ test/int/channel$(OBJSUFFIX) test/int/channel$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -19264,20 +19264,6 @@ test/int/channel$(OBJSUFFIX) test/int/channel$(SBJSUFFIX): \ ./test/int.hh ./test/int.hpp ./test/test.hh \ ./test/test.hpp test/int/arithmetic$(OBJSUFFIX) test/int/arithmetic$(SBJSUFFIX): \ - ./gecode/int/arithmetic.hh ./gecode/int/arithmetic/abs.hpp ./gecode/int/arithmetic/argmax.hpp \ - ./gecode/int/arithmetic/divides.hpp ./gecode/int/arithmetic/divmod.hpp ./gecode/int/arithmetic/gcd.hpp \ - ./gecode/int/arithmetic/max.hpp ./gecode/int/arithmetic/mult.hpp ./gecode/int/arithmetic/nroot.hpp \ - ./gecode/int/arithmetic/pow-ops.hpp ./gecode/int/arithmetic/pow.hpp ./gecode/int/arithmetic/product-mod.hpp \ - ./gecode/int/arithmetic/product.hpp ./gecode/int/bool.hh ./gecode/int/bool/base.hpp \ - ./gecode/int/bool/clause.hpp ./gecode/int/bool/eq.hpp ./gecode/int/bool/eqv.hpp \ - ./gecode/int/bool/ite.hpp ./gecode/int/bool/lq.hpp ./gecode/int/bool/or.hpp \ - ./gecode/int/idx-view.hh ./gecode/int/idx-view.hpp ./gecode/int/linear.hh \ - ./gecode/int/linear/bool-int.hpp ./gecode/int/linear/bool-scale.hpp ./gecode/int/linear/bool-view.hpp \ - ./gecode/int/linear/int-bin.hpp ./gecode/int/linear/int-dom.hpp ./gecode/int/linear/int-nary.hpp \ - ./gecode/int/linear/int-noview.hpp ./gecode/int/linear/int-ter.hpp ./gecode/int/linear/post.hpp \ - ./gecode/int/rel.hh ./gecode/int/rel/eq.hpp ./gecode/int/rel/lex.hpp \ - ./gecode/int/rel/lq-le.hpp ./gecode/int/rel/nq.hpp ./gecode/int/support-values.hh \ - ./gecode/int/support-values.hpp \ ./gecode/float.hh ./gecode/float/array-traits.hpp ./gecode/float/array.hpp \ ./gecode/float/branch.hpp ./gecode/float/branch/action.hpp ./gecode/float/branch/afc.hpp \ ./gecode/float/branch/assign.hpp ./gecode/float/branch/chb.hpp ./gecode/float/branch/traits.hpp \ @@ -19289,7 +19275,7 @@ test/int/arithmetic$(OBJSUFFIX) test/int/arithmetic$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -19370,7 +19356,7 @@ test/int/arithmetic$(OBJSUFFIX) test/int/arithmetic$(SBJSUFFIX): \ ./test/int.hh ./test/int.hpp ./test/test.hh \ ./test/test.hpp test/int/basic$(OBJSUFFIX) test/int/basic$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -19445,7 +19431,7 @@ test/int/bool$(OBJSUFFIX) test/int/bool$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -19526,7 +19512,7 @@ test/int/bool$(OBJSUFFIX) test/int/bool$(SBJSUFFIX): \ ./test/int.hh ./test/int.hpp ./test/test.hh \ ./test/test.hpp test/int/count$(OBJSUFFIX) test/int/count$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -19601,7 +19587,7 @@ test/int/dom$(OBJSUFFIX) test/int/dom$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -19693,7 +19679,7 @@ test/int/distinct$(OBJSUFFIX) test/int/distinct$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -19785,7 +19771,7 @@ test/int/element$(OBJSUFFIX) test/int/element$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -19877,7 +19863,7 @@ test/int/extensional$(OBJSUFFIX) test/int/extensional$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -19969,7 +19955,7 @@ test/int/rel$(OBJSUFFIX) test/int/rel$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -20061,7 +20047,7 @@ test/int/linear$(OBJSUFFIX) test/int/linear$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -20142,7 +20128,7 @@ test/int/linear$(OBJSUFFIX) test/int/linear$(SBJSUFFIX): \ ./test/int.hh ./test/int.hpp ./test/test.hh \ ./test/test.hpp test/int/gcc$(OBJSUFFIX) test/int/gcc$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -20206,7 +20192,7 @@ test/int/gcc$(OBJSUFFIX) test/int/gcc$(SBJSUFFIX): \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp ./test/int.hh \ ./test/int.hpp ./test/test.hh ./test/test.hpp test/int/sorted$(OBJSUFFIX) test/int/sorted$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -20281,7 +20267,7 @@ test/int/unshare$(OBJSUFFIX) test/int/unshare$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -20373,7 +20359,7 @@ test/int/exec$(OBJSUFFIX) test/int/exec$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -20465,7 +20451,7 @@ test/int/sequence$(OBJSUFFIX) test/int/sequence$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -20557,7 +20543,7 @@ test/int/mm-arithmetic$(OBJSUFFIX) test/int/mm-arithmetic$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -20649,7 +20635,7 @@ test/int/mm-bool$(OBJSUFFIX) test/int/mm-bool$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -20741,7 +20727,7 @@ test/int/mm-lin$(OBJSUFFIX) test/int/mm-lin$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -20833,7 +20819,7 @@ test/int/mm-count$(OBJSUFFIX) test/int/mm-count$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -20925,7 +20911,7 @@ test/int/mm-rel$(OBJSUFFIX) test/int/mm-rel$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -21017,7 +21003,7 @@ test/int/bin-packing$(OBJSUFFIX) test/int/bin-packing$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -21109,7 +21095,7 @@ test/int/order$(OBJSUFFIX) test/int/order$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -21201,7 +21187,7 @@ test/int/unary$(OBJSUFFIX) test/int/unary$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -21293,7 +21279,7 @@ test/int/cumulative$(OBJSUFFIX) test/int/cumulative$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -21397,7 +21383,7 @@ test/int/cumulatives$(OBJSUFFIX) test/int/cumulatives$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -21489,7 +21475,7 @@ test/int/circuit$(OBJSUFFIX) test/int/circuit$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -21581,7 +21567,7 @@ test/int/no-overlap$(OBJSUFFIX) test/int/no-overlap$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -21662,7 +21648,7 @@ test/int/no-overlap$(OBJSUFFIX) test/int/no-overlap$(SBJSUFFIX): \ ./test/int.hh ./test/int.hpp ./test/test.hh \ ./test/test.hpp test/int/precede$(OBJSUFFIX) test/int/precede$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -21737,7 +21723,7 @@ test/int/nvalues$(OBJSUFFIX) test/int/nvalues$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -21829,7 +21815,7 @@ test/int/member$(OBJSUFFIX) test/int/member$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -21910,7 +21896,7 @@ test/int/member$(OBJSUFFIX) test/int/member$(SBJSUFFIX): \ ./test/int.hh ./test/int.hpp ./test/test.hh \ ./test/test.hpp test/set$(OBJSUFFIX) test/set$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -21986,7 +21972,7 @@ test/set$(OBJSUFFIX) test/set$(SBJSUFFIX): \ ./test/set.hh ./test/set.hpp ./test/test.hh \ ./test/test.hpp test/set/construct$(OBJSUFFIX) test/set/construct$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -22073,7 +22059,7 @@ test/set/dom$(OBJSUFFIX) test/set/dom$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -22165,7 +22151,7 @@ test/set/rel$(OBJSUFFIX) test/set/rel$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -22246,7 +22232,7 @@ test/set/rel$(OBJSUFFIX) test/set/rel$(SBJSUFFIX): \ ./test/int.hh ./test/int.hpp ./test/set.hh \ ./test/set.hpp ./test/test.hh ./test/test.hpp test/set/rel-op$(OBJSUFFIX) test/set/rel-op$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -22322,7 +22308,7 @@ test/set/rel-op$(OBJSUFFIX) test/set/rel-op$(SBJSUFFIX): \ ./test/set.hh ./test/set.hpp ./test/test.hh \ ./test/test.hpp test/set/rel-op-const$(OBJSUFFIX) test/set/rel-op-const$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -22398,7 +22384,7 @@ test/set/rel-op-const$(OBJSUFFIX) test/set/rel-op-const$(SBJSUFFIX): \ ./test/set.hh ./test/set.hpp ./test/test.hh \ ./test/test.hpp test/set/convex$(OBJSUFFIX) test/set/convex$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -22474,7 +22460,7 @@ test/set/convex$(OBJSUFFIX) test/set/convex$(SBJSUFFIX): \ ./test/set.hh ./test/set.hpp ./test/test.hh \ ./test/test.hpp test/set/sequence$(OBJSUFFIX) test/set/sequence$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -22561,7 +22547,7 @@ test/set/int$(OBJSUFFIX) test/set/int$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -22653,7 +22639,7 @@ test/set/element$(OBJSUFFIX) test/set/element$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -22734,7 +22720,7 @@ test/set/element$(OBJSUFFIX) test/set/element$(SBJSUFFIX): \ ./test/int.hh ./test/int.hpp ./test/set.hh \ ./test/set.hpp ./test/test.hh ./test/test.hpp test/set/precede$(OBJSUFFIX) test/set/precede$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -22810,7 +22796,7 @@ test/set/precede$(OBJSUFFIX) test/set/precede$(SBJSUFFIX): \ ./test/set.hh ./test/set.hpp ./test/test.hh \ ./test/test.hpp test/set/distinct$(OBJSUFFIX) test/set/distinct$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -22886,7 +22872,7 @@ test/set/distinct$(OBJSUFFIX) test/set/distinct$(SBJSUFFIX): \ ./test/set.hh ./test/set.hpp ./test/test.hh \ ./test/test.hpp test/set/exec$(OBJSUFFIX) test/set/exec$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -22973,7 +22959,7 @@ test/set/mm-set$(OBJSUFFIX) test/set/mm-set$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -23065,7 +23051,7 @@ test/set/channel$(OBJSUFFIX) test/set/channel$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -23157,7 +23143,7 @@ test/float$(OBJSUFFIX) test/float$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -23233,7 +23219,7 @@ test/float/basic$(OBJSUFFIX) test/float/basic$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -23309,7 +23295,7 @@ test/float/arithmetic$(OBJSUFFIX) test/float/arithmetic$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -23401,7 +23387,7 @@ test/float/transcendental$(OBJSUFFIX) test/float/transcendental$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -23493,7 +23479,7 @@ test/float/trigonometric$(OBJSUFFIX) test/float/trigonometric$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -23585,7 +23571,7 @@ test/float/linear$(OBJSUFFIX) test/float/linear$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -23677,7 +23663,7 @@ test/float/rel$(OBJSUFFIX) test/float/rel$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -23769,7 +23755,7 @@ test/float/channel$(OBJSUFFIX) test/float/channel$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -23861,7 +23847,7 @@ test/float/mm-lin$(OBJSUFFIX) test/float/mm-lin$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -23953,7 +23939,7 @@ test/float/dom$(OBJSUFFIX) test/float/dom$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -24045,7 +24031,7 @@ test/branch$(OBJSUFFIX) test/branch$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -24131,7 +24117,7 @@ test/branch/int$(OBJSUFFIX) test/branch/int$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -24217,7 +24203,7 @@ test/branch/bool$(OBJSUFFIX) test/branch/bool$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -24303,7 +24289,7 @@ test/branch/set$(OBJSUFFIX) test/branch/set$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -24389,7 +24375,7 @@ test/branch/float$(OBJSUFFIX) test/branch/float$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -24475,7 +24461,7 @@ test/assign$(OBJSUFFIX) test/assign$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -24561,7 +24547,7 @@ test/assign/int$(OBJSUFFIX) test/assign/int$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -24647,7 +24633,7 @@ test/assign/bool$(OBJSUFFIX) test/assign/bool$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -24733,7 +24719,7 @@ test/assign/set$(OBJSUFFIX) test/assign/set$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -24819,7 +24805,7 @@ test/assign/float$(OBJSUFFIX) test/assign/float$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -24905,7 +24891,7 @@ test/search$(OBJSUFFIX) test/search$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -24996,7 +24982,7 @@ test/nogoods$(OBJSUFFIX) test/nogoods$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -25076,7 +25062,7 @@ test/nogoods$(OBJSUFFIX) test/nogoods$(SBJSUFFIX): \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp \ ./test/test.hh ./test/test.hpp test/array$(OBJSUFFIX) test/array$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -25154,7 +25140,7 @@ test/flatzinc$(OBJSUFFIX) test/flatzinc$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -25249,7 +25235,7 @@ test/flatzinc/bool_clause$(OBJSUFFIX) test/flatzinc/bool_clause$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -25344,7 +25330,7 @@ test/flatzinc/bug232$(OBJSUFFIX) test/flatzinc/bug232$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -25439,7 +25425,7 @@ test/flatzinc/bug319$(OBJSUFFIX) test/flatzinc/bug319$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -25534,7 +25520,7 @@ test/flatzinc/bugfix_r6746$(OBJSUFFIX) test/flatzinc/bugfix_r6746$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -25629,7 +25615,7 @@ test/flatzinc/bugfix_r7854$(OBJSUFFIX) test/flatzinc/bugfix_r7854$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -25724,7 +25710,7 @@ test/flatzinc/empty_domain_1$(OBJSUFFIX) test/flatzinc/empty_domain_1$(SBJSUFFIX ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -25819,7 +25805,7 @@ test/flatzinc/empty_domain_2$(OBJSUFFIX) test/flatzinc/empty_domain_2$(SBJSUFFIX ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -25914,7 +25900,7 @@ test/flatzinc/int_set_as_type1$(OBJSUFFIX) test/flatzinc/int_set_as_type1$(SBJSU ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -26009,7 +25995,7 @@ test/flatzinc/int_set_as_type2$(OBJSUFFIX) test/flatzinc/int_set_as_type2$(SBJSU ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -26104,7 +26090,7 @@ test/flatzinc/jobshop$(OBJSUFFIX) test/flatzinc/jobshop$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -26199,7 +26185,7 @@ test/flatzinc/no_warn_empty_domain$(OBJSUFFIX) test/flatzinc/no_warn_empty_domai ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -26294,7 +26280,7 @@ test/flatzinc/output_test$(OBJSUFFIX) test/flatzinc/output_test$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -26389,7 +26375,7 @@ test/flatzinc/queens4$(OBJSUFFIX) test/flatzinc/queens4$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -26484,7 +26470,7 @@ test/flatzinc/sat_arith1$(OBJSUFFIX) test/flatzinc/sat_arith1$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -26579,7 +26565,7 @@ test/flatzinc/sat_array_bool_and$(OBJSUFFIX) test/flatzinc/sat_array_bool_and$(S ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -26674,7 +26660,7 @@ test/flatzinc/sat_array_bool_or$(OBJSUFFIX) test/flatzinc/sat_array_bool_or$(SBJ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -26769,7 +26755,7 @@ test/flatzinc/sat_cmp_reif$(OBJSUFFIX) test/flatzinc/sat_cmp_reif$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -26864,7 +26850,7 @@ test/flatzinc/sat_eq_reif$(OBJSUFFIX) test/flatzinc/sat_eq_reif$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -26959,7 +26945,7 @@ test/flatzinc/test_approx_bnb$(OBJSUFFIX) test/flatzinc/test_approx_bnb$(SBJSUFF ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -27054,7 +27040,7 @@ test/flatzinc/test_array_just_right$(OBJSUFFIX) test/flatzinc/test_array_just_ri ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -27149,7 +27135,7 @@ test/flatzinc/test_assigned_var_bounds_bad$(OBJSUFFIX) test/flatzinc/test_assign ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -27244,7 +27230,7 @@ test/flatzinc/test_flatzinc_output_anns$(OBJSUFFIX) test/flatzinc/test_flatzinc_ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -27339,7 +27325,7 @@ test/flatzinc/test_fzn_arith$(OBJSUFFIX) test/flatzinc/test_fzn_arith$(SBJSUFFIX ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -27434,7 +27420,7 @@ test/flatzinc/test_fzn_arrays$(OBJSUFFIX) test/flatzinc/test_fzn_arrays$(SBJSUFF ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -27529,7 +27515,7 @@ test/flatzinc/test_fzn_coercions$(OBJSUFFIX) test/flatzinc/test_fzn_coercions$(S ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -27624,7 +27610,7 @@ test/flatzinc/test_fzn_comparison$(OBJSUFFIX) test/flatzinc/test_fzn_comparison$ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -27719,7 +27705,7 @@ test/flatzinc/test_fzn_logic$(OBJSUFFIX) test/flatzinc/test_fzn_logic$(SBJSUFFIX ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -27814,7 +27800,7 @@ test/flatzinc/test_fzn_sets$(OBJSUFFIX) test/flatzinc/test_fzn_sets$(SBJSUFFIX): ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -27909,7 +27895,7 @@ test/flatzinc/test_int_div$(OBJSUFFIX) test/flatzinc/test_int_div$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -28004,7 +27990,7 @@ test/flatzinc/test_int_mod$(OBJSUFFIX) test/flatzinc/test_int_mod$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -28099,7 +28085,7 @@ test/flatzinc/test_int_ranges_as_values$(OBJSUFFIX) test/flatzinc/test_int_range ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -28194,7 +28180,7 @@ test/flatzinc/test_seq_search$(OBJSUFFIX) test/flatzinc/test_seq_search$(SBJSUFF ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -28289,7 +28275,7 @@ test/flatzinc/2dpacking$(OBJSUFFIX) test/flatzinc/2dpacking$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -28384,7 +28370,7 @@ test/flatzinc/alpha$(OBJSUFFIX) test/flatzinc/alpha$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -28479,7 +28465,7 @@ test/flatzinc/battleships1$(OBJSUFFIX) test/flatzinc/battleships1$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -28574,7 +28560,7 @@ test/flatzinc/battleships10$(OBJSUFFIX) test/flatzinc/battleships10$(SBJSUFFIX): ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -28669,7 +28655,7 @@ test/flatzinc/battleships2$(OBJSUFFIX) test/flatzinc/battleships2$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -28764,7 +28750,7 @@ test/flatzinc/battleships3$(OBJSUFFIX) test/flatzinc/battleships3$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -28859,7 +28845,7 @@ test/flatzinc/battleships4$(OBJSUFFIX) test/flatzinc/battleships4$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -28954,7 +28940,7 @@ test/flatzinc/battleships5$(OBJSUFFIX) test/flatzinc/battleships5$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -29049,7 +29035,7 @@ test/flatzinc/battleships7$(OBJSUFFIX) test/flatzinc/battleships7$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -29144,7 +29130,7 @@ test/flatzinc/battleships9$(OBJSUFFIX) test/flatzinc/battleships9$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -29239,7 +29225,7 @@ test/flatzinc/blocksworld_instance_1$(OBJSUFFIX) test/flatzinc/blocksworld_insta ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -29334,7 +29320,7 @@ test/flatzinc/blocksworld_instance_2$(OBJSUFFIX) test/flatzinc/blocksworld_insta ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -29429,7 +29415,7 @@ test/flatzinc/cumulatives$(OBJSUFFIX) test/flatzinc/cumulatives$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -29524,7 +29510,7 @@ test/flatzinc/cumulatives_full_1$(OBJSUFFIX) test/flatzinc/cumulatives_full_1$(S ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -29619,7 +29605,7 @@ test/flatzinc/cumulatives_full_2$(OBJSUFFIX) test/flatzinc/cumulatives_full_2$(S ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -29714,7 +29700,7 @@ test/flatzinc/cumulatives_full_3$(OBJSUFFIX) test/flatzinc/cumulatives_full_3$(S ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -29809,7 +29795,7 @@ test/flatzinc/cumulatives_full_4$(OBJSUFFIX) test/flatzinc/cumulatives_full_4$(S ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -29904,7 +29890,7 @@ test/flatzinc/cumulatives_full_5$(OBJSUFFIX) test/flatzinc/cumulatives_full_5$(S ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -29999,7 +29985,7 @@ test/flatzinc/cumulatives_full_6$(OBJSUFFIX) test/flatzinc/cumulatives_full_6$(S ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -30094,7 +30080,7 @@ test/flatzinc/cumulatives_full_7$(OBJSUFFIX) test/flatzinc/cumulatives_full_7$(S ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -30189,7 +30175,7 @@ test/flatzinc/cumulatives_full_8$(OBJSUFFIX) test/flatzinc/cumulatives_full_8$(S ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -30284,7 +30270,7 @@ test/flatzinc/cutstock$(OBJSUFFIX) test/flatzinc/cutstock$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -30379,7 +30365,7 @@ test/flatzinc/eq20$(OBJSUFFIX) test/flatzinc/eq20$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -30474,7 +30460,7 @@ test/flatzinc/factory_planning_instance$(OBJSUFFIX) test/flatzinc/factory_planni ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -30569,7 +30555,7 @@ test/flatzinc/golomb$(OBJSUFFIX) test/flatzinc/golomb$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -30664,7 +30650,7 @@ test/flatzinc/jobshop2x2$(OBJSUFFIX) test/flatzinc/jobshop2x2$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -30759,7 +30745,7 @@ test/flatzinc/knights$(OBJSUFFIX) test/flatzinc/knights$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -30854,7 +30840,7 @@ test/flatzinc/langford2$(OBJSUFFIX) test/flatzinc/langford2$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -30949,7 +30935,7 @@ test/flatzinc/latin_squares_fd$(OBJSUFFIX) test/flatzinc/latin_squares_fd$(SBJSU ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -31044,7 +31030,7 @@ test/flatzinc/multidim_knapsack_simple$(OBJSUFFIX) test/flatzinc/multidim_knapsa ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -31139,7 +31125,7 @@ test/flatzinc/packing$(OBJSUFFIX) test/flatzinc/packing$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -31234,7 +31220,7 @@ test/flatzinc/perfsq$(OBJSUFFIX) test/flatzinc/perfsq$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -31329,7 +31315,7 @@ test/flatzinc/perfsq2$(OBJSUFFIX) test/flatzinc/perfsq2$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -31424,7 +31410,7 @@ test/flatzinc/photo$(OBJSUFFIX) test/flatzinc/photo$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -31519,7 +31505,7 @@ test/flatzinc/product_fd$(OBJSUFFIX) test/flatzinc/product_fd$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -31614,7 +31600,7 @@ test/flatzinc/product_lp$(OBJSUFFIX) test/flatzinc/product_lp$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -31709,7 +31695,7 @@ test/flatzinc/quasigroup_qg5$(OBJSUFFIX) test/flatzinc/quasigroup_qg5$(SBJSUFFIX ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -31804,7 +31790,7 @@ test/flatzinc/queen_cp2$(OBJSUFFIX) test/flatzinc/queen_cp2$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -31899,7 +31885,7 @@ test/flatzinc/queen_ip$(OBJSUFFIX) test/flatzinc/queen_ip$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -31994,7 +31980,7 @@ test/flatzinc/radiation$(OBJSUFFIX) test/flatzinc/radiation$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -32089,7 +32075,7 @@ test/flatzinc/shared_array_element$(OBJSUFFIX) test/flatzinc/shared_array_elemen ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -32184,7 +32170,7 @@ test/flatzinc/simple_sat$(OBJSUFFIX) test/flatzinc/simple_sat$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -32279,7 +32265,7 @@ test/flatzinc/singHoist2$(OBJSUFFIX) test/flatzinc/singHoist2$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -32374,7 +32360,7 @@ test/flatzinc/sudoku$(OBJSUFFIX) test/flatzinc/sudoku$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -32469,7 +32455,7 @@ test/flatzinc/template_design$(OBJSUFFIX) test/flatzinc/template_design$(SBJSUFF ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -32564,7 +32550,7 @@ test/flatzinc/tenpenki_1$(OBJSUFFIX) test/flatzinc/tenpenki_1$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -32659,7 +32645,7 @@ test/flatzinc/tenpenki_2$(OBJSUFFIX) test/flatzinc/tenpenki_2$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -32754,7 +32740,7 @@ test/flatzinc/tenpenki_3$(OBJSUFFIX) test/flatzinc/tenpenki_3$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -32849,7 +32835,7 @@ test/flatzinc/tenpenki_4$(OBJSUFFIX) test/flatzinc/tenpenki_4$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -32944,7 +32930,7 @@ test/flatzinc/tenpenki_5$(OBJSUFFIX) test/flatzinc/tenpenki_5$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -33039,7 +33025,7 @@ test/flatzinc/tenpenki_6$(OBJSUFFIX) test/flatzinc/tenpenki_6$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -33134,7 +33120,7 @@ test/flatzinc/warehouses$(OBJSUFFIX) test/flatzinc/warehouses$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -33229,7 +33215,7 @@ test/flatzinc/warehouses_small$(OBJSUFFIX) test/flatzinc/warehouses_small$(SBJSU ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -33324,7 +33310,7 @@ test/flatzinc/wolf_goat_cabbage$(OBJSUFFIX) test/flatzinc/wolf_goat_cabbage$(SBJ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -33419,7 +33405,7 @@ test/flatzinc/zebra$(OBJSUFFIX) test/flatzinc/zebra$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -33514,7 +33500,7 @@ test/flatzinc/magicsq_3$(OBJSUFFIX) test/flatzinc/magicsq_3$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -33609,7 +33595,7 @@ test/flatzinc/magicsq_4$(OBJSUFFIX) test/flatzinc/magicsq_4$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -33704,7 +33690,7 @@ test/flatzinc/magicsq_5$(OBJSUFFIX) test/flatzinc/magicsq_5$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -33799,7 +33785,7 @@ test/flatzinc/oss$(OBJSUFFIX) test/flatzinc/oss$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -33894,7 +33880,7 @@ test/flatzinc/steiner_triples$(OBJSUFFIX) test/flatzinc/steiner_triples$(SBJSUFF ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -33989,7 +33975,7 @@ test/flatzinc/subtyping$(OBJSUFFIX) test/flatzinc/subtyping$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -34084,7 +34070,7 @@ test/flatzinc/timetabling$(OBJSUFFIX) test/flatzinc/timetabling$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -34179,7 +34165,7 @@ test/flatzinc/trucking$(OBJSUFFIX) test/flatzinc/trucking$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -34274,7 +34260,7 @@ test/flatzinc/on_restart_complete$(OBJSUFFIX) test/flatzinc/on_restart_complete$ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -34369,7 +34355,7 @@ test/flatzinc/on_restart_last_val_bool$(OBJSUFFIX) test/flatzinc/on_restart_last ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -34464,7 +34450,7 @@ test/flatzinc/on_restart_last_val_float$(OBJSUFFIX) test/flatzinc/on_restart_las ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -34559,7 +34545,7 @@ test/flatzinc/on_restart_last_val_int$(OBJSUFFIX) test/flatzinc/on_restart_last_ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -34654,7 +34640,7 @@ test/flatzinc/on_restart_last_val_set$(OBJSUFFIX) test/flatzinc/on_restart_last_ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -34749,7 +34735,7 @@ test/flatzinc/on_restart_sol_bool$(OBJSUFFIX) test/flatzinc/on_restart_sol_bool$ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -34844,7 +34830,7 @@ test/flatzinc/on_restart_sol_float$(OBJSUFFIX) test/flatzinc/on_restart_sol_floa ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -34939,7 +34925,7 @@ test/flatzinc/on_restart_sol_int$(OBJSUFFIX) test/flatzinc/on_restart_sol_int$(S ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -35034,7 +35020,7 @@ test/flatzinc/on_restart_sol_set$(OBJSUFFIX) test/flatzinc/on_restart_sol_set$(S ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -35114,6 +35100,226 @@ test/flatzinc/on_restart_sol_set$(OBJSUFFIX) test/flatzinc/on_restart_sol_set$(S ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp ./test/flatzinc.hh ./test/test.hh \ ./test/test.hpp +gecode/int/open-sequence$(OBJSUFFIX) gecode/int/open-sequence$(SBJSUFFIX): \ + ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int/branch.hh ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ + ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/cbs.hpp \ + ./gecode/int/branch/chb.hpp ./gecode/int/branch/merit.hpp ./gecode/int/branch/ngl.hpp \ + ./gecode/int/branch/traits.hpp ./gecode/int/branch/val-commit.hpp ./gecode/int/branch/val-sel.hpp \ + ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/branch/view-values.hpp \ + ./gecode/int/channel.hpp ./gecode/int/div.hh ./gecode/int/div.hpp \ + ./gecode/int/exception.hpp ./gecode/int/extensional.hpp ./gecode/int/extensional/dfa.hpp \ + ./gecode/int/extensional/tuple-set.hpp ./gecode/int/int-set-1.hpp ./gecode/int/int-set-2.hpp \ + ./gecode/int/ipl.hpp ./gecode/int/irt.hpp ./gecode/int/limits.hpp \ + ./gecode/int/open-sequence.hpp ./gecode/int/propagator.hpp ./gecode/int/reify.hpp \ + ./gecode/int/trace.hpp ./gecode/int/trace/bool-delta.hpp ./gecode/int/trace/bool-trace-view.hpp \ + ./gecode/int/trace/int-delta.hpp ./gecode/int/trace/int-trace-view.hpp ./gecode/int/trace/traits.hpp \ + ./gecode/int/var-imp.hpp ./gecode/int/var-imp/bool.hpp ./gecode/int/var-imp/delta.hpp \ + ./gecode/int/var-imp/int.hpp ./gecode/int/var/bool.hpp ./gecode/int/var/int.hpp \ + ./gecode/int/var/print.hpp ./gecode/int/view.hpp ./gecode/int/view/bool-test.hpp \ + ./gecode/int/view/bool.hpp ./gecode/int/view/cached.hpp ./gecode/int/view/constint.hpp \ + ./gecode/int/view/int.hpp ./gecode/int/view/iter.hpp ./gecode/int/view/minus.hpp \ + ./gecode/int/view/neg-bool.hpp ./gecode/int/view/offset.hpp ./gecode/int/view/print.hpp \ + ./gecode/int/view/rel-test.hpp ./gecode/int/view/scale.hpp ./gecode/int/view/zero.hpp \ + ./gecode/iter.hh ./gecode/iter/ranges-add.hpp ./gecode/iter/ranges-append.hpp \ + ./gecode/iter/ranges-array.hpp ./gecode/iter/ranges-cache.hpp ./gecode/iter/ranges-compl.hpp \ + ./gecode/iter/ranges-diff.hpp ./gecode/iter/ranges-empty.hpp ./gecode/iter/ranges-inter.hpp \ + ./gecode/iter/ranges-list.hpp ./gecode/iter/ranges-map.hpp ./gecode/iter/ranges-minmax.hpp \ + ./gecode/iter/ranges-minus.hpp ./gecode/iter/ranges-negative.hpp ./gecode/iter/ranges-offset.hpp \ + ./gecode/iter/ranges-operations.hpp ./gecode/iter/ranges-positive.hpp ./gecode/iter/ranges-rangelist.hpp \ + ./gecode/iter/ranges-scale.hpp ./gecode/iter/ranges-singleton-append.hpp ./gecode/iter/ranges-singleton.hpp \ + ./gecode/iter/ranges-size.hpp ./gecode/iter/ranges-union.hpp ./gecode/iter/ranges-values.hpp \ + ./gecode/iter/values-array.hpp ./gecode/iter/values-bitset.hpp ./gecode/iter/values-bitsetoffset.hpp \ + ./gecode/iter/values-inter.hpp ./gecode/iter/values-list.hpp ./gecode/iter/values-map.hpp \ + ./gecode/iter/values-minus.hpp ./gecode/iter/values-negative.hpp ./gecode/iter/values-offset.hpp \ + ./gecode/iter/values-positive.hpp ./gecode/iter/values-ranges.hpp ./gecode/iter/values-singleton.hpp \ + ./gecode/iter/values-union.hpp ./gecode/iter/values-unique.hpp ./gecode/kernel.hh \ + ./gecode/kernel/archive.hpp ./gecode/kernel/branch/action.hpp ./gecode/kernel/branch/afc.hpp \ + ./gecode/kernel/branch/chb.hpp ./gecode/kernel/branch/filter.hpp ./gecode/kernel/branch/merit.hpp \ + ./gecode/kernel/branch/print.hpp ./gecode/kernel/branch/tiebreak.hpp ./gecode/kernel/branch/traits.hpp \ + ./gecode/kernel/branch/val-commit.hpp ./gecode/kernel/branch/val-sel-commit.hpp ./gecode/kernel/branch/val-sel.hpp \ + ./gecode/kernel/branch/val.hpp ./gecode/kernel/branch/var.hpp ./gecode/kernel/branch/view-sel.hpp \ + ./gecode/kernel/branch/view-val.hpp ./gecode/kernel/branch/view.hpp ./gecode/kernel/core.hpp \ + ./gecode/kernel/data/array.hpp ./gecode/kernel/data/rnd.hpp ./gecode/kernel/data/shared-array.hpp \ + ./gecode/kernel/data/shared-data.hpp ./gecode/kernel/exception.hpp ./gecode/kernel/gpi.hpp \ + ./gecode/kernel/macros.hpp ./gecode/kernel/memory/allocators.hpp ./gecode/kernel/memory/config.hpp \ + ./gecode/kernel/memory/manager.hpp ./gecode/kernel/memory/region.hpp ./gecode/kernel/modevent.hpp \ + ./gecode/kernel/propagator/advisor.hpp ./gecode/kernel/propagator/pattern.hpp ./gecode/kernel/propagator/subscribed.hpp \ + ./gecode/kernel/propagator/wait.hpp ./gecode/kernel/range-list.hpp ./gecode/kernel/shared-object.hpp \ + ./gecode/kernel/shared-space-data.hpp ./gecode/kernel/trace/filter.hpp ./gecode/kernel/trace/general.hpp \ + ./gecode/kernel/trace/print.hpp ./gecode/kernel/trace/recorder.hpp ./gecode/kernel/trace/tracer.hpp \ + ./gecode/kernel/trace/traits.hpp ./gecode/kernel/var-imp.hpp ./gecode/kernel/var-type.hpp \ + ./gecode/kernel/var.hpp ./gecode/kernel/view.hpp ./gecode/search.hh \ + ./gecode/search/bab.hpp ./gecode/search/base.hpp ./gecode/search/build.hpp \ + ./gecode/search/cutoff.hpp ./gecode/search/dfs.hpp ./gecode/search/engine.hpp \ + ./gecode/search/exception.hpp ./gecode/search/lds.hpp ./gecode/search/options.hpp \ + ./gecode/search/pbs.hpp ./gecode/search/rbs.hpp ./gecode/search/sebs.hpp \ + ./gecode/search/seq/dead.hh ./gecode/search/statistics.hpp ./gecode/search/stop.hpp \ + ./gecode/search/support.hh ./gecode/search/trace-recorder.hpp ./gecode/search/tracer.hpp \ + ./gecode/search/traits.hpp ./gecode/support.hh ./gecode/support/allocator.hpp \ + ./gecode/support/auto-link.hpp ./gecode/support/bitset-base.hpp ./gecode/support/bitset-offset.hpp \ + ./gecode/support/bitset.hpp ./gecode/support/block-allocator.hpp ./gecode/support/cast.hpp \ + gecode/support/config.hpp ./gecode/support/dynamic-array.hpp ./gecode/support/dynamic-queue.hpp \ + ./gecode/support/dynamic-stack.hpp ./gecode/support/exception.hpp ./gecode/support/failpoint.hpp \ + ./gecode/support/hash.hpp ./gecode/support/heap.hpp ./gecode/support/hw-rnd.hpp \ + ./gecode/support/int-type.hpp ./gecode/support/macros.hpp ./gecode/support/marked-pointer.hpp \ + ./gecode/support/random.hpp ./gecode/support/ref-count.hpp ./gecode/support/run-jobs.hpp \ + ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ + ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp +gecode/int/extensional-open-regular$(OBJSUFFIX) gecode/int/extensional-open-regular$(SBJSUFFIX): \ + ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ + ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ + ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ + ./gecode/int/div.hh ./gecode/int/div.hpp ./gecode/int/exception.hpp \ + ./gecode/int/extensional.hh ./gecode/int/extensional.hpp ./gecode/int/extensional/bit-set.hpp \ + ./gecode/int/extensional/compact.hpp ./gecode/int/extensional/dfa.hpp ./gecode/int/extensional/layered-graph.hpp \ + ./gecode/int/extensional/tiny-bit-set.hpp ./gecode/int/extensional/tuple-set.hpp ./gecode/int/int-set-1.hpp \ + ./gecode/int/int-set-2.hpp ./gecode/int/ipl.hpp ./gecode/int/irt.hpp \ + ./gecode/int/limits.hpp ./gecode/int/open-sequence.hpp ./gecode/int/propagator.hpp \ + ./gecode/int/reify.hpp ./gecode/int/rel.hh ./gecode/int/rel/eq.hpp \ + ./gecode/int/rel/lex.hpp ./gecode/int/rel/lq-le.hpp ./gecode/int/rel/nq.hpp \ + ./gecode/int/trace.hpp ./gecode/int/trace/bool-delta.hpp ./gecode/int/trace/bool-trace-view.hpp \ + ./gecode/int/trace/int-delta.hpp ./gecode/int/trace/int-trace-view.hpp ./gecode/int/trace/traits.hpp \ + ./gecode/int/var-imp.hpp ./gecode/int/var-imp/bool.hpp ./gecode/int/var-imp/delta.hpp \ + ./gecode/int/var-imp/int.hpp ./gecode/int/var/bool.hpp ./gecode/int/var/int.hpp \ + ./gecode/int/var/print.hpp ./gecode/int/view.hpp ./gecode/int/view/bool-test.hpp \ + ./gecode/int/view/bool.hpp ./gecode/int/view/cached.hpp ./gecode/int/view/constint.hpp \ + ./gecode/int/view/int.hpp ./gecode/int/view/iter.hpp ./gecode/int/view/minus.hpp \ + ./gecode/int/view/neg-bool.hpp ./gecode/int/view/offset.hpp ./gecode/int/view/print.hpp \ + ./gecode/int/view/rel-test.hpp ./gecode/int/view/scale.hpp ./gecode/int/view/zero.hpp \ + ./gecode/iter.hh ./gecode/iter/ranges-add.hpp ./gecode/iter/ranges-append.hpp \ + ./gecode/iter/ranges-array.hpp ./gecode/iter/ranges-cache.hpp ./gecode/iter/ranges-compl.hpp \ + ./gecode/iter/ranges-diff.hpp ./gecode/iter/ranges-empty.hpp ./gecode/iter/ranges-inter.hpp \ + ./gecode/iter/ranges-list.hpp ./gecode/iter/ranges-map.hpp ./gecode/iter/ranges-minmax.hpp \ + ./gecode/iter/ranges-minus.hpp ./gecode/iter/ranges-negative.hpp ./gecode/iter/ranges-offset.hpp \ + ./gecode/iter/ranges-operations.hpp ./gecode/iter/ranges-positive.hpp ./gecode/iter/ranges-rangelist.hpp \ + ./gecode/iter/ranges-scale.hpp ./gecode/iter/ranges-singleton-append.hpp ./gecode/iter/ranges-singleton.hpp \ + ./gecode/iter/ranges-size.hpp ./gecode/iter/ranges-union.hpp ./gecode/iter/ranges-values.hpp \ + ./gecode/iter/values-array.hpp ./gecode/iter/values-bitset.hpp ./gecode/iter/values-bitsetoffset.hpp \ + ./gecode/iter/values-inter.hpp ./gecode/iter/values-list.hpp ./gecode/iter/values-map.hpp \ + ./gecode/iter/values-minus.hpp ./gecode/iter/values-negative.hpp ./gecode/iter/values-offset.hpp \ + ./gecode/iter/values-positive.hpp ./gecode/iter/values-ranges.hpp ./gecode/iter/values-singleton.hpp \ + ./gecode/iter/values-union.hpp ./gecode/iter/values-unique.hpp ./gecode/kernel.hh \ + ./gecode/kernel/archive.hpp ./gecode/kernel/branch/action.hpp ./gecode/kernel/branch/afc.hpp \ + ./gecode/kernel/branch/chb.hpp ./gecode/kernel/branch/filter.hpp ./gecode/kernel/branch/merit.hpp \ + ./gecode/kernel/branch/print.hpp ./gecode/kernel/branch/tiebreak.hpp ./gecode/kernel/branch/traits.hpp \ + ./gecode/kernel/branch/val-commit.hpp ./gecode/kernel/branch/val-sel-commit.hpp ./gecode/kernel/branch/val-sel.hpp \ + ./gecode/kernel/branch/val.hpp ./gecode/kernel/branch/var.hpp ./gecode/kernel/branch/view-sel.hpp \ + ./gecode/kernel/branch/view-val.hpp ./gecode/kernel/branch/view.hpp ./gecode/kernel/core.hpp \ + ./gecode/kernel/data/array.hpp ./gecode/kernel/data/rnd.hpp ./gecode/kernel/data/shared-array.hpp \ + ./gecode/kernel/data/shared-data.hpp ./gecode/kernel/exception.hpp ./gecode/kernel/gpi.hpp \ + ./gecode/kernel/macros.hpp ./gecode/kernel/memory/allocators.hpp ./gecode/kernel/memory/config.hpp \ + ./gecode/kernel/memory/manager.hpp ./gecode/kernel/memory/region.hpp ./gecode/kernel/modevent.hpp \ + ./gecode/kernel/propagator/advisor.hpp ./gecode/kernel/propagator/pattern.hpp ./gecode/kernel/propagator/subscribed.hpp \ + ./gecode/kernel/propagator/wait.hpp ./gecode/kernel/range-list.hpp ./gecode/kernel/shared-object.hpp \ + ./gecode/kernel/shared-space-data.hpp ./gecode/kernel/trace/filter.hpp ./gecode/kernel/trace/general.hpp \ + ./gecode/kernel/trace/print.hpp ./gecode/kernel/trace/recorder.hpp ./gecode/kernel/trace/tracer.hpp \ + ./gecode/kernel/trace/traits.hpp ./gecode/kernel/var-imp.hpp ./gecode/kernel/var-type.hpp \ + ./gecode/kernel/var.hpp ./gecode/kernel/view.hpp ./gecode/search.hh \ + ./gecode/search/bab.hpp ./gecode/search/base.hpp ./gecode/search/build.hpp \ + ./gecode/search/cutoff.hpp ./gecode/search/dfs.hpp ./gecode/search/engine.hpp \ + ./gecode/search/exception.hpp ./gecode/search/lds.hpp ./gecode/search/options.hpp \ + ./gecode/search/pbs.hpp ./gecode/search/rbs.hpp ./gecode/search/sebs.hpp \ + ./gecode/search/seq/dead.hh ./gecode/search/statistics.hpp ./gecode/search/stop.hpp \ + ./gecode/search/support.hh ./gecode/search/trace-recorder.hpp ./gecode/search/tracer.hpp \ + ./gecode/search/traits.hpp ./gecode/support.hh ./gecode/support/allocator.hpp \ + ./gecode/support/auto-link.hpp ./gecode/support/bitset-base.hpp ./gecode/support/bitset-offset.hpp \ + ./gecode/support/bitset.hpp ./gecode/support/block-allocator.hpp ./gecode/support/cast.hpp \ + gecode/support/config.hpp ./gecode/support/dynamic-array.hpp ./gecode/support/dynamic-queue.hpp \ + ./gecode/support/dynamic-stack.hpp ./gecode/support/exception.hpp ./gecode/support/failpoint.hpp \ + ./gecode/support/hash.hpp ./gecode/support/heap.hpp ./gecode/support/hw-rnd.hpp \ + ./gecode/support/int-type.hpp ./gecode/support/macros.hpp ./gecode/support/marked-pointer.hpp \ + ./gecode/support/random.hpp ./gecode/support/ref-count.hpp ./gecode/support/run-jobs.hpp \ + ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ + ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp +test/int/open-sequence$(OBJSUFFIX) test/int/open-sequence$(SBJSUFFIX): \ + ./gecode/float.hh ./gecode/float/array-traits.hpp ./gecode/float/array.hpp \ + ./gecode/float/branch.hpp ./gecode/float/branch/action.hpp ./gecode/float/branch/afc.hpp \ + ./gecode/float/branch/assign.hpp ./gecode/float/branch/chb.hpp ./gecode/float/branch/traits.hpp \ + ./gecode/float/branch/val.hpp ./gecode/float/branch/var.hpp ./gecode/float/channel.hpp \ + ./gecode/float/exception.hpp ./gecode/float/limits.hpp ./gecode/float/nextafter.hpp \ + ./gecode/float/num.hpp ./gecode/float/rounding.hpp ./gecode/float/trace.hpp \ + ./gecode/float/trace/delta.hpp ./gecode/float/trace/trace-view.hpp ./gecode/float/trace/traits.hpp \ + ./gecode/float/val.hpp ./gecode/float/var-imp.hpp ./gecode/float/var-imp/delta.hpp \ + ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ + ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ + ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/array-traits.hpp \ + ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ + ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ + ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ + ./gecode/int/channel.hpp ./gecode/int/div.hh ./gecode/int/div.hpp \ + ./gecode/int/exception.hpp ./gecode/int/extensional.hpp ./gecode/int/extensional/dfa.hpp \ + ./gecode/int/extensional/tuple-set.hpp ./gecode/int/int-set-1.hpp ./gecode/int/int-set-2.hpp \ + ./gecode/int/ipl.hpp ./gecode/int/irt.hpp ./gecode/int/limits.hpp \ + ./gecode/int/open-sequence.hpp ./gecode/int/propagator.hpp ./gecode/int/reify.hpp \ + ./gecode/int/trace.hpp ./gecode/int/trace/bool-delta.hpp ./gecode/int/trace/bool-trace-view.hpp \ + ./gecode/int/trace/int-delta.hpp ./gecode/int/trace/int-trace-view.hpp ./gecode/int/trace/traits.hpp \ + ./gecode/int/var-imp.hpp ./gecode/int/var-imp/bool.hpp ./gecode/int/var-imp/delta.hpp \ + ./gecode/int/var-imp/int.hpp ./gecode/int/var/bool.hpp ./gecode/int/var/int.hpp \ + ./gecode/int/var/print.hpp ./gecode/int/view.hpp ./gecode/int/view/bool-test.hpp \ + ./gecode/int/view/bool.hpp ./gecode/int/view/cached.hpp ./gecode/int/view/constint.hpp \ + ./gecode/int/view/int.hpp ./gecode/int/view/iter.hpp ./gecode/int/view/minus.hpp \ + ./gecode/int/view/neg-bool.hpp ./gecode/int/view/offset.hpp ./gecode/int/view/print.hpp \ + ./gecode/int/view/rel-test.hpp ./gecode/int/view/scale.hpp ./gecode/int/view/zero.hpp \ + ./gecode/iter.hh ./gecode/iter/ranges-add.hpp ./gecode/iter/ranges-append.hpp \ + ./gecode/iter/ranges-array.hpp ./gecode/iter/ranges-cache.hpp ./gecode/iter/ranges-compl.hpp \ + ./gecode/iter/ranges-diff.hpp ./gecode/iter/ranges-empty.hpp ./gecode/iter/ranges-inter.hpp \ + ./gecode/iter/ranges-list.hpp ./gecode/iter/ranges-map.hpp ./gecode/iter/ranges-minmax.hpp \ + ./gecode/iter/ranges-minus.hpp ./gecode/iter/ranges-negative.hpp ./gecode/iter/ranges-offset.hpp \ + ./gecode/iter/ranges-operations.hpp ./gecode/iter/ranges-positive.hpp ./gecode/iter/ranges-rangelist.hpp \ + ./gecode/iter/ranges-scale.hpp ./gecode/iter/ranges-singleton-append.hpp ./gecode/iter/ranges-singleton.hpp \ + ./gecode/iter/ranges-size.hpp ./gecode/iter/ranges-union.hpp ./gecode/iter/ranges-values.hpp \ + ./gecode/iter/values-array.hpp ./gecode/iter/values-bitset.hpp ./gecode/iter/values-bitsetoffset.hpp \ + ./gecode/iter/values-inter.hpp ./gecode/iter/values-list.hpp ./gecode/iter/values-map.hpp \ + ./gecode/iter/values-minus.hpp ./gecode/iter/values-negative.hpp ./gecode/iter/values-offset.hpp \ + ./gecode/iter/values-positive.hpp ./gecode/iter/values-ranges.hpp ./gecode/iter/values-singleton.hpp \ + ./gecode/iter/values-union.hpp ./gecode/iter/values-unique.hpp ./gecode/kernel.hh \ + ./gecode/kernel/archive.hpp ./gecode/kernel/branch/action.hpp ./gecode/kernel/branch/afc.hpp \ + ./gecode/kernel/branch/chb.hpp ./gecode/kernel/branch/filter.hpp ./gecode/kernel/branch/merit.hpp \ + ./gecode/kernel/branch/print.hpp ./gecode/kernel/branch/tiebreak.hpp ./gecode/kernel/branch/traits.hpp \ + ./gecode/kernel/branch/val-commit.hpp ./gecode/kernel/branch/val-sel-commit.hpp ./gecode/kernel/branch/val-sel.hpp \ + ./gecode/kernel/branch/val.hpp ./gecode/kernel/branch/var.hpp ./gecode/kernel/branch/view-sel.hpp \ + ./gecode/kernel/branch/view-val.hpp ./gecode/kernel/branch/view.hpp ./gecode/kernel/core.hpp \ + ./gecode/kernel/data/array.hpp ./gecode/kernel/data/rnd.hpp ./gecode/kernel/data/shared-array.hpp \ + ./gecode/kernel/data/shared-data.hpp ./gecode/kernel/exception.hpp ./gecode/kernel/gpi.hpp \ + ./gecode/kernel/macros.hpp ./gecode/kernel/memory/allocators.hpp ./gecode/kernel/memory/config.hpp \ + ./gecode/kernel/memory/manager.hpp ./gecode/kernel/memory/region.hpp ./gecode/kernel/modevent.hpp \ + ./gecode/kernel/propagator/advisor.hpp ./gecode/kernel/propagator/pattern.hpp ./gecode/kernel/propagator/subscribed.hpp \ + ./gecode/kernel/propagator/wait.hpp ./gecode/kernel/range-list.hpp ./gecode/kernel/shared-object.hpp \ + ./gecode/kernel/shared-space-data.hpp ./gecode/kernel/trace/filter.hpp ./gecode/kernel/trace/general.hpp \ + ./gecode/kernel/trace/print.hpp ./gecode/kernel/trace/recorder.hpp ./gecode/kernel/trace/tracer.hpp \ + ./gecode/kernel/trace/traits.hpp ./gecode/kernel/var-imp.hpp ./gecode/kernel/var-type.hpp \ + ./gecode/kernel/var.hpp ./gecode/kernel/view.hpp ./gecode/search.hh \ + ./gecode/search/bab.hpp ./gecode/search/base.hpp ./gecode/search/build.hpp \ + ./gecode/search/cutoff.hpp ./gecode/search/dfs.hpp ./gecode/search/engine.hpp \ + ./gecode/search/exception.hpp ./gecode/search/lds.hpp ./gecode/search/options.hpp \ + ./gecode/search/pbs.hpp ./gecode/search/rbs.hpp ./gecode/search/sebs.hpp \ + ./gecode/search/seq/dead.hh ./gecode/search/statistics.hpp ./gecode/search/stop.hpp \ + ./gecode/search/support.hh ./gecode/search/trace-recorder.hpp ./gecode/search/tracer.hpp \ + ./gecode/search/traits.hpp ./gecode/set.hh ./gecode/set/array-traits.hpp \ + ./gecode/set/array.hpp ./gecode/set/branch.hpp ./gecode/set/branch/action.hpp \ + ./gecode/set/branch/afc.hpp ./gecode/set/branch/assign.hpp ./gecode/set/branch/chb.hpp \ + ./gecode/set/branch/traits.hpp ./gecode/set/branch/val.hpp ./gecode/set/branch/var.hpp \ + ./gecode/set/exception.hpp ./gecode/set/int.hpp ./gecode/set/limits.hpp \ + ./gecode/set/trace.hpp ./gecode/set/trace/delta.hpp ./gecode/set/trace/trace-view.hpp \ + ./gecode/set/trace/traits.hpp ./gecode/set/var-imp.hpp ./gecode/set/var-imp/delta.hpp \ + ./gecode/set/var-imp/integerset.hpp ./gecode/set/var-imp/iter.hpp ./gecode/set/var-imp/set.hpp \ + ./gecode/set/var/print.hpp ./gecode/set/var/set.hpp ./gecode/set/view.hpp \ + ./gecode/set/view/cached.hpp ./gecode/set/view/complement.hpp ./gecode/set/view/const.hpp \ + ./gecode/set/view/print.hpp ./gecode/set/view/set.hpp ./gecode/set/view/singleton.hpp \ + ./gecode/support.hh ./gecode/support/allocator.hpp ./gecode/support/auto-link.hpp \ + ./gecode/support/bitset-base.hpp ./gecode/support/bitset-offset.hpp ./gecode/support/bitset.hpp \ + ./gecode/support/block-allocator.hpp ./gecode/support/cast.hpp gecode/support/config.hpp \ + ./gecode/support/dynamic-array.hpp ./gecode/support/dynamic-queue.hpp ./gecode/support/dynamic-stack.hpp \ + ./gecode/support/exception.hpp ./gecode/support/failpoint.hpp ./gecode/support/hash.hpp \ + ./gecode/support/heap.hpp ./gecode/support/hw-rnd.hpp ./gecode/support/int-type.hpp \ + ./gecode/support/macros.hpp ./gecode/support/marked-pointer.hpp ./gecode/support/random.hpp \ + ./gecode/support/ref-count.hpp ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp \ + ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ + ./gecode/support/timer.hpp ./test/int.hh ./test/int.hpp \ + ./test/test.hh ./test/test.hpp gecode/int/min-distance$(OBJSUFFIX) gecode/int/min-distance$(SBJSUFFIX): \ ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ diff --git a/gecode/int/open-sequence.cpp b/gecode/int/open-sequence.cpp index fb2b6d1da1..db93b78a1f 100644 --- a/gecode/int/open-sequence.cpp +++ b/gecode/int/open-sequence.cpp @@ -229,7 +229,7 @@ namespace Gecode { namespace Int { const int size = sequence.size(); const int first = std::max(1,posted); for (int i=first; i Date: Tue, 6 Oct 2026 17:21:37 +0200 Subject: [PATCH 16/34] Rename open variable sequences to lists --- Makefile.dep | 810 +++++++++--------- Makefile.in | 6 +- cmake/GecodeSources.cmake | 4 +- gecode/int.hh | 189 ++-- gecode/int/extensional-open-regular.cpp | 64 +- .../{open-sequence.cpp => open-var-list.cpp} | 376 ++++---- .../{open-sequence.hpp => open-var-list.hpp} | 110 +-- test/int/extensional.cpp | 128 +-- .../{open-sequence.cpp => open-var-list.cpp} | 356 ++++---- 9 files changed, 1029 insertions(+), 1014 deletions(-) rename gecode/int/{open-sequence.cpp => open-var-list.cpp} (66%) rename gecode/int/{open-sequence.hpp => open-var-list.hpp} (70%) rename test/int/{open-sequence.cpp => open-var-list.cpp} (74%) diff --git a/Makefile.dep b/Makefile.dep index bbd2349183..8eee6c8279 100644 --- a/Makefile.dep +++ b/Makefile.dep @@ -1042,7 +1042,7 @@ gecode/search/cpprofiler/tracer$(OBJSUFFIX) gecode/search/cpprofiler/tracer$(SBJ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/int/int-set$(OBJSUFFIX) gecode/int/int-set$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -1105,7 +1105,7 @@ gecode/int/int-set$(OBJSUFFIX) gecode/int/int-set$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/var-imp/int$(OBJSUFFIX) gecode/int/var-imp/int$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -1168,7 +1168,7 @@ gecode/int/var-imp/int$(OBJSUFFIX) gecode/int/var-imp/int$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/var-imp/bool$(OBJSUFFIX) gecode/int/var-imp/bool$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -1231,7 +1231,7 @@ gecode/int/var-imp/bool$(OBJSUFFIX) gecode/int/var-imp/bool$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/var/int$(OBJSUFFIX) gecode/int/var/int$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -1294,7 +1294,7 @@ gecode/int/var/int$(OBJSUFFIX) gecode/int/var/int$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/var/bool$(OBJSUFFIX) gecode/int/var/bool$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -1357,7 +1357,7 @@ gecode/int/var/bool$(OBJSUFFIX) gecode/int/var/bool$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/array$(OBJSUFFIX) gecode/int/array$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -1420,7 +1420,7 @@ gecode/int/array$(OBJSUFFIX) gecode/int/array$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/bool$(OBJSUFFIX) gecode/int/bool$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/bool.hh ./gecode/int/bool/base.hpp ./gecode/int/bool/clause.hpp \ ./gecode/int/bool/eq.hpp ./gecode/int/bool/eqv.hpp ./gecode/int/bool/ite.hpp \ ./gecode/int/bool/lq.hpp ./gecode/int/bool/or.hpp ./gecode/int/branch.hpp \ @@ -1487,7 +1487,7 @@ gecode/int/bool$(OBJSUFFIX) gecode/int/bool$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/bool/eqv$(OBJSUFFIX) gecode/int/bool/eqv$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/bool.hh ./gecode/int/bool/base.hpp ./gecode/int/bool/clause.hpp \ ./gecode/int/bool/eq.hpp ./gecode/int/bool/eqv.hpp ./gecode/int/bool/ite.hpp \ ./gecode/int/bool/lq.hpp ./gecode/int/bool/or.hpp ./gecode/int/branch.hpp \ @@ -1554,7 +1554,7 @@ gecode/int/bool/eqv$(OBJSUFFIX) gecode/int/bool/eqv$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/extensional/dfa$(OBJSUFFIX) gecode/int/extensional/dfa$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -1617,7 +1617,7 @@ gecode/int/extensional/dfa$(OBJSUFFIX) gecode/int/extensional/dfa$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/extensional/tuple-set$(OBJSUFFIX) gecode/int/extensional/tuple-set$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -1680,7 +1680,7 @@ gecode/int/extensional/tuple-set$(OBJSUFFIX) gecode/int/extensional/tuple-set$(S ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/extensional-regular$(OBJSUFFIX) gecode/int/extensional-regular$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -1746,7 +1746,7 @@ gecode/int/extensional-regular$(OBJSUFFIX) gecode/int/extensional-regular$(SBJSU ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/extensional-tuple-set$(OBJSUFFIX) gecode/int/extensional-tuple-set$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -1812,7 +1812,7 @@ gecode/int/extensional-tuple-set$(OBJSUFFIX) gecode/int/extensional-tuple-set$(S ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/dom$(OBJSUFFIX) gecode/int/dom$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -1878,7 +1878,7 @@ gecode/int/dom$(OBJSUFFIX) gecode/int/dom$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/int/rel$(OBJSUFFIX) gecode/int/rel$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/bool.hh ./gecode/int/bool/base.hpp ./gecode/int/bool/clause.hpp \ ./gecode/int/bool/eq.hpp ./gecode/int/bool/eqv.hpp ./gecode/int/bool/ite.hpp \ ./gecode/int/bool/lq.hpp ./gecode/int/bool/or.hpp ./gecode/int/branch.hpp \ @@ -1945,7 +1945,7 @@ gecode/int/rel$(OBJSUFFIX) gecode/int/rel$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/precede$(OBJSUFFIX) gecode/int/precede$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -2009,7 +2009,7 @@ gecode/int/precede$(OBJSUFFIX) gecode/int/precede$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/int/element$(OBJSUFFIX) gecode/int/element$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -2076,7 +2076,7 @@ gecode/int/element$(OBJSUFFIX) gecode/int/element$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/int/count$(OBJSUFFIX) gecode/int/count$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -2146,7 +2146,7 @@ gecode/int/count$(OBJSUFFIX) gecode/int/count$(SBJSUFFIX): \ gecode/int/arithmetic$(OBJSUFFIX) gecode/int/arithmetic$(SBJSUFFIX): \ ./gecode/int/arithmetic/gcd.hpp ./gecode/int/arithmetic/divides.hpp \ ./gecode/int/arithmetic/product.hpp ./gecode/int/arithmetic/product-mod.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/arithmetic.hh ./gecode/int/arithmetic/abs.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/arithmetic.hh ./gecode/int/arithmetic/abs.hpp \ ./gecode/int/arithmetic/argmax.hpp ./gecode/int/arithmetic/divmod.hpp ./gecode/int/arithmetic/max.hpp \ ./gecode/int/arithmetic/mult.hpp ./gecode/int/arithmetic/nroot.hpp ./gecode/int/arithmetic/pow-ops.hpp \ ./gecode/int/arithmetic/pow.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ @@ -2221,7 +2221,7 @@ gecode/int/arithmetic$(OBJSUFFIX) gecode/int/arithmetic$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/exec$(OBJSUFFIX) gecode/int/exec$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -2285,7 +2285,7 @@ gecode/int/exec$(OBJSUFFIX) gecode/int/exec$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/int/exec/when$(OBJSUFFIX) gecode/int/exec/when$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -2349,7 +2349,7 @@ gecode/int/exec/when$(OBJSUFFIX) gecode/int/exec/when$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/int/element/pair$(OBJSUFFIX) gecode/int/element/pair$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -2416,7 +2416,7 @@ gecode/int/element/pair$(OBJSUFFIX) gecode/int/element/pair$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/int/linear/int-post$(OBJSUFFIX) gecode/int/linear/int-post$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/bool.hh ./gecode/int/bool/base.hpp ./gecode/int/bool/clause.hpp \ ./gecode/int/bool/eq.hpp ./gecode/int/bool/eqv.hpp ./gecode/int/bool/ite.hpp \ ./gecode/int/bool/lq.hpp ./gecode/int/bool/or.hpp ./gecode/int/branch.hpp \ @@ -2487,7 +2487,7 @@ gecode/int/linear/int-post$(OBJSUFFIX) gecode/int/linear/int-post$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/int/linear-int$(OBJSUFFIX) gecode/int/linear-int$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/bool.hh ./gecode/int/bool/base.hpp ./gecode/int/bool/clause.hpp \ ./gecode/int/bool/eq.hpp ./gecode/int/bool/eqv.hpp ./gecode/int/bool/ite.hpp \ ./gecode/int/bool/lq.hpp ./gecode/int/bool/or.hpp ./gecode/int/branch.hpp \ @@ -2558,7 +2558,7 @@ gecode/int/linear-int$(OBJSUFFIX) gecode/int/linear-int$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/int/linear/bool-post$(OBJSUFFIX) gecode/int/linear/bool-post$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/bool.hh ./gecode/int/bool/base.hpp ./gecode/int/bool/clause.hpp \ ./gecode/int/bool/eq.hpp ./gecode/int/bool/eqv.hpp ./gecode/int/bool/ite.hpp \ ./gecode/int/bool/lq.hpp ./gecode/int/bool/or.hpp ./gecode/int/branch.hpp \ @@ -2629,7 +2629,7 @@ gecode/int/linear/bool-post$(OBJSUFFIX) gecode/int/linear/bool-post$(SBJSUFFIX): ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/int/linear-bool$(OBJSUFFIX) gecode/int/linear-bool$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/bool.hh ./gecode/int/bool/base.hpp ./gecode/int/bool/clause.hpp \ ./gecode/int/bool/eq.hpp ./gecode/int/bool/eqv.hpp ./gecode/int/bool/ite.hpp \ ./gecode/int/bool/lq.hpp ./gecode/int/bool/or.hpp ./gecode/int/branch.hpp \ @@ -2700,7 +2700,7 @@ gecode/int/linear-bool$(OBJSUFFIX) gecode/int/linear-bool$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/int/branch$(OBJSUFFIX) gecode/int/branch$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hh ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/cbs.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/merit.hpp ./gecode/int/branch/ngl.hpp \ @@ -2765,7 +2765,7 @@ gecode/int/branch$(OBJSUFFIX) gecode/int/branch$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/distinct/eqite$(OBJSUFFIX) gecode/int/distinct/eqite$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -2835,7 +2835,7 @@ gecode/int/distinct/eqite$(OBJSUFFIX) gecode/int/distinct/eqite$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/distinct/cbs$(OBJSUFFIX) gecode/int/distinct/cbs$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -2905,7 +2905,7 @@ gecode/int/distinct/cbs$(OBJSUFFIX) gecode/int/distinct/cbs$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/distinct$(OBJSUFFIX) gecode/int/distinct$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/bool.hh ./gecode/int/bool/base.hpp ./gecode/int/bool/clause.hpp \ ./gecode/int/bool/eq.hpp ./gecode/int/bool/eqv.hpp ./gecode/int/bool/ite.hpp \ ./gecode/int/bool/lq.hpp ./gecode/int/bool/or.hpp ./gecode/int/branch.hpp \ @@ -2978,7 +2978,7 @@ gecode/int/distinct$(OBJSUFFIX) gecode/int/distinct$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/int/sorted$(OBJSUFFIX) gecode/int/sorted$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -3050,7 +3050,7 @@ gecode/int/sorted$(OBJSUFFIX) gecode/int/sorted$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/gcc$(OBJSUFFIX) gecode/int/gcc$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/bool.hh ./gecode/int/bool/base.hpp ./gecode/int/bool/clause.hpp \ ./gecode/int/bool/eq.hpp ./gecode/int/bool/eqv.hpp ./gecode/int/bool/ite.hpp \ ./gecode/int/bool/lq.hpp ./gecode/int/bool/or.hpp ./gecode/int/branch.hpp \ @@ -3129,7 +3129,7 @@ gecode/int/gcc$(OBJSUFFIX) gecode/int/gcc$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/int/channel$(OBJSUFFIX) gecode/int/channel$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hh \ @@ -3201,7 +3201,7 @@ gecode/int/channel$(OBJSUFFIX) gecode/int/channel$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/channel/link-single$(OBJSUFFIX) gecode/int/channel/link-single$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hh \ @@ -3273,7 +3273,7 @@ gecode/int/channel/link-single$(OBJSUFFIX) gecode/int/channel/link-single$(SBJSU ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/channel/link-multi$(OBJSUFFIX) gecode/int/channel/link-multi$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hh \ @@ -3345,7 +3345,7 @@ gecode/int/channel/link-multi$(OBJSUFFIX) gecode/int/channel/link-multi$(SBJSUFF ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/unshare$(OBJSUFFIX) gecode/int/unshare$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/bool.hh ./gecode/int/bool/base.hpp ./gecode/int/bool/clause.hpp \ ./gecode/int/bool/eq.hpp ./gecode/int/bool/eqv.hpp ./gecode/int/bool/ite.hpp \ ./gecode/int/bool/lq.hpp ./gecode/int/bool/or.hpp ./gecode/int/branch.hpp \ @@ -3412,7 +3412,7 @@ gecode/int/unshare$(OBJSUFFIX) gecode/int/unshare$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/sequence$(OBJSUFFIX) gecode/int/sequence$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -3478,7 +3478,7 @@ gecode/int/sequence$(OBJSUFFIX) gecode/int/sequence$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/bin-packing$(OBJSUFFIX) gecode/int/bin-packing$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/bin-packing.hh ./gecode/int/bin-packing/conflict-graph.hpp ./gecode/int/bin-packing/propagate.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ @@ -3549,7 +3549,7 @@ gecode/int/bin-packing$(OBJSUFFIX) gecode/int/bin-packing$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/bin-packing/propagate$(OBJSUFFIX) gecode/int/bin-packing/propagate$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/bin-packing.hh ./gecode/int/bin-packing/conflict-graph.hpp ./gecode/int/bin-packing/propagate.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ @@ -3620,7 +3620,7 @@ gecode/int/bin-packing/propagate$(OBJSUFFIX) gecode/int/bin-packing/propagate$(S ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/bin-packing/conflict-graph$(OBJSUFFIX) gecode/int/bin-packing/conflict-graph$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/bin-packing.hh ./gecode/int/bin-packing/conflict-graph.hpp ./gecode/int/bin-packing/propagate.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ @@ -3691,7 +3691,7 @@ gecode/int/bin-packing/conflict-graph$(OBJSUFFIX) gecode/int/bin-packing/conflic ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/order$(OBJSUFFIX) gecode/int/order$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -3756,7 +3756,7 @@ gecode/int/order$(OBJSUFFIX) gecode/int/order$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/order/propagate$(OBJSUFFIX) gecode/int/order/propagate$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -3821,7 +3821,7 @@ gecode/int/order/propagate$(OBJSUFFIX) gecode/int/order/propagate$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/unary$(OBJSUFFIX) gecode/int/unary$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -3899,7 +3899,7 @@ gecode/int/unary$(OBJSUFFIX) gecode/int/unary$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/int/cumulative$(OBJSUFFIX) gecode/int/cumulative$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -3974,7 +3974,7 @@ gecode/int/cumulative$(OBJSUFFIX) gecode/int/cumulative$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/cumulatives$(OBJSUFFIX) gecode/int/cumulatives$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -4038,7 +4038,7 @@ gecode/int/cumulatives$(OBJSUFFIX) gecode/int/cumulatives$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/int/circuit$(OBJSUFFIX) gecode/int/circuit$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -4109,7 +4109,7 @@ gecode/int/circuit$(OBJSUFFIX) gecode/int/circuit$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/no-overlap$(OBJSUFFIX) gecode/int/no-overlap$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -4174,7 +4174,7 @@ gecode/int/no-overlap$(OBJSUFFIX) gecode/int/no-overlap$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/nvalues$(OBJSUFFIX) gecode/int/nvalues$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/bool.hh ./gecode/int/bool/base.hpp ./gecode/int/bool/clause.hpp \ ./gecode/int/bool/eq.hpp ./gecode/int/bool/eqv.hpp ./gecode/int/bool/ite.hpp \ ./gecode/int/bool/lq.hpp ./gecode/int/bool/or.hpp ./gecode/int/branch.hpp \ @@ -4251,7 +4251,7 @@ gecode/int/nvalues$(OBJSUFFIX) gecode/int/nvalues$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/member$(OBJSUFFIX) gecode/int/member$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -4317,7 +4317,7 @@ gecode/int/member$(OBJSUFFIX) gecode/int/member$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/branch/action$(OBJSUFFIX) gecode/int/branch/action$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -4380,7 +4380,7 @@ gecode/int/branch/action$(OBJSUFFIX) gecode/int/branch/action$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/branch/chb$(OBJSUFFIX) gecode/int/branch/chb$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -4445,7 +4445,7 @@ gecode/int/branch/chb$(OBJSUFFIX) gecode/int/branch/chb$(SBJSUFFIX): \ gecode/int/arithmetic/mult$(OBJSUFFIX) gecode/int/arithmetic/mult$(SBJSUFFIX): \ ./gecode/int/arithmetic/gcd.hpp ./gecode/int/arithmetic/divides.hpp \ ./gecode/int/arithmetic/product.hpp ./gecode/int/arithmetic/product-mod.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/arithmetic.hh ./gecode/int/arithmetic/abs.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/arithmetic.hh ./gecode/int/arithmetic/abs.hpp \ ./gecode/int/arithmetic/argmax.hpp ./gecode/int/arithmetic/divmod.hpp ./gecode/int/arithmetic/max.hpp \ ./gecode/int/arithmetic/mult.hpp ./gecode/int/arithmetic/nroot.hpp ./gecode/int/arithmetic/pow-ops.hpp \ ./gecode/int/arithmetic/pow.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ @@ -4520,7 +4520,7 @@ gecode/int/arithmetic/mult$(OBJSUFFIX) gecode/int/arithmetic/mult$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/branch/view-sel$(OBJSUFFIX) gecode/int/branch/view-sel$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hh ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/cbs.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/merit.hpp ./gecode/int/branch/ngl.hpp \ @@ -4585,7 +4585,7 @@ gecode/int/branch/view-sel$(OBJSUFFIX) gecode/int/branch/view-sel$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/branch/val-sel-commit$(OBJSUFFIX) gecode/int/branch/val-sel-commit$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hh ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/cbs.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/merit.hpp ./gecode/int/branch/ngl.hpp \ @@ -4650,7 +4650,7 @@ gecode/int/branch/val-sel-commit$(OBJSUFFIX) gecode/int/branch/val-sel-commit$(S ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/branch/view-values$(OBJSUFFIX) gecode/int/branch/view-values$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hh ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/cbs.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/merit.hpp ./gecode/int/branch/ngl.hpp \ @@ -4715,7 +4715,7 @@ gecode/int/branch/view-values$(OBJSUFFIX) gecode/int/branch/view-values$(SBJSUFF ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/relax$(OBJSUFFIX) gecode/int/relax$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -4778,7 +4778,7 @@ gecode/int/relax$(OBJSUFFIX) gecode/int/relax$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/ldsb$(OBJSUFFIX) gecode/int/ldsb$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hh ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/cbs.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/merit.hpp ./gecode/int/branch/ngl.hpp \ @@ -4844,7 +4844,7 @@ gecode/int/ldsb$(OBJSUFFIX) gecode/int/ldsb$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/ldsb/sym-imp$(OBJSUFFIX) gecode/int/ldsb/sym-imp$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hh ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/cbs.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/merit.hpp ./gecode/int/branch/ngl.hpp \ @@ -4910,7 +4910,7 @@ gecode/int/ldsb/sym-imp$(OBJSUFFIX) gecode/int/ldsb/sym-imp$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/ldsb/sym-obj$(OBJSUFFIX) gecode/int/ldsb/sym-obj$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -4974,7 +4974,7 @@ gecode/int/ldsb/sym-obj$(OBJSUFFIX) gecode/int/ldsb/sym-obj$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/trace$(OBJSUFFIX) gecode/int/trace$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -5037,7 +5037,7 @@ gecode/int/trace$(OBJSUFFIX) gecode/int/trace$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/trace/tracer$(OBJSUFFIX) gecode/int/trace/tracer$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -5100,7 +5100,7 @@ gecode/int/trace/tracer$(OBJSUFFIX) gecode/int/trace/tracer$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/int/exception$(OBJSUFFIX) gecode/int/exception$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -5174,7 +5174,7 @@ gecode/float/var/float$(OBJSUFFIX) gecode/float/var/float$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -5248,7 +5248,7 @@ gecode/float/var-imp/float$(OBJSUFFIX) gecode/float/var-imp/float$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -5326,7 +5326,7 @@ gecode/float/arithmetic$(OBJSUFFIX) gecode/float/arithmetic$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -5400,7 +5400,7 @@ gecode/float/array$(OBJSUFFIX) gecode/float/array$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -5475,7 +5475,7 @@ gecode/float/branch$(OBJSUFFIX) gecode/float/branch$(SBJSUFFIX): \ ./gecode/float/var-imp/delta.hpp ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp \ ./gecode/float/var/print.hpp ./gecode/float/view.hpp ./gecode/float/view/float.hpp \ ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp \ - ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -5551,7 +5551,7 @@ gecode/float/rel$(OBJSUFFIX) gecode/float/rel$(SBJSUFFIX): \ ./gecode/float/var-imp/delta.hpp ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp \ ./gecode/float/var/print.hpp ./gecode/float/view.hpp ./gecode/float/view/float.hpp \ ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp \ - ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -5627,7 +5627,7 @@ gecode/float/linear$(OBJSUFFIX) gecode/float/linear$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -5703,7 +5703,7 @@ gecode/float/linear/post$(OBJSUFFIX) gecode/float/linear/post$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -5779,7 +5779,7 @@ gecode/float/bool$(OBJSUFFIX) gecode/float/bool$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -5854,7 +5854,7 @@ gecode/float/channel$(OBJSUFFIX) gecode/float/channel$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -5929,7 +5929,7 @@ gecode/float/transcendental$(OBJSUFFIX) gecode/float/transcendental$(SBJSUFFIX): ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -6004,7 +6004,7 @@ gecode/float/trigonometric$(OBJSUFFIX) gecode/float/trigonometric$(SBJSUFFIX): \ ./gecode/float/var-imp/delta.hpp ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp \ ./gecode/float/var/print.hpp ./gecode/float/view.hpp ./gecode/float/view/float.hpp \ ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp \ - ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -6079,7 +6079,7 @@ gecode/float/branch/action$(OBJSUFFIX) gecode/float/branch/action$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -6153,7 +6153,7 @@ gecode/float/branch/chb$(OBJSUFFIX) gecode/float/branch/chb$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -6227,7 +6227,7 @@ gecode/float/rounding$(OBJSUFFIX) gecode/float/rounding$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -6301,7 +6301,7 @@ gecode/float/exec$(OBJSUFFIX) gecode/float/exec$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -6376,7 +6376,7 @@ gecode/float/branch/val-sel-commit$(OBJSUFFIX) gecode/float/branch/val-sel-commi ./gecode/float/var-imp/delta.hpp ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp \ ./gecode/float/var/print.hpp ./gecode/float/view.hpp ./gecode/float/view/float.hpp \ ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp \ - ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -6452,7 +6452,7 @@ gecode/float/branch/view-sel$(OBJSUFFIX) gecode/float/branch/view-sel$(SBJSUFFIX ./gecode/float/var-imp/delta.hpp ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp \ ./gecode/float/var/print.hpp ./gecode/float/view.hpp ./gecode/float/view/float.hpp \ ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp \ - ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -6528,7 +6528,7 @@ gecode/float/dom$(OBJSUFFIX) gecode/float/dom$(SBJSUFFIX): \ ./gecode/float/var-imp/delta.hpp ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp \ ./gecode/float/var/print.hpp ./gecode/float/view.hpp ./gecode/float/view/float.hpp \ ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp \ - ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -6603,7 +6603,7 @@ gecode/float/relax$(OBJSUFFIX) gecode/float/relax$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -6678,7 +6678,7 @@ gecode/float/trace$(OBJSUFFIX) gecode/float/trace$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -6752,7 +6752,7 @@ gecode/float/trace/tracer$(OBJSUFFIX) gecode/float/trace/tracer$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -6826,7 +6826,7 @@ gecode/float/exception$(OBJSUFFIX) gecode/float/exception$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -6889,7 +6889,7 @@ gecode/float/exception$(OBJSUFFIX) gecode/float/exception$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/set/branch$(OBJSUFFIX) gecode/set/branch$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -6964,7 +6964,7 @@ gecode/set/branch$(OBJSUFFIX) gecode/set/branch$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/set/cardinality$(OBJSUFFIX) gecode/set/cardinality$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -7039,7 +7039,7 @@ gecode/set/cardinality$(OBJSUFFIX) gecode/set/cardinality$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/set/convex$(OBJSUFFIX) gecode/set/convex$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -7114,7 +7114,7 @@ gecode/set/convex$(OBJSUFFIX) gecode/set/convex$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/convex/conv$(OBJSUFFIX) gecode/set/convex/conv$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -7189,7 +7189,7 @@ gecode/set/convex/conv$(OBJSUFFIX) gecode/set/convex/conv$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/convex/hull$(OBJSUFFIX) gecode/set/convex/hull$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -7264,7 +7264,7 @@ gecode/set/convex/hull$(OBJSUFFIX) gecode/set/convex/hull$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/dom$(OBJSUFFIX) gecode/set/dom$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -7341,7 +7341,7 @@ gecode/set/dom$(OBJSUFFIX) gecode/set/dom$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/set/rel$(OBJSUFFIX) gecode/set/rel$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -7422,7 +7422,7 @@ gecode/set/rel$(OBJSUFFIX) gecode/set/rel$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/set/rel-op$(OBJSUFFIX) gecode/set/rel-op$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -7502,7 +7502,7 @@ gecode/set/rel-op$(OBJSUFFIX) gecode/set/rel-op$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/rel-op-ternary$(OBJSUFFIX) gecode/set/rel-op-ternary$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -7582,7 +7582,7 @@ gecode/set/rel-op-ternary$(OBJSUFFIX) gecode/set/rel-op-ternary$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/rel-op-singleton$(OBJSUFFIX) gecode/set/rel-op-singleton$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -7662,7 +7662,7 @@ gecode/set/rel-op-singleton$(OBJSUFFIX) gecode/set/rel-op-singleton$(SBJSUFFIX): ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/rel-op/post-compl$(OBJSUFFIX) gecode/set/rel-op/post-compl$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -7742,7 +7742,7 @@ gecode/set/rel-op/post-compl$(OBJSUFFIX) gecode/set/rel-op/post-compl$(SBJSUFFIX ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/rel-op/post-nocompl$(OBJSUFFIX) gecode/set/rel-op/post-nocompl$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -7822,7 +7822,7 @@ gecode/set/rel-op/post-nocompl$(OBJSUFFIX) gecode/set/rel-op/post-nocompl$(SBJSU ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/rel-op/post-compl-cvv$(OBJSUFFIX) gecode/set/rel-op/post-compl-cvv$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -7902,7 +7902,7 @@ gecode/set/rel-op/post-compl-cvv$(OBJSUFFIX) gecode/set/rel-op/post-compl-cvv$(S ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/rel-op/post-nocompl-cvv$(OBJSUFFIX) gecode/set/rel-op/post-nocompl-cvv$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -7982,7 +7982,7 @@ gecode/set/rel-op/post-nocompl-cvv$(OBJSUFFIX) gecode/set/rel-op/post-nocompl-cv ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/rel-op/post-compl-vvc$(OBJSUFFIX) gecode/set/rel-op/post-compl-vvc$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -8062,7 +8062,7 @@ gecode/set/rel-op/post-compl-vvc$(OBJSUFFIX) gecode/set/rel-op/post-compl-vvc$(S ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/rel-op/post-nocompl-vvc$(OBJSUFFIX) gecode/set/rel-op/post-nocompl-vvc$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -8142,7 +8142,7 @@ gecode/set/rel-op/post-nocompl-vvc$(OBJSUFFIX) gecode/set/rel-op/post-nocompl-vv ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/rel-op/post-compl-cvc$(OBJSUFFIX) gecode/set/rel-op/post-compl-cvc$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -8222,7 +8222,7 @@ gecode/set/rel-op/post-compl-cvc$(OBJSUFFIX) gecode/set/rel-op/post-compl-cvc$(S ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/rel-op/post-nocompl-cvc$(OBJSUFFIX) gecode/set/rel-op/post-nocompl-cvc$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -8302,7 +8302,7 @@ gecode/set/rel-op/post-nocompl-cvc$(OBJSUFFIX) gecode/set/rel-op/post-nocompl-cv ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/rel-op-const-vvc$(OBJSUFFIX) gecode/set/rel-op-const-vvc$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -8382,7 +8382,7 @@ gecode/set/rel-op-const-vvc$(OBJSUFFIX) gecode/set/rel-op-const-vvc$(SBJSUFFIX): ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/rel-op-const-vcv$(OBJSUFFIX) gecode/set/rel-op-const-vcv$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -8462,7 +8462,7 @@ gecode/set/rel-op-const-vcv$(OBJSUFFIX) gecode/set/rel-op-const-vcv$(SBJSUFFIX): ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/rel-op-const-vcc$(OBJSUFFIX) gecode/set/rel-op-const-vcc$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -8542,7 +8542,7 @@ gecode/set/rel-op-const-vcc$(OBJSUFFIX) gecode/set/rel-op-const-vcc$(SBJSUFFIX): ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/rel-op-const-cvc$(OBJSUFFIX) gecode/set/rel-op-const-cvc$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -8622,7 +8622,7 @@ gecode/set/rel-op-const-cvc$(OBJSUFFIX) gecode/set/rel-op-const-cvc$(SBJSUFFIX): ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/rel-op-const-cvv$(OBJSUFFIX) gecode/set/rel-op-const-cvv$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -8702,7 +8702,7 @@ gecode/set/rel-op-const-cvv$(OBJSUFFIX) gecode/set/rel-op-const-cvv$(SBJSUFFIX): ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/int$(OBJSUFFIX) gecode/set/int$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -8780,7 +8780,7 @@ gecode/set/int$(OBJSUFFIX) gecode/set/int$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/set/channel$(OBJSUFFIX) gecode/set/channel$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -8859,7 +8859,7 @@ gecode/set/channel$(OBJSUFFIX) gecode/set/channel$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/bool$(OBJSUFFIX) gecode/set/bool$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -8933,7 +8933,7 @@ gecode/set/bool$(OBJSUFFIX) gecode/set/bool$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/element$(OBJSUFFIX) gecode/set/element$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -9018,7 +9018,7 @@ gecode/set/element$(OBJSUFFIX) gecode/set/element$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/set/sequence$(OBJSUFFIX) gecode/set/sequence$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -9097,7 +9097,7 @@ gecode/set/sequence$(OBJSUFFIX) gecode/set/sequence$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/distinct$(OBJSUFFIX) gecode/set/distinct$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -9171,7 +9171,7 @@ gecode/set/distinct$(OBJSUFFIX) gecode/set/distinct$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/set/distinct/atmostOne$(OBJSUFFIX) gecode/set/distinct/atmostOne$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -9245,7 +9245,7 @@ gecode/set/distinct/atmostOne$(OBJSUFFIX) gecode/set/distinct/atmostOne$(SBJSUFF ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/set/precede$(OBJSUFFIX) gecode/set/precede$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -9319,7 +9319,7 @@ gecode/set/precede$(OBJSUFFIX) gecode/set/precede$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/set/sequence/seq$(OBJSUFFIX) gecode/set/sequence/seq$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -9398,7 +9398,7 @@ gecode/set/sequence/seq$(OBJSUFFIX) gecode/set/sequence/seq$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/sequence/seq-u$(OBJSUFFIX) gecode/set/sequence/seq-u$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -9477,7 +9477,7 @@ gecode/set/sequence/seq-u$(OBJSUFFIX) gecode/set/sequence/seq-u$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/array$(OBJSUFFIX) gecode/set/array$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -9551,7 +9551,7 @@ gecode/set/array$(OBJSUFFIX) gecode/set/array$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/var-imp/set$(OBJSUFFIX) gecode/set/var-imp/set$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -9625,7 +9625,7 @@ gecode/set/var-imp/set$(OBJSUFFIX) gecode/set/var-imp/set$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/var-imp/integerset$(OBJSUFFIX) gecode/set/var-imp/integerset$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -9699,7 +9699,7 @@ gecode/set/var-imp/integerset$(OBJSUFFIX) gecode/set/var-imp/integerset$(SBJSUFF ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/var/set$(OBJSUFFIX) gecode/set/var/set$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -9773,7 +9773,7 @@ gecode/set/var/set$(OBJSUFFIX) gecode/set/var/set$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/exec$(OBJSUFFIX) gecode/set/exec$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -9847,7 +9847,7 @@ gecode/set/exec$(OBJSUFFIX) gecode/set/exec$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/branch/action$(OBJSUFFIX) gecode/set/branch/action$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -9921,7 +9921,7 @@ gecode/set/branch/action$(OBJSUFFIX) gecode/set/branch/action$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/branch/chb$(OBJSUFFIX) gecode/set/branch/chb$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -9995,7 +9995,7 @@ gecode/set/branch/chb$(OBJSUFFIX) gecode/set/branch/chb$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/branch/view-sel$(OBJSUFFIX) gecode/set/branch/view-sel$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -10070,7 +10070,7 @@ gecode/set/branch/view-sel$(OBJSUFFIX) gecode/set/branch/view-sel$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/set/branch/val-sel-commit$(OBJSUFFIX) gecode/set/branch/val-sel-commit$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -10145,7 +10145,7 @@ gecode/set/branch/val-sel-commit$(OBJSUFFIX) gecode/set/branch/val-sel-commit$(S ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/set/branch/ngl$(OBJSUFFIX) gecode/set/branch/ngl$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -10220,7 +10220,7 @@ gecode/set/branch/ngl$(OBJSUFFIX) gecode/set/branch/ngl$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/set/ldsb$(OBJSUFFIX) gecode/set/ldsb$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -10297,7 +10297,7 @@ gecode/set/ldsb$(OBJSUFFIX) gecode/set/ldsb$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/set/ldsb/sym-imp$(OBJSUFFIX) gecode/set/ldsb/sym-imp$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -10372,7 +10372,7 @@ gecode/set/ldsb/sym-imp$(OBJSUFFIX) gecode/set/ldsb/sym-imp$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/set/relax$(OBJSUFFIX) gecode/set/relax$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -10446,7 +10446,7 @@ gecode/set/relax$(OBJSUFFIX) gecode/set/relax$(SBJSUFFIX): \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp gecode/set/trace$(OBJSUFFIX) gecode/set/trace$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -10520,7 +10520,7 @@ gecode/set/trace$(OBJSUFFIX) gecode/set/trace$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/trace/tracer$(OBJSUFFIX) gecode/set/trace/tracer$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -10594,7 +10594,7 @@ gecode/set/trace/tracer$(OBJSUFFIX) gecode/set/trace/tracer$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp gecode/set/exception$(OBJSUFFIX) gecode/set/exception$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -10679,7 +10679,7 @@ gecode/minimodel/int-expr$(OBJSUFFIX) gecode/minimodel/int-expr$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/bool.hh ./gecode/int/bool/base.hpp \ ./gecode/int/bool/clause.hpp ./gecode/int/bool/eq.hpp ./gecode/int/bool/eqv.hpp \ ./gecode/int/bool/ite.hpp ./gecode/int/bool/lq.hpp ./gecode/int/bool/or.hpp \ @@ -10777,7 +10777,7 @@ gecode/minimodel/int-rel$(OBJSUFFIX) gecode/minimodel/int-rel$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -10867,7 +10867,7 @@ gecode/minimodel/int-arith$(OBJSUFFIX) gecode/minimodel/int-arith$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -10957,7 +10957,7 @@ gecode/minimodel/bool-expr$(OBJSUFFIX) gecode/minimodel/bool-expr$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -11047,7 +11047,7 @@ gecode/minimodel/set-expr$(OBJSUFFIX) gecode/minimodel/set-expr$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -11137,7 +11137,7 @@ gecode/minimodel/set-rel$(OBJSUFFIX) gecode/minimodel/set-rel$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -11227,7 +11227,7 @@ gecode/minimodel/dom$(OBJSUFFIX) gecode/minimodel/dom$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -11318,7 +11318,7 @@ gecode/minimodel/float-expr$(OBJSUFFIX) gecode/minimodel/float-expr$(SBJSUFFIX): ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -11408,7 +11408,7 @@ gecode/minimodel/float-rel$(OBJSUFFIX) gecode/minimodel/float-rel$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -11498,7 +11498,7 @@ gecode/minimodel/float-arith$(OBJSUFFIX) gecode/minimodel/float-arith$(SBJSUFFIX ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -11588,7 +11588,7 @@ gecode/minimodel/reg$(OBJSUFFIX) gecode/minimodel/reg$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -11678,7 +11678,7 @@ gecode/minimodel/optimize$(OBJSUFFIX) gecode/minimodel/optimize$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -11768,7 +11768,7 @@ gecode/minimodel/exception$(OBJSUFFIX) gecode/minimodel/exception$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -11858,7 +11858,7 @@ gecode/minimodel/ipl$(OBJSUFFIX) gecode/minimodel/ipl$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -11950,7 +11950,7 @@ gecode/driver/options$(OBJSUFFIX) gecode/driver/options$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -12042,7 +12042,7 @@ gecode/driver/script$(OBJSUFFIX) gecode/driver/script$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -12134,7 +12134,7 @@ examples/alpha$(OBJSUFFIX) examples/alpha$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -12226,7 +12226,7 @@ examples/bacp$(OBJSUFFIX) examples/bacp$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hh ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/cbs.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/merit.hpp ./gecode/int/branch/ngl.hpp \ @@ -12320,7 +12320,7 @@ examples/bibd$(OBJSUFFIX) examples/bibd$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -12412,7 +12412,7 @@ examples/donald$(OBJSUFFIX) examples/donald$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -12504,7 +12504,7 @@ examples/efpa$(OBJSUFFIX) examples/efpa$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -12596,7 +12596,7 @@ examples/eq20$(OBJSUFFIX) examples/eq20$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -12688,7 +12688,7 @@ examples/golomb-ruler$(OBJSUFFIX) examples/golomb-ruler$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -12780,7 +12780,7 @@ examples/graph-color$(OBJSUFFIX) examples/graph-color$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -12872,7 +12872,7 @@ examples/grocery$(OBJSUFFIX) examples/grocery$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -12964,7 +12964,7 @@ examples/ind-set$(OBJSUFFIX) examples/ind-set$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -13056,7 +13056,7 @@ examples/magic-sequence$(OBJSUFFIX) examples/magic-sequence$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -13148,7 +13148,7 @@ examples/magic-square$(OBJSUFFIX) examples/magic-square$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -13240,7 +13240,7 @@ examples/money$(OBJSUFFIX) examples/money$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -13332,7 +13332,7 @@ examples/ortho-latin$(OBJSUFFIX) examples/ortho-latin$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -13424,7 +13424,7 @@ examples/partition$(OBJSUFFIX) examples/partition$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -13516,7 +13516,7 @@ examples/photo$(OBJSUFFIX) examples/photo$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -13608,7 +13608,7 @@ examples/queens$(OBJSUFFIX) examples/queens$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -13700,7 +13700,7 @@ examples/sudoku$(OBJSUFFIX) examples/sudoku$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -13792,7 +13792,7 @@ examples/sudoku-advanced$(OBJSUFFIX) examples/sudoku-advanced$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -13884,7 +13884,7 @@ examples/kakuro$(OBJSUFFIX) examples/kakuro$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -13976,7 +13976,7 @@ examples/nonogram$(OBJSUFFIX) examples/nonogram$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -14068,7 +14068,7 @@ examples/pentominoes$(OBJSUFFIX) examples/pentominoes$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -14160,7 +14160,7 @@ examples/crowded-chess$(OBJSUFFIX) examples/crowded-chess$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -14252,7 +14252,7 @@ examples/black-hole$(OBJSUFFIX) examples/black-hole$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -14344,7 +14344,7 @@ examples/minesweeper$(OBJSUFFIX) examples/minesweeper$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -14436,7 +14436,7 @@ examples/domino$(OBJSUFFIX) examples/domino$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -14528,7 +14528,7 @@ examples/steel-mill$(OBJSUFFIX) examples/steel-mill$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -14620,7 +14620,7 @@ examples/sports-league$(OBJSUFFIX) examples/sports-league$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -14712,7 +14712,7 @@ examples/all-interval$(OBJSUFFIX) examples/all-interval$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -14804,7 +14804,7 @@ examples/langford-number$(OBJSUFFIX) examples/langford-number$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -14896,7 +14896,7 @@ examples/warehouses$(OBJSUFFIX) examples/warehouses$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -14988,7 +14988,7 @@ examples/radiotherapy$(OBJSUFFIX) examples/radiotherapy$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -15080,7 +15080,7 @@ examples/word-square$(OBJSUFFIX) examples/word-square$(SBJSUFFIX): \ ./gecode/float/var/print.hpp ./gecode/float/view.hpp ./gecode/float/view/float.hpp \ ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp \ ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp ./gecode/gist.hh \ - ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -15172,7 +15172,7 @@ examples/crossword$(OBJSUFFIX) examples/crossword$(SBJSUFFIX): \ ./gecode/float/var/print.hpp ./gecode/float/view.hpp ./gecode/float/view/float.hpp \ ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp \ ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp ./gecode/gist.hh \ - ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -15264,7 +15264,7 @@ examples/open-shop$(OBJSUFFIX) examples/open-shop$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -15356,7 +15356,7 @@ examples/car-sequencing$(OBJSUFFIX) examples/car-sequencing$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -15448,7 +15448,7 @@ examples/sat$(OBJSUFFIX) examples/sat$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -15540,7 +15540,7 @@ examples/bin-packing$(OBJSUFFIX) examples/bin-packing$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -15632,7 +15632,7 @@ examples/knights$(OBJSUFFIX) examples/knights$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -15724,7 +15724,7 @@ examples/tsp$(OBJSUFFIX) examples/tsp$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -15816,7 +15816,7 @@ examples/perfect-square$(OBJSUFFIX) examples/perfect-square$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -15908,7 +15908,7 @@ examples/schurs-lemma$(OBJSUFFIX) examples/schurs-lemma$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -16000,7 +16000,7 @@ examples/dominating-queens$(OBJSUFFIX) examples/dominating-queens$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -16092,7 +16092,7 @@ examples/colored-matrix$(OBJSUFFIX) examples/colored-matrix$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -16184,7 +16184,7 @@ examples/multi-bin-packing$(OBJSUFFIX) examples/multi-bin-packing$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -16276,7 +16276,7 @@ examples/qcp$(OBJSUFFIX) examples/qcp$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -16368,7 +16368,7 @@ examples/job-shop$(OBJSUFFIX) examples/job-shop$(SBJSUFFIX): \ ./gecode/float/var/print.hpp ./gecode/float/view.hpp ./gecode/float/view/float.hpp \ ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp \ ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp ./gecode/gist.hh \ - ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -16460,7 +16460,7 @@ examples/crew$(OBJSUFFIX) examples/crew$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -16552,7 +16552,7 @@ examples/golf$(OBJSUFFIX) examples/golf$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -16644,7 +16644,7 @@ examples/hamming$(OBJSUFFIX) examples/hamming$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -16736,7 +16736,7 @@ examples/steiner$(OBJSUFFIX) examples/steiner$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -16828,7 +16828,7 @@ examples/queen-armies$(OBJSUFFIX) examples/queen-armies$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -16920,7 +16920,7 @@ examples/cartesian-heart$(OBJSUFFIX) examples/cartesian-heart$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -17012,7 +17012,7 @@ examples/descartes-folium$(OBJSUFFIX) examples/descartes-folium$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -17104,7 +17104,7 @@ examples/archimedean-spiral$(OBJSUFFIX) examples/archimedean-spiral$(SBJSUFFIX): ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -17196,7 +17196,7 @@ examples/golden-spiral$(OBJSUFFIX) examples/golden-spiral$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -17321,7 +17321,7 @@ gecode/gist/gist$(OBJSUFFIX) gecode/gist/gist$(SBJSUFFIX): \ ./gecode/gist/nodestats.hh ./gecode/gist/qtgist.hh ./gecode/gist/spacenode.hh \ ./gecode/gist/spacenode.hpp ./gecode/gist/stopbrancher.hh ./gecode/gist/textoutput.hh \ ./gecode/gist/treecanvas.hh ./gecode/gist/visualnode.hh ./gecode/gist/visualnode.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -17439,7 +17439,7 @@ gecode/gist/spacenode$(OBJSUFFIX) gecode/gist/spacenode$(SBJSUFFIX): \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ ./gecode/gist/node.hh ./gecode/gist/node.hpp ./gecode/gist/spacenode.hh \ ./gecode/gist/spacenode.hpp ./gecode/gist/stopbrancher.hh ./gecode/gist/visualnode.hh \ - ./gecode/gist/visualnode.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/gist/visualnode.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -17532,7 +17532,7 @@ gecode/gist/treecanvas$(OBJSUFFIX) gecode/gist/treecanvas$(SBJSUFFIX): \ ./gecode/gist/nodecursor.hh ./gecode/gist/nodecursor.hpp ./gecode/gist/nodevisitor.hh \ ./gecode/gist/nodevisitor.hpp ./gecode/gist/spacenode.hh ./gecode/gist/spacenode.hpp \ ./gecode/gist/treecanvas.hh ./gecode/gist/visualnode.hh ./gecode/gist/visualnode.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -17622,7 +17622,7 @@ gecode/gist/qtgist$(OBJSUFFIX) gecode/gist/qtgist$(SBJSUFFIX): \ ./gecode/gist/nodecursor.hpp ./gecode/gist/nodestats.hh ./gecode/gist/nodevisitor.hh \ ./gecode/gist/nodevisitor.hpp ./gecode/gist/qtgist.hh ./gecode/gist/spacenode.hh \ ./gecode/gist/spacenode.hpp ./gecode/gist/treecanvas.hh ./gecode/gist/visualnode.hh \ - ./gecode/gist/visualnode.hpp ./gecode/gist/zoomToFitIcon.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist/visualnode.hpp ./gecode/gist/zoomToFitIcon.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -17744,7 +17744,7 @@ gecode/gist/nodestats$(OBJSUFFIX) gecode/gist/nodestats$(SBJSUFFIX): \ ./gecode/gist/nodevisitor.hh ./gecode/gist/nodevisitor.hpp ./gecode/gist/nodewidget.hh \ ./gecode/gist/qtgist.hh ./gecode/gist/spacenode.hh ./gecode/gist/spacenode.hpp \ ./gecode/gist/treecanvas.hh ./gecode/gist/visualnode.hh ./gecode/gist/visualnode.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -17835,7 +17835,7 @@ gecode/gist/nodewidget$(OBJSUFFIX) gecode/gist/nodewidget$(SBJSUFFIX): \ ./gecode/gist/nodecursor.hh ./gecode/gist/nodecursor.hpp ./gecode/gist/nodestats.hh \ ./gecode/gist/nodewidget.hh ./gecode/gist/qtgist.hh ./gecode/gist/spacenode.hh \ ./gecode/gist/spacenode.hpp ./gecode/gist/treecanvas.hh ./gecode/gist/visualnode.hh \ - ./gecode/gist/visualnode.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/gist/visualnode.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -17927,7 +17927,7 @@ gecode/gist/mainwindow$(OBJSUFFIX) gecode/gist/mainwindow$(SBJSUFFIX): \ ./gecode/gist/nodecursor.hpp ./gecode/gist/nodestats.hh ./gecode/gist/nodewidget.hh \ ./gecode/gist/preferences.hh ./gecode/gist/qtgist.hh ./gecode/gist/spacenode.hh \ ./gecode/gist/spacenode.hpp ./gecode/gist/treecanvas.hh ./gecode/gist/visualnode.hh \ - ./gecode/gist/visualnode.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/gist/visualnode.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -18013,7 +18013,7 @@ gecode/gist/preferences$(OBJSUFFIX) gecode/gist/preferences$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/gist/preferences.hh ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/gist/preferences.hh ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -18099,7 +18099,7 @@ gecode/gist/stopbrancher$(OBJSUFFIX) gecode/gist/stopbrancher$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/gist/stopbrancher.hh ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/gist/stopbrancher.hh ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -18189,7 +18189,7 @@ gecode/flatzinc/flatzinc$(OBJSUFFIX) gecode/flatzinc/flatzinc$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hh ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/cbs.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/merit.hpp ./gecode/int/branch/ngl.hpp \ @@ -18285,7 +18285,7 @@ gecode/flatzinc/registry$(OBJSUFFIX) gecode/flatzinc/registry$(SBJSUFFIX): \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -18379,7 +18379,7 @@ gecode/flatzinc/branch$(OBJSUFFIX) gecode/flatzinc/branch$(SBJSUFFIX): \ ./gecode/float/var/print.hpp ./gecode/float/view.hpp ./gecode/float/view/float.hpp \ ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp \ ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp ./gecode/gist.hh \ - ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hh ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/cbs.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/merit.hpp \ @@ -18475,7 +18475,7 @@ tools/flatzinc/fzn-gecode$(OBJSUFFIX) tools/flatzinc/fzn-gecode$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -18571,7 +18571,7 @@ gecode/flatzinc/parser.tab$(OBJSUFFIX) gecode/flatzinc/parser.tab$(SBJSUFFIX): \ ./gecode/float/var/print.hpp ./gecode/float/view.hpp ./gecode/float/view/float.hpp \ ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp \ ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp ./gecode/gist.hh \ - ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -18677,7 +18677,7 @@ gecode/flatzinc/lexer.yy$(OBJSUFFIX) gecode/flatzinc/lexer.yy$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -18757,7 +18757,7 @@ gecode/flatzinc/lexer.yy$(OBJSUFFIX) gecode/flatzinc/lexer.yy$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp test/test$(OBJSUFFIX) test/test$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -18821,7 +18821,7 @@ test/test$(OBJSUFFIX) test/test$(SBJSUFFIX): \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp ./test/test.hh \ ./test/test.hpp test/afc$(OBJSUFFIX) test/afc$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -18896,7 +18896,7 @@ test/ldsb$(OBJSUFFIX) test/ldsb$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hh ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/cbs.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/merit.hpp \ @@ -18980,7 +18980,7 @@ test/ldsb$(OBJSUFFIX) test/ldsb$(SBJSUFFIX): \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp \ ./test/test.hh ./test/test.hpp test/region$(OBJSUFFIX) test/region$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -19044,7 +19044,7 @@ test/region$(OBJSUFFIX) test/region$(SBJSUFFIX): \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp ./test/test.hh \ ./test/test.hpp test/groups$(OBJSUFFIX) test/groups$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -19108,7 +19108,7 @@ test/groups$(OBJSUFFIX) test/groups$(SBJSUFFIX): \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp ./test/test.hh \ ./test/test.hpp test/int$(OBJSUFFIX) test/int$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -19183,7 +19183,7 @@ test/int/channel$(OBJSUFFIX) test/int/channel$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -19275,7 +19275,7 @@ test/int/arithmetic$(OBJSUFFIX) test/int/arithmetic$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -19356,7 +19356,7 @@ test/int/arithmetic$(OBJSUFFIX) test/int/arithmetic$(SBJSUFFIX): \ ./test/int.hh ./test/int.hpp ./test/test.hh \ ./test/test.hpp test/int/basic$(OBJSUFFIX) test/int/basic$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -19431,7 +19431,7 @@ test/int/bool$(OBJSUFFIX) test/int/bool$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -19512,7 +19512,7 @@ test/int/bool$(OBJSUFFIX) test/int/bool$(SBJSUFFIX): \ ./test/int.hh ./test/int.hpp ./test/test.hh \ ./test/test.hpp test/int/count$(OBJSUFFIX) test/int/count$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -19587,7 +19587,7 @@ test/int/dom$(OBJSUFFIX) test/int/dom$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -19679,7 +19679,7 @@ test/int/distinct$(OBJSUFFIX) test/int/distinct$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -19771,7 +19771,7 @@ test/int/element$(OBJSUFFIX) test/int/element$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -19863,7 +19863,7 @@ test/int/extensional$(OBJSUFFIX) test/int/extensional$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -19955,7 +19955,7 @@ test/int/rel$(OBJSUFFIX) test/int/rel$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -20047,7 +20047,7 @@ test/int/linear$(OBJSUFFIX) test/int/linear$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -20128,7 +20128,7 @@ test/int/linear$(OBJSUFFIX) test/int/linear$(SBJSUFFIX): \ ./test/int.hh ./test/int.hpp ./test/test.hh \ ./test/test.hpp test/int/gcc$(OBJSUFFIX) test/int/gcc$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -20192,7 +20192,7 @@ test/int/gcc$(OBJSUFFIX) test/int/gcc$(SBJSUFFIX): \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp ./test/int.hh \ ./test/int.hpp ./test/test.hh ./test/test.hpp test/int/sorted$(OBJSUFFIX) test/int/sorted$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -20267,7 +20267,7 @@ test/int/unshare$(OBJSUFFIX) test/int/unshare$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -20359,7 +20359,7 @@ test/int/exec$(OBJSUFFIX) test/int/exec$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -20451,7 +20451,7 @@ test/int/sequence$(OBJSUFFIX) test/int/sequence$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -20543,7 +20543,7 @@ test/int/mm-arithmetic$(OBJSUFFIX) test/int/mm-arithmetic$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -20635,7 +20635,7 @@ test/int/mm-bool$(OBJSUFFIX) test/int/mm-bool$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -20727,7 +20727,7 @@ test/int/mm-lin$(OBJSUFFIX) test/int/mm-lin$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -20819,7 +20819,7 @@ test/int/mm-count$(OBJSUFFIX) test/int/mm-count$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -20911,7 +20911,7 @@ test/int/mm-rel$(OBJSUFFIX) test/int/mm-rel$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -21003,7 +21003,7 @@ test/int/bin-packing$(OBJSUFFIX) test/int/bin-packing$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -21095,7 +21095,7 @@ test/int/order$(OBJSUFFIX) test/int/order$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -21187,7 +21187,7 @@ test/int/unary$(OBJSUFFIX) test/int/unary$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -21279,7 +21279,7 @@ test/int/cumulative$(OBJSUFFIX) test/int/cumulative$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -21383,7 +21383,7 @@ test/int/cumulatives$(OBJSUFFIX) test/int/cumulatives$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -21475,7 +21475,7 @@ test/int/circuit$(OBJSUFFIX) test/int/circuit$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -21567,7 +21567,7 @@ test/int/no-overlap$(OBJSUFFIX) test/int/no-overlap$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -21648,7 +21648,7 @@ test/int/no-overlap$(OBJSUFFIX) test/int/no-overlap$(SBJSUFFIX): \ ./test/int.hh ./test/int.hpp ./test/test.hh \ ./test/test.hpp test/int/precede$(OBJSUFFIX) test/int/precede$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -21723,7 +21723,7 @@ test/int/nvalues$(OBJSUFFIX) test/int/nvalues$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -21815,7 +21815,7 @@ test/int/member$(OBJSUFFIX) test/int/member$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -21896,7 +21896,7 @@ test/int/member$(OBJSUFFIX) test/int/member$(SBJSUFFIX): \ ./test/int.hh ./test/int.hpp ./test/test.hh \ ./test/test.hpp test/set$(OBJSUFFIX) test/set$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -21972,7 +21972,7 @@ test/set$(OBJSUFFIX) test/set$(SBJSUFFIX): \ ./test/set.hh ./test/set.hpp ./test/test.hh \ ./test/test.hpp test/set/construct$(OBJSUFFIX) test/set/construct$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -22059,7 +22059,7 @@ test/set/dom$(OBJSUFFIX) test/set/dom$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -22151,7 +22151,7 @@ test/set/rel$(OBJSUFFIX) test/set/rel$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -22232,7 +22232,7 @@ test/set/rel$(OBJSUFFIX) test/set/rel$(SBJSUFFIX): \ ./test/int.hh ./test/int.hpp ./test/set.hh \ ./test/set.hpp ./test/test.hh ./test/test.hpp test/set/rel-op$(OBJSUFFIX) test/set/rel-op$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -22308,7 +22308,7 @@ test/set/rel-op$(OBJSUFFIX) test/set/rel-op$(SBJSUFFIX): \ ./test/set.hh ./test/set.hpp ./test/test.hh \ ./test/test.hpp test/set/rel-op-const$(OBJSUFFIX) test/set/rel-op-const$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -22384,7 +22384,7 @@ test/set/rel-op-const$(OBJSUFFIX) test/set/rel-op-const$(SBJSUFFIX): \ ./test/set.hh ./test/set.hpp ./test/test.hh \ ./test/test.hpp test/set/convex$(OBJSUFFIX) test/set/convex$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -22460,7 +22460,7 @@ test/set/convex$(OBJSUFFIX) test/set/convex$(SBJSUFFIX): \ ./test/set.hh ./test/set.hpp ./test/test.hh \ ./test/test.hpp test/set/sequence$(OBJSUFFIX) test/set/sequence$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -22547,7 +22547,7 @@ test/set/int$(OBJSUFFIX) test/set/int$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -22639,7 +22639,7 @@ test/set/element$(OBJSUFFIX) test/set/element$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -22720,7 +22720,7 @@ test/set/element$(OBJSUFFIX) test/set/element$(SBJSUFFIX): \ ./test/int.hh ./test/int.hpp ./test/set.hh \ ./test/set.hpp ./test/test.hh ./test/test.hpp test/set/precede$(OBJSUFFIX) test/set/precede$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -22796,7 +22796,7 @@ test/set/precede$(OBJSUFFIX) test/set/precede$(SBJSUFFIX): \ ./test/set.hh ./test/set.hpp ./test/test.hh \ ./test/test.hpp test/set/distinct$(OBJSUFFIX) test/set/distinct$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -22872,7 +22872,7 @@ test/set/distinct$(OBJSUFFIX) test/set/distinct$(SBJSUFFIX): \ ./test/set.hh ./test/set.hpp ./test/test.hh \ ./test/test.hpp test/set/exec$(OBJSUFFIX) test/set/exec$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -22959,7 +22959,7 @@ test/set/mm-set$(OBJSUFFIX) test/set/mm-set$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -23051,7 +23051,7 @@ test/set/channel$(OBJSUFFIX) test/set/channel$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -23143,7 +23143,7 @@ test/float$(OBJSUFFIX) test/float$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -23219,7 +23219,7 @@ test/float/basic$(OBJSUFFIX) test/float/basic$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -23295,7 +23295,7 @@ test/float/arithmetic$(OBJSUFFIX) test/float/arithmetic$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -23387,7 +23387,7 @@ test/float/transcendental$(OBJSUFFIX) test/float/transcendental$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -23479,7 +23479,7 @@ test/float/trigonometric$(OBJSUFFIX) test/float/trigonometric$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -23571,7 +23571,7 @@ test/float/linear$(OBJSUFFIX) test/float/linear$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -23663,7 +23663,7 @@ test/float/rel$(OBJSUFFIX) test/float/rel$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -23755,7 +23755,7 @@ test/float/channel$(OBJSUFFIX) test/float/channel$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -23847,7 +23847,7 @@ test/float/mm-lin$(OBJSUFFIX) test/float/mm-lin$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -23939,7 +23939,7 @@ test/float/dom$(OBJSUFFIX) test/float/dom$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -24031,7 +24031,7 @@ test/branch$(OBJSUFFIX) test/branch$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -24117,7 +24117,7 @@ test/branch/int$(OBJSUFFIX) test/branch/int$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -24203,7 +24203,7 @@ test/branch/bool$(OBJSUFFIX) test/branch/bool$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -24289,7 +24289,7 @@ test/branch/set$(OBJSUFFIX) test/branch/set$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -24375,7 +24375,7 @@ test/branch/float$(OBJSUFFIX) test/branch/float$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -24461,7 +24461,7 @@ test/assign$(OBJSUFFIX) test/assign$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -24547,7 +24547,7 @@ test/assign/int$(OBJSUFFIX) test/assign/int$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -24633,7 +24633,7 @@ test/assign/bool$(OBJSUFFIX) test/assign/bool$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -24719,7 +24719,7 @@ test/assign/set$(OBJSUFFIX) test/assign/set$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -24805,7 +24805,7 @@ test/assign/float$(OBJSUFFIX) test/assign/float$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -24891,7 +24891,7 @@ test/search$(OBJSUFFIX) test/search$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -24982,7 +24982,7 @@ test/nogoods$(OBJSUFFIX) test/nogoods$(SBJSUFFIX): \ ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ - ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp \ + ./gecode/float/view/scale.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp \ ./gecode/int/array.hpp ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp \ ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp \ @@ -25062,7 +25062,7 @@ test/nogoods$(OBJSUFFIX) test/nogoods$(SBJSUFFIX): \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp \ ./test/test.hh ./test/test.hpp test/array$(OBJSUFFIX) test/array$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/open-sequence.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -25140,7 +25140,7 @@ test/flatzinc$(OBJSUFFIX) test/flatzinc$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -25235,7 +25235,7 @@ test/flatzinc/bool_clause$(OBJSUFFIX) test/flatzinc/bool_clause$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -25330,7 +25330,7 @@ test/flatzinc/bug232$(OBJSUFFIX) test/flatzinc/bug232$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -25425,7 +25425,7 @@ test/flatzinc/bug319$(OBJSUFFIX) test/flatzinc/bug319$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -25520,7 +25520,7 @@ test/flatzinc/bugfix_r6746$(OBJSUFFIX) test/flatzinc/bugfix_r6746$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -25615,7 +25615,7 @@ test/flatzinc/bugfix_r7854$(OBJSUFFIX) test/flatzinc/bugfix_r7854$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -25710,7 +25710,7 @@ test/flatzinc/empty_domain_1$(OBJSUFFIX) test/flatzinc/empty_domain_1$(SBJSUFFIX ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -25805,7 +25805,7 @@ test/flatzinc/empty_domain_2$(OBJSUFFIX) test/flatzinc/empty_domain_2$(SBJSUFFIX ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -25900,7 +25900,7 @@ test/flatzinc/int_set_as_type1$(OBJSUFFIX) test/flatzinc/int_set_as_type1$(SBJSU ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -25995,7 +25995,7 @@ test/flatzinc/int_set_as_type2$(OBJSUFFIX) test/flatzinc/int_set_as_type2$(SBJSU ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -26090,7 +26090,7 @@ test/flatzinc/jobshop$(OBJSUFFIX) test/flatzinc/jobshop$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -26185,7 +26185,7 @@ test/flatzinc/no_warn_empty_domain$(OBJSUFFIX) test/flatzinc/no_warn_empty_domai ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -26280,7 +26280,7 @@ test/flatzinc/output_test$(OBJSUFFIX) test/flatzinc/output_test$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -26375,7 +26375,7 @@ test/flatzinc/queens4$(OBJSUFFIX) test/flatzinc/queens4$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -26470,7 +26470,7 @@ test/flatzinc/sat_arith1$(OBJSUFFIX) test/flatzinc/sat_arith1$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -26565,7 +26565,7 @@ test/flatzinc/sat_array_bool_and$(OBJSUFFIX) test/flatzinc/sat_array_bool_and$(S ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -26660,7 +26660,7 @@ test/flatzinc/sat_array_bool_or$(OBJSUFFIX) test/flatzinc/sat_array_bool_or$(SBJ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -26755,7 +26755,7 @@ test/flatzinc/sat_cmp_reif$(OBJSUFFIX) test/flatzinc/sat_cmp_reif$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -26850,7 +26850,7 @@ test/flatzinc/sat_eq_reif$(OBJSUFFIX) test/flatzinc/sat_eq_reif$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -26945,7 +26945,7 @@ test/flatzinc/test_approx_bnb$(OBJSUFFIX) test/flatzinc/test_approx_bnb$(SBJSUFF ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -27040,7 +27040,7 @@ test/flatzinc/test_array_just_right$(OBJSUFFIX) test/flatzinc/test_array_just_ri ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -27135,7 +27135,7 @@ test/flatzinc/test_assigned_var_bounds_bad$(OBJSUFFIX) test/flatzinc/test_assign ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -27230,7 +27230,7 @@ test/flatzinc/test_flatzinc_output_anns$(OBJSUFFIX) test/flatzinc/test_flatzinc_ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -27325,7 +27325,7 @@ test/flatzinc/test_fzn_arith$(OBJSUFFIX) test/flatzinc/test_fzn_arith$(SBJSUFFIX ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -27420,7 +27420,7 @@ test/flatzinc/test_fzn_arrays$(OBJSUFFIX) test/flatzinc/test_fzn_arrays$(SBJSUFF ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -27515,7 +27515,7 @@ test/flatzinc/test_fzn_coercions$(OBJSUFFIX) test/flatzinc/test_fzn_coercions$(S ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -27610,7 +27610,7 @@ test/flatzinc/test_fzn_comparison$(OBJSUFFIX) test/flatzinc/test_fzn_comparison$ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -27705,7 +27705,7 @@ test/flatzinc/test_fzn_logic$(OBJSUFFIX) test/flatzinc/test_fzn_logic$(SBJSUFFIX ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -27800,7 +27800,7 @@ test/flatzinc/test_fzn_sets$(OBJSUFFIX) test/flatzinc/test_fzn_sets$(SBJSUFFIX): ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -27895,7 +27895,7 @@ test/flatzinc/test_int_div$(OBJSUFFIX) test/flatzinc/test_int_div$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -27990,7 +27990,7 @@ test/flatzinc/test_int_mod$(OBJSUFFIX) test/flatzinc/test_int_mod$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -28085,7 +28085,7 @@ test/flatzinc/test_int_ranges_as_values$(OBJSUFFIX) test/flatzinc/test_int_range ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -28180,7 +28180,7 @@ test/flatzinc/test_seq_search$(OBJSUFFIX) test/flatzinc/test_seq_search$(SBJSUFF ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -28275,7 +28275,7 @@ test/flatzinc/2dpacking$(OBJSUFFIX) test/flatzinc/2dpacking$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -28370,7 +28370,7 @@ test/flatzinc/alpha$(OBJSUFFIX) test/flatzinc/alpha$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -28465,7 +28465,7 @@ test/flatzinc/battleships1$(OBJSUFFIX) test/flatzinc/battleships1$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -28560,7 +28560,7 @@ test/flatzinc/battleships10$(OBJSUFFIX) test/flatzinc/battleships10$(SBJSUFFIX): ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -28655,7 +28655,7 @@ test/flatzinc/battleships2$(OBJSUFFIX) test/flatzinc/battleships2$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -28750,7 +28750,7 @@ test/flatzinc/battleships3$(OBJSUFFIX) test/flatzinc/battleships3$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -28845,7 +28845,7 @@ test/flatzinc/battleships4$(OBJSUFFIX) test/flatzinc/battleships4$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -28940,7 +28940,7 @@ test/flatzinc/battleships5$(OBJSUFFIX) test/flatzinc/battleships5$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -29035,7 +29035,7 @@ test/flatzinc/battleships7$(OBJSUFFIX) test/flatzinc/battleships7$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -29130,7 +29130,7 @@ test/flatzinc/battleships9$(OBJSUFFIX) test/flatzinc/battleships9$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -29225,7 +29225,7 @@ test/flatzinc/blocksworld_instance_1$(OBJSUFFIX) test/flatzinc/blocksworld_insta ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -29320,7 +29320,7 @@ test/flatzinc/blocksworld_instance_2$(OBJSUFFIX) test/flatzinc/blocksworld_insta ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -29415,7 +29415,7 @@ test/flatzinc/cumulatives$(OBJSUFFIX) test/flatzinc/cumulatives$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -29510,7 +29510,7 @@ test/flatzinc/cumulatives_full_1$(OBJSUFFIX) test/flatzinc/cumulatives_full_1$(S ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -29605,7 +29605,7 @@ test/flatzinc/cumulatives_full_2$(OBJSUFFIX) test/flatzinc/cumulatives_full_2$(S ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -29700,7 +29700,7 @@ test/flatzinc/cumulatives_full_3$(OBJSUFFIX) test/flatzinc/cumulatives_full_3$(S ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -29795,7 +29795,7 @@ test/flatzinc/cumulatives_full_4$(OBJSUFFIX) test/flatzinc/cumulatives_full_4$(S ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -29890,7 +29890,7 @@ test/flatzinc/cumulatives_full_5$(OBJSUFFIX) test/flatzinc/cumulatives_full_5$(S ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -29985,7 +29985,7 @@ test/flatzinc/cumulatives_full_6$(OBJSUFFIX) test/flatzinc/cumulatives_full_6$(S ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -30080,7 +30080,7 @@ test/flatzinc/cumulatives_full_7$(OBJSUFFIX) test/flatzinc/cumulatives_full_7$(S ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -30175,7 +30175,7 @@ test/flatzinc/cumulatives_full_8$(OBJSUFFIX) test/flatzinc/cumulatives_full_8$(S ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -30270,7 +30270,7 @@ test/flatzinc/cutstock$(OBJSUFFIX) test/flatzinc/cutstock$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -30365,7 +30365,7 @@ test/flatzinc/eq20$(OBJSUFFIX) test/flatzinc/eq20$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -30460,7 +30460,7 @@ test/flatzinc/factory_planning_instance$(OBJSUFFIX) test/flatzinc/factory_planni ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -30555,7 +30555,7 @@ test/flatzinc/golomb$(OBJSUFFIX) test/flatzinc/golomb$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -30650,7 +30650,7 @@ test/flatzinc/jobshop2x2$(OBJSUFFIX) test/flatzinc/jobshop2x2$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -30745,7 +30745,7 @@ test/flatzinc/knights$(OBJSUFFIX) test/flatzinc/knights$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -30840,7 +30840,7 @@ test/flatzinc/langford2$(OBJSUFFIX) test/flatzinc/langford2$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -30935,7 +30935,7 @@ test/flatzinc/latin_squares_fd$(OBJSUFFIX) test/flatzinc/latin_squares_fd$(SBJSU ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -31030,7 +31030,7 @@ test/flatzinc/multidim_knapsack_simple$(OBJSUFFIX) test/flatzinc/multidim_knapsa ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -31125,7 +31125,7 @@ test/flatzinc/packing$(OBJSUFFIX) test/flatzinc/packing$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -31220,7 +31220,7 @@ test/flatzinc/perfsq$(OBJSUFFIX) test/flatzinc/perfsq$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -31315,7 +31315,7 @@ test/flatzinc/perfsq2$(OBJSUFFIX) test/flatzinc/perfsq2$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -31410,7 +31410,7 @@ test/flatzinc/photo$(OBJSUFFIX) test/flatzinc/photo$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -31505,7 +31505,7 @@ test/flatzinc/product_fd$(OBJSUFFIX) test/flatzinc/product_fd$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -31600,7 +31600,7 @@ test/flatzinc/product_lp$(OBJSUFFIX) test/flatzinc/product_lp$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -31695,7 +31695,7 @@ test/flatzinc/quasigroup_qg5$(OBJSUFFIX) test/flatzinc/quasigroup_qg5$(SBJSUFFIX ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -31790,7 +31790,7 @@ test/flatzinc/queen_cp2$(OBJSUFFIX) test/flatzinc/queen_cp2$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -31885,7 +31885,7 @@ test/flatzinc/queen_ip$(OBJSUFFIX) test/flatzinc/queen_ip$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -31980,7 +31980,7 @@ test/flatzinc/radiation$(OBJSUFFIX) test/flatzinc/radiation$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -32075,7 +32075,7 @@ test/flatzinc/shared_array_element$(OBJSUFFIX) test/flatzinc/shared_array_elemen ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -32170,7 +32170,7 @@ test/flatzinc/simple_sat$(OBJSUFFIX) test/flatzinc/simple_sat$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -32265,7 +32265,7 @@ test/flatzinc/singHoist2$(OBJSUFFIX) test/flatzinc/singHoist2$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -32360,7 +32360,7 @@ test/flatzinc/sudoku$(OBJSUFFIX) test/flatzinc/sudoku$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -32455,7 +32455,7 @@ test/flatzinc/template_design$(OBJSUFFIX) test/flatzinc/template_design$(SBJSUFF ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -32550,7 +32550,7 @@ test/flatzinc/tenpenki_1$(OBJSUFFIX) test/flatzinc/tenpenki_1$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -32645,7 +32645,7 @@ test/flatzinc/tenpenki_2$(OBJSUFFIX) test/flatzinc/tenpenki_2$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -32740,7 +32740,7 @@ test/flatzinc/tenpenki_3$(OBJSUFFIX) test/flatzinc/tenpenki_3$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -32835,7 +32835,7 @@ test/flatzinc/tenpenki_4$(OBJSUFFIX) test/flatzinc/tenpenki_4$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -32930,7 +32930,7 @@ test/flatzinc/tenpenki_5$(OBJSUFFIX) test/flatzinc/tenpenki_5$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -33025,7 +33025,7 @@ test/flatzinc/tenpenki_6$(OBJSUFFIX) test/flatzinc/tenpenki_6$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -33120,7 +33120,7 @@ test/flatzinc/warehouses$(OBJSUFFIX) test/flatzinc/warehouses$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -33215,7 +33215,7 @@ test/flatzinc/warehouses_small$(OBJSUFFIX) test/flatzinc/warehouses_small$(SBJSU ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -33310,7 +33310,7 @@ test/flatzinc/wolf_goat_cabbage$(OBJSUFFIX) test/flatzinc/wolf_goat_cabbage$(SBJ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -33405,7 +33405,7 @@ test/flatzinc/zebra$(OBJSUFFIX) test/flatzinc/zebra$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -33500,7 +33500,7 @@ test/flatzinc/magicsq_3$(OBJSUFFIX) test/flatzinc/magicsq_3$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -33595,7 +33595,7 @@ test/flatzinc/magicsq_4$(OBJSUFFIX) test/flatzinc/magicsq_4$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -33690,7 +33690,7 @@ test/flatzinc/magicsq_5$(OBJSUFFIX) test/flatzinc/magicsq_5$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -33785,7 +33785,7 @@ test/flatzinc/oss$(OBJSUFFIX) test/flatzinc/oss$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -33880,7 +33880,7 @@ test/flatzinc/steiner_triples$(OBJSUFFIX) test/flatzinc/steiner_triples$(SBJSUFF ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -33975,7 +33975,7 @@ test/flatzinc/subtyping$(OBJSUFFIX) test/flatzinc/subtyping$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -34070,7 +34070,7 @@ test/flatzinc/timetabling$(OBJSUFFIX) test/flatzinc/timetabling$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -34165,7 +34165,7 @@ test/flatzinc/trucking$(OBJSUFFIX) test/flatzinc/trucking$(SBJSUFFIX): \ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -34260,7 +34260,7 @@ test/flatzinc/on_restart_complete$(OBJSUFFIX) test/flatzinc/on_restart_complete$ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -34355,7 +34355,7 @@ test/flatzinc/on_restart_last_val_bool$(OBJSUFFIX) test/flatzinc/on_restart_last ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -34450,7 +34450,7 @@ test/flatzinc/on_restart_last_val_float$(OBJSUFFIX) test/flatzinc/on_restart_las ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -34545,7 +34545,7 @@ test/flatzinc/on_restart_last_val_int$(OBJSUFFIX) test/flatzinc/on_restart_last_ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -34640,7 +34640,7 @@ test/flatzinc/on_restart_last_val_set$(OBJSUFFIX) test/flatzinc/on_restart_last_ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -34735,7 +34735,7 @@ test/flatzinc/on_restart_sol_bool$(OBJSUFFIX) test/flatzinc/on_restart_sol_bool$ ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -34830,7 +34830,7 @@ test/flatzinc/on_restart_sol_float$(OBJSUFFIX) test/flatzinc/on_restart_sol_floa ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -34925,7 +34925,7 @@ test/flatzinc/on_restart_sol_int$(OBJSUFFIX) test/flatzinc/on_restart_sol_int$(S ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -35020,7 +35020,7 @@ test/flatzinc/on_restart_sol_set$(OBJSUFFIX) test/flatzinc/on_restart_sol_set$(S ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp ./gecode/float/view.hpp \ ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp ./gecode/float/view/offset.hpp \ ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp ./gecode/float/view/scale.hpp \ - ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-sequence.hpp \ + ./gecode/gist.hh ./gecode/gist/gist.hpp ./gecode/int.hh ./gecode/int/open-var-list.hpp \ ./gecode/int/array-traits.hpp ./gecode/int/array.hpp ./gecode/int/branch.hpp \ ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp \ ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp ./gecode/int/branch/val.hpp \ @@ -35100,7 +35100,7 @@ test/flatzinc/on_restart_sol_set$(OBJSUFFIX) test/flatzinc/on_restart_sol_set$(S ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp ./test/flatzinc.hh ./test/test.hh \ ./test/test.hpp -gecode/int/open-sequence$(OBJSUFFIX) gecode/int/open-sequence$(SBJSUFFIX): \ +gecode/int/open-var-list$(OBJSUFFIX) gecode/int/open-var-list$(SBJSUFFIX): \ ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hh ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp \ ./gecode/int/branch/afc.hpp ./gecode/int/branch/assign.hpp ./gecode/int/branch/cbs.hpp \ @@ -35111,7 +35111,7 @@ gecode/int/open-sequence$(OBJSUFFIX) gecode/int/open-sequence$(SBJSUFFIX): \ ./gecode/int/exception.hpp ./gecode/int/extensional.hpp ./gecode/int/extensional/dfa.hpp \ ./gecode/int/extensional/tuple-set.hpp ./gecode/int/int-set-1.hpp ./gecode/int/int-set-2.hpp \ ./gecode/int/ipl.hpp ./gecode/int/irt.hpp ./gecode/int/limits.hpp \ - ./gecode/int/open-sequence.hpp ./gecode/int/propagator.hpp ./gecode/int/reify.hpp \ + ./gecode/int/open-var-list.hpp ./gecode/int/propagator.hpp ./gecode/int/reify.hpp \ ./gecode/int/trace.hpp ./gecode/int/trace/bool-delta.hpp ./gecode/int/trace/bool-trace-view.hpp \ ./gecode/int/trace/int-delta.hpp ./gecode/int/trace/int-trace-view.hpp ./gecode/int/trace/traits.hpp \ ./gecode/int/var-imp.hpp ./gecode/int/var-imp/bool.hpp ./gecode/int/var-imp/delta.hpp \ @@ -35176,7 +35176,7 @@ gecode/int/extensional-open-regular$(OBJSUFFIX) gecode/int/extensional-open-regu ./gecode/int/extensional/compact.hpp ./gecode/int/extensional/dfa.hpp ./gecode/int/extensional/layered-graph.hpp \ ./gecode/int/extensional/tiny-bit-set.hpp ./gecode/int/extensional/tuple-set.hpp ./gecode/int/int-set-1.hpp \ ./gecode/int/int-set-2.hpp ./gecode/int/ipl.hpp ./gecode/int/irt.hpp \ - ./gecode/int/limits.hpp ./gecode/int/open-sequence.hpp ./gecode/int/propagator.hpp \ + ./gecode/int/limits.hpp ./gecode/int/open-var-list.hpp ./gecode/int/propagator.hpp \ ./gecode/int/reify.hpp ./gecode/int/rel.hh ./gecode/int/rel/eq.hpp \ ./gecode/int/rel/lex.hpp ./gecode/int/rel/lq-le.hpp ./gecode/int/rel/nq.hpp \ ./gecode/int/trace.hpp ./gecode/int/trace/bool-delta.hpp ./gecode/int/trace/bool-trace-view.hpp \ @@ -35233,7 +35233,7 @@ gecode/int/extensional-open-regular$(OBJSUFFIX) gecode/int/extensional-open-regu ./gecode/support/random.hpp ./gecode/support/ref-count.hpp ./gecode/support/run-jobs.hpp \ ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp \ ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp -test/int/open-sequence$(OBJSUFFIX) test/int/open-sequence$(SBJSUFFIX): \ +test/int/open-var-list$(OBJSUFFIX) test/int/open-var-list$(SBJSUFFIX): \ ./gecode/float.hh ./gecode/float/array-traits.hpp ./gecode/float/array.hpp \ ./gecode/float/branch.hpp ./gecode/float/branch/action.hpp ./gecode/float/branch/afc.hpp \ ./gecode/float/branch/assign.hpp ./gecode/float/branch/chb.hpp ./gecode/float/branch/traits.hpp \ @@ -35253,7 +35253,7 @@ test/int/open-sequence$(OBJSUFFIX) test/int/open-sequence$(SBJSUFFIX): \ ./gecode/int/exception.hpp ./gecode/int/extensional.hpp ./gecode/int/extensional/dfa.hpp \ ./gecode/int/extensional/tuple-set.hpp ./gecode/int/int-set-1.hpp ./gecode/int/int-set-2.hpp \ ./gecode/int/ipl.hpp ./gecode/int/irt.hpp ./gecode/int/limits.hpp \ - ./gecode/int/open-sequence.hpp ./gecode/int/propagator.hpp ./gecode/int/reify.hpp \ + ./gecode/int/open-var-list.hpp ./gecode/int/propagator.hpp ./gecode/int/reify.hpp \ ./gecode/int/trace.hpp ./gecode/int/trace/bool-delta.hpp ./gecode/int/trace/bool-trace-view.hpp \ ./gecode/int/trace/int-delta.hpp ./gecode/int/trace/int-trace-view.hpp ./gecode/int/trace/traits.hpp \ ./gecode/int/var-imp.hpp ./gecode/int/var-imp/bool.hpp ./gecode/int/var-imp/delta.hpp \ diff --git a/Makefile.in b/Makefile.in index 746ed460f4..1ef33463fc 100755 --- a/Makefile.in +++ b/Makefile.in @@ -325,7 +325,7 @@ INTSRC0 = \ extensional/dfa.cpp extensional/tuple-set.cpp \ extensional-regular.cpp extensional-open-regular.cpp \ extensional-tuple-set.cpp \ - open-sequence.cpp \ + open-var-list.cpp \ dom.cpp rel.cpp precede.cpp element.cpp count.cpp \ arithmetic.cpp exec.cpp \ exec/when.cpp element/pair.cpp \ @@ -350,7 +350,7 @@ INTSRC0 = \ exception.cpp INTHDR0 = \ - open-sequence.hpp \ + open-var-list.hpp \ limits.hpp support-values.hh support-values.hpp \ idx-view.hh idx-view.hpp div.hh div.hpp \ exec.hh exec/when.hpp \ @@ -1122,7 +1122,7 @@ EXETARGETS = $(FLATZINCEXE) $(FLATZINCLAUNCHER) INTTESTSRC00 = \ channel arithmetic basic bool count dom distinct element extensional \ - rel linear gcc sorted unshare exec sequence open-sequence \ + rel linear gcc sorted unshare exec sequence open-var-list \ mm-arithmetic mm-bool mm-lin mm-count mm-rel \ bin-packing order unary cumulative cumulatives circuit \ no-overlap precede inter-distance nvalues member min-distance diff --git a/cmake/GecodeSources.cmake b/cmake/GecodeSources.cmake index 2b3df973ad..c3e7b24359 100644 --- a/cmake/GecodeSources.cmake +++ b/cmake/GecodeSources.cmake @@ -85,7 +85,7 @@ set(GECODE_INT_SOURCES gecode/int/extensional-regular.cpp gecode/int/extensional-open-regular.cpp gecode/int/extensional-tuple-set.cpp - gecode/int/open-sequence.cpp + gecode/int/open-var-list.cpp gecode/int/extensional/dfa.cpp gecode/int/extensional/tuple-set.cpp gecode/int/gcc.cpp @@ -430,7 +430,7 @@ set(GECODE_TEST_SOURCES test/int/no-overlap.cpp test/int/nvalues.cpp test/int/order.cpp - test/int/open-sequence.cpp + test/int/open-var-list.cpp test/int/precede.cpp test/int/rel.cpp test/int/sequence.cpp diff --git a/gecode/int.hh b/gecode/int.hh index d64652afee..89684d2e67 100755 --- a/gecode/int.hh +++ b/gecode/int.hh @@ -2425,23 +2425,29 @@ namespace Gecode { }; /** - * \brief Space-local sequence of variables with an open length + * \brief Space-local list of variables with an open length * - * Variables can be appended until the sequence is closed. The length - * variable denotes the eventual sequence length. Propagation materializes - * positions required by its minimum. + * Variables can be appended until the list is closed. The length + * variable denotes the eventual list length. Propagation materializes + * positions required by its minimum. The prefix_size() query counts the + * positions already constructed. Indexed access is limited to this prefix; + * get() creates positions and requires enough eventual length to include + * the requested position. * - * OpenIntVarSequence and OpenBoolVarSequence provide standard factories. - * Other variable types use a factory passed to OpenVarSequence, for + * Handles in one Space share the same list. Updating during cloning + * preserves that sharing in the clone with separate mutable state. + * + * OpenIntVarList and OpenBoolVarList provide standard factories. + * Other variable types use a factory passed to OpenVarList, for * example a function returning SetVar or FloatVar. Storage, cloning, and * materialization are shared; constraint and branching overloads remain * specific to the variable type. * - * A sequence can be used in an ordinary Space: + * A list can be used in an ordinary Space: * \code * class Model : public Space { * public: - * OpenIntVarSequence x; + * OpenIntVarList x; * Model(void) : x(*this,IntSet(0,1),3) { * rel(*this,x.length(),IRT_EQ,2); * distinct(*this,x); @@ -2459,10 +2465,10 @@ namespace Gecode { * \ingroup TaskModelInt */ template - class OpenVarSequence : public LocalHandle { + class OpenVarList : public LocalHandle { private: - /// Space-local sequence implementation - class Sequence; + /// Space-local list implementation + class Object; public: /** * \brief Function creating the variable at position \a i in \a home @@ -2479,20 +2485,20 @@ namespace Gecode { * deterministic and must not capture space-local data; \a home and * \a x refer to the current space. */ - typedef std::function x, int i)> + typedef std::function x, int i)> Transition; - /// Construct an uninitialized sequence - OpenVarSequence(void); - /// Construct a sequence using \a create for each position - OpenVarSequence(Space& home, Factory create, - int max=Int::Limits::max); - /// Construct a sequence using \a create and transition function \a t - OpenVarSequence(Space& home, Factory create, Transition t, - int max=Int::Limits::max); + /// Construct an uninitialized list + OpenVarList(void); + /// Construct a list using \a create for each position + OpenVarList(Space& home, Factory create, + int max=Int::Limits::max); + /// Construct a list using \a create and transition function \a t + OpenVarList(Space& home, Factory create, Transition t, + int max=Int::Limits::max); /// Update during cloning - void update(Space& home, OpenVarSequence& s); - /// Return the number of appended variables - int size(void) const; + void update(Space& home, OpenVarList& s); + /// Return the number of materialized positions + int prefix_size(void) const; /// Return variable at position \a i (\a i must be a valid position) Var operator [](int i) const; /// Return the eventual-length variable @@ -2500,8 +2506,11 @@ namespace Gecode { /** * \brief Append variable \a x * + * Constrains the eventual length to include the new position and calls + * the transition function, if supplied. + * * Throws an exception of type Int::ArgumentSame if \a x is an - * unassigned variable already in the sequence. + * unassigned variable already in the list. */ void append(Space& home, Var x); /** @@ -2513,17 +2522,21 @@ namespace Gecode { */ void materialize(Space& home, int n); /** - * \brief Return position \a i, materializing positions through \a i + * \brief Require and return the variable at position \a i + * + * Constrains the eventual length to be at least \a i+1 and materializes + * positions through \a i. * * Returns an uninitialized variable if \a home is failed or * materialization fails. */ Var get(Space& home, int i); /** - * \brief Close the sequence at its materialized length + * \brief Close the list at its materialized length * * First materializes any positions required by the minimum eventual * length, then assigns the eventual length to the number of positions. + * The contained variables can remain unassigned. */ void close(Space& home); /// Subscribe \a p to the addition of positions @@ -2536,10 +2549,10 @@ namespace Gecode { /** - * \brief Open sequence of integer variables + * \brief Open list of integer variables * \ingroup TaskModelInt */ - class OpenIntVarSequence : public OpenVarSequence { + class OpenIntVarList : public OpenVarList { public: /** * \brief Function returning the domain for position \a i @@ -2548,53 +2561,53 @@ namespace Gecode { * data. The function object is shared between clones. */ typedef std::function Domain; - using OpenVarSequence::OpenVarSequence; - /// Construct an uninitialized sequence - GECODE_INT_EXPORT OpenIntVarSequence(void); - /// Share an integer sequence constructed through a variable factory - OpenIntVarSequence(const OpenVarSequence& x); - /// Construct a sequence with maximal length \a max and full domains + using OpenVarList::OpenVarList; + /// Construct an uninitialized list + GECODE_INT_EXPORT OpenIntVarList(void); + /// Share an integer list constructed through a variable factory + OpenIntVarList(const OpenVarList& x); + /// Construct a list with maximal length \a max and full domains GECODE_INT_EXPORT - OpenIntVarSequence(Space& home, int max=Int::Limits::max); - /// Construct a sequence using domain \a d for every position + OpenIntVarList(Space& home, int max=Int::Limits::max); + /// Construct a list using domain \a d for every position GECODE_INT_EXPORT - OpenIntVarSequence(Space& home, const IntSet& d, - int max=Int::Limits::max); - /// Construct a sequence using domain \a d and transition function \a t + OpenIntVarList(Space& home, const IntSet& d, + int max=Int::Limits::max); + /// Construct a list using domain \a d and transition function \a t GECODE_INT_EXPORT - OpenIntVarSequence(Space& home, const IntSet& d, Transition t, - int max=Int::Limits::max); - /// Construct a sequence using \a d to create each position + OpenIntVarList(Space& home, const IntSet& d, Transition t, + int max=Int::Limits::max); + /// Construct a list using \a d to create each position GECODE_INT_EXPORT - OpenIntVarSequence(Space& home, Domain d, - int max=Int::Limits::max); - /// Construct a sequence using \a d and transition function \a t + OpenIntVarList(Space& home, Domain d, + int max=Int::Limits::max); + /// Construct a list using \a d and transition function \a t GECODE_INT_EXPORT - OpenIntVarSequence(Space& home, Domain d, Transition t, - int max=Int::Limits::max); + OpenIntVarList(Space& home, Domain d, Transition t, + int max=Int::Limits::max); private: /// Convert a position-dependent domain to a variable factory static Factory factory(Domain d); }; /** - * \brief Open sequence of Boolean variables + * \brief Open list of Boolean variables * \ingroup TaskModelInt */ - class OpenBoolVarSequence : public OpenVarSequence { + class OpenBoolVarList : public OpenVarList { public: - using OpenVarSequence::OpenVarSequence; - /// Construct an uninitialized sequence - GECODE_INT_EXPORT OpenBoolVarSequence(void); - /// Share a Boolean sequence constructed through a variable factory - OpenBoolVarSequence(const OpenVarSequence& x); - /// Construct a sequence with maximal length \a max and domains 0..1 + using OpenVarList::OpenVarList; + /// Construct an uninitialized list + GECODE_INT_EXPORT OpenBoolVarList(void); + /// Share a Boolean list constructed through a variable factory + OpenBoolVarList(const OpenVarList& x); + /// Construct a list with maximal length \a max and domains 0..1 GECODE_INT_EXPORT - OpenBoolVarSequence(Space& home, int max=Int::Limits::max); - /// Construct a sequence with domains 0..1 and transition function \a t + OpenBoolVarList(Space& home, int max=Int::Limits::max); + /// Construct a list with domains 0..1 and transition function \a t GECODE_INT_EXPORT - OpenBoolVarSequence(Space& home, Transition t, - int max=Int::Limits::max); + OpenBoolVarList(Space& home, Transition t, + int max=Int::Limits::max); }; } @@ -2610,7 +2623,7 @@ namespace Gecode { * \ingroup TaskModelIntDistinct */ GECODE_INT_EXPORT void - distinct(Home home, OpenIntVarSequence x, + distinct(Home home, OpenIntVarList x, IntPropLevel ipl=IPL_DEF); /** @@ -2621,7 +2634,7 @@ namespace Gecode { * \ingroup TaskModelIntRel */ GECODE_INT_EXPORT void - rel(Home home, OpenIntVarSequence x, IntRelType irt, + rel(Home home, OpenIntVarList x, IntRelType irt, IntPropLevel ipl=IPL_DEF); /** @@ -2633,7 +2646,7 @@ namespace Gecode { * \ingroup TaskModelIntSequence */ GECODE_INT_EXPORT void - sequence(Home home, OpenIntVarSequence x, const IntSet& s, + sequence(Home home, OpenIntVarList x, const IntSet& s, int q, int l, int u, IntPropLevel ipl=IPL_DEF); /** @@ -2645,7 +2658,7 @@ namespace Gecode { * \ingroup TaskModelIntSequence */ GECODE_INT_EXPORT void - slidingsum(Home home, OpenIntVarSequence x, + slidingsum(Home home, OpenIntVarList x, int q, int l, int u, IntPropLevel ipl=IPL_DEF); /** @@ -2656,7 +2669,7 @@ namespace Gecode { * \ingroup TaskModelIntArith */ GECODE_INT_EXPORT void - min(Home home, OpenIntVarSequence x, IntVar y, + min(Home home, OpenIntVarList x, IntVar y, IntPropLevel ipl=IPL_DEF); /** @@ -2667,7 +2680,7 @@ namespace Gecode { * \ingroup TaskModelIntArith */ GECODE_INT_EXPORT void - max(Home home, OpenIntVarSequence x, IntVar y, + max(Home home, OpenIntVarList x, IntVar y, IntPropLevel ipl=IPL_DEF); /** @@ -2678,7 +2691,7 @@ namespace Gecode { * \ingroup TaskModelIntPrecede */ GECODE_INT_EXPORT void - precede(Home home, OpenIntVarSequence x, int s, int t, + precede(Home home, OpenIntVarList x, int s, int t, IntPropLevel ipl=IPL_DEF); /** @@ -2689,12 +2702,12 @@ namespace Gecode { * \ingroup TaskModelIntPrecede */ GECODE_INT_EXPORT void - precede(Home home, OpenIntVarSequence x, const IntArgs& c, + precede(Home home, OpenIntVarList x, const IntArgs& c, IntPropLevel ipl=IPL_DEF); } -#include +#include #include @@ -3116,12 +3129,12 @@ namespace Gecode { * * While \a x is open, its materialized prefix must have a continuation * accepted by \a d. Once its length equals its materialized size, the - * complete sequence must be accepted by \a d. + * complete list must be accepted by \a d. * * \ingroup TaskModelIntExt */ GECODE_INT_EXPORT void - extensional(Home home, OpenIntVarSequence x, DFA d, + extensional(Home home, OpenIntVarList x, DFA d, IntPropLevel ipl=IPL_DEF); /** @@ -3129,7 +3142,7 @@ namespace Gecode { * \ingroup TaskModelIntExt */ GECODE_INT_EXPORT void - extensional(Home home, OpenBoolVarSequence x, DFA d, + extensional(Home home, OpenBoolVarList x, DFA d, IntPropLevel ipl=IPL_DEF); /** \brief Post propagator for \f$x\in t\f$. @@ -5164,11 +5177,11 @@ namespace Gecode { */ /** - * \brief Branching order for an open sequence + * \brief Branching order for an open list * \ingroup TaskModelIntBranch */ enum OpenVarBranch { - OVB_HORIZON_FIRST, ///< Select the horizon before sequence values + OVB_HORIZON_FIRST, ///< Select the horizon before list values OVB_VALUE_FIRST ///< Select materialized values before the horizon }; @@ -6111,59 +6124,59 @@ namespace Gecode { branch(Home home, IntVar x, IntValBranch vals, IntVarValPrint vvp=nullptr); /** - * \brief Branch over the eventual integer sequence \a x + * \brief Branch over the eventual integer list \a x * * The default selects the horizon first, then the first unassigned * variable and its minimum value. * \ingroup TaskModelIntBranch */ GECODE_INT_EXPORT void - branch(Home home, OpenIntVarSequence x, + branch(Home home, OpenIntVarList x, OpenVarBranch o=OVB_HORIZON_FIRST); /** - * \brief Branch over the eventual Boolean sequence \a x + * \brief Branch over the eventual Boolean list \a x * \ingroup TaskModelIntBranch */ GECODE_INT_EXPORT void - branch(Home home, OpenBoolVarSequence x, + branch(Home home, OpenBoolVarList x, OpenVarBranch o=OVB_HORIZON_FIRST); /** - * \brief Branch over an open integer sequence with standard selectors + * \brief Branch over an open integer list with standard selectors * * Selectors consider all materialized positions. \a OVB_HORIZON_FIRST * decides the length before values; \a OVB_VALUE_FIRST selects values - * before closing or extending the sequence. Filters and callbacks receive - * the position in the sequence. + * before closing or extending the list. Filters and callbacks receive + * the position in the list. * - * Action and CHB selection require the complete sequence to be materialized + * Action and CHB selection require the complete list to be materialized * when posting; otherwise Int::UnknownBranching is thrown. * \ingroup TaskModelIntBranch */ GECODE_INT_EXPORT void - branch(Home home, OpenIntVarSequence x, + branch(Home home, OpenIntVarList x, IntVarBranch vars, IntValBranch vals, OpenVarBranch o=OVB_HORIZON_FIRST, IntBranchFilter bf=nullptr, IntVarValPrint vvp=nullptr); - /// Branch over an open integer sequence with tie-breaking selectors + /// Branch over an open integer list with tie-breaking selectors GECODE_INT_EXPORT void - branch(Home home, OpenIntVarSequence x, + branch(Home home, OpenIntVarList x, TieBreak vars, IntValBranch vals, OpenVarBranch o=OVB_HORIZON_FIRST, IntBranchFilter bf=nullptr, IntVarValPrint vvp=nullptr); /** - * \brief Branch over an open Boolean sequence with standard selectors + * \brief Branch over an open Boolean list with standard selectors * * The order, filter, and Action/CHB restrictions are as for integers. * \ingroup TaskModelIntBranch */ GECODE_INT_EXPORT void - branch(Home home, OpenBoolVarSequence x, + branch(Home home, OpenBoolVarList x, BoolVarBranch vars, BoolValBranch vals, OpenVarBranch o=OVB_HORIZON_FIRST, BoolBranchFilter bf=nullptr, BoolVarValPrint vvp=nullptr); - /// Branch over an open Boolean sequence with tie-breaking selectors + /// Branch over an open Boolean list with tie-breaking selectors GECODE_INT_EXPORT void - branch(Home home, OpenBoolVarSequence x, + branch(Home home, OpenBoolVarList x, TieBreak vars, BoolValBranch vals, OpenVarBranch o=OVB_HORIZON_FIRST, BoolBranchFilter bf=nullptr, BoolVarValPrint vvp=nullptr); diff --git a/gecode/int/extensional-open-regular.cpp b/gecode/int/extensional-open-regular.cpp index 79d99b9807..d3349b9792 100644 --- a/gecode/int/extensional-open-regular.cpp +++ b/gecode/int/extensional-open-regular.cpp @@ -40,7 +40,7 @@ namespace Gecode { namespace Int { namespace Extensional { template class OpenRegular : public Propagator { protected: - OpenVarSequence sequence; + OpenVarList list; IntView length; DFA dfa; unsigned char* start; @@ -48,28 +48,28 @@ namespace Gecode { namespace Int { namespace Extensional { int subscribed; OpenRegular(Home home, - OpenVarSequence sequence0, DFA dfa0) - : Propagator(home), sequence(sequence0), - length(sequence0.length()), + OpenVarList list0, DFA dfa0) + : Propagator(home), list(list0), + length(list0.length()), dfa(dfa0), start(static_cast(home).alloc(dfa.n_states())), - offset(0), subscribed(sequence0.size()) { + offset(0), subscribed(list0.prefix_size()) { home.notice(*this,AP_DISPOSE); for (int i=0; i(p.dfa.n_states())), offset(p.offset), subscribed(p.subscribed) { - sequence.update(home,p.sequence); + list.update(home,p.list); length.update(home,p.length); for (int i=0; i(n+1) * @@ -136,7 +136,7 @@ namespace Gecode { namespace Int { namespace Extensional { for (int i=n; i--; ) { unsigned char* in = backward + static_cast(i)*k; unsigned char* out = in+k; - View x(sequence[offset+i]); + View x(list[offset+i]); for (ViewValues v(x); v(); ++v) for (DFA::Transitions t(dfa,v.val()); t(); ++t) if (out[t.o_state()] != 0) @@ -159,19 +159,19 @@ namespace Gecode { namespace Int { namespace Extensional { virtual void reschedule(Space& home) { length.reschedule(home,*this,PC_INT_VAL); - sequence.reschedule(home,*this); + list.reschedule(home,*this); for (int i=offset; i(dfa.n_symbols()); int n_supported = 0; @@ -233,13 +233,13 @@ namespace Gecode { namespace Int { namespace Extensional { } int consumed = 0; - while ((consumed < n) && sequence[offset+consumed].assigned()) { + while ((consumed < n) && list[offset+consumed].assigned()) { const unsigned char* live = backward + static_cast(consumed+1)*k; unsigned char* next = r.alloc(k); for (int s=0; s sequence, DFA dfa) { - for (int i=0; i list, DFA dfa) { + for (int i=0; i - ::post(home,sequence,dfa))); + ::post(home,list,dfa))); } void - extensional(Home home, OpenBoolVarSequence sequence, DFA dfa, + extensional(Home home, OpenBoolVarList list, DFA dfa, IntPropLevel) { GECODE_POST; GECODE_ES_FAIL((Int::Extensional::OpenRegular - ::post(home,sequence,dfa))); + ::post(home,list,dfa))); } } diff --git a/gecode/int/open-sequence.cpp b/gecode/int/open-var-list.cpp similarity index 66% rename from gecode/int/open-sequence.cpp rename to gecode/int/open-var-list.cpp index db93b78a1f..8167a26b51 100644 --- a/gecode/int/open-sequence.cpp +++ b/gecode/int/open-var-list.cpp @@ -35,108 +35,108 @@ namespace Gecode { - OpenIntVarSequence::OpenIntVarSequence(void) {} + OpenIntVarList::OpenIntVarList(void) {} - OpenIntVarSequence::Factory - OpenIntVarSequence::factory(Domain d) { + OpenIntVarList::Factory + OpenIntVarList::factory(Domain d) { if (!d) - throw InvalidFunction("OpenIntVarSequence"); + throw InvalidFunction("OpenIntVarList"); return [d](Space& home, int i) { return IntVar(home,d(i)); }; } - OpenIntVarSequence::OpenIntVarSequence(Space& home, int max) - : OpenIntVarSequence(home, + OpenIntVarList::OpenIntVarList(Space& home, int max) + : OpenIntVarList(home, IntSet(Int::Limits::min,Int::Limits::max),max) {} - OpenIntVarSequence::OpenIntVarSequence(Space& home, const IntSet& d, - int max) - : OpenIntVarSequence(home,[d](int) { return d; },max) {} + OpenIntVarList::OpenIntVarList(Space& home, const IntSet& d, + int max) + : OpenIntVarList(home,[d](int) { return d; },max) {} - OpenIntVarSequence::OpenIntVarSequence(Space& home, const IntSet& d, - Transition t, int max) - : OpenIntVarSequence(home,[d](int) { return d; },t,max) {} + OpenIntVarList::OpenIntVarList(Space& home, const IntSet& d, + Transition t, int max) + : OpenIntVarList(home,[d](int) { return d; },t,max) {} - OpenIntVarSequence::OpenIntVarSequence(Space& home, Domain d, int max) - : OpenVarSequence(home,factory(d),max) {} + OpenIntVarList::OpenIntVarList(Space& home, Domain d, int max) + : OpenVarList(home,factory(d),max) {} - OpenIntVarSequence::OpenIntVarSequence(Space& home, Domain d, - Transition t, int max) - : OpenVarSequence(home,factory(d),t,max) {} + OpenIntVarList::OpenIntVarList(Space& home, Domain d, + Transition t, int max) + : OpenVarList(home,factory(d),t,max) {} - OpenBoolVarSequence::OpenBoolVarSequence(void) {} + OpenBoolVarList::OpenBoolVarList(void) {} - OpenBoolVarSequence::OpenBoolVarSequence(Space& home, int max) - : OpenVarSequence(home, + OpenBoolVarList::OpenBoolVarList(Space& home, int max) + : OpenVarList(home, [](Space& home, int) { return BoolVar(home,0,1); },max) {} - OpenBoolVarSequence::OpenBoolVarSequence(Space& home, Transition t, - int max) - : OpenVarSequence(home, + OpenBoolVarList::OpenBoolVarList(Space& home, Transition t, + int max) + : OpenVarList(home, [](Space& home, int) { return BoolVar(home,0,1); },t,max) {} } namespace Gecode { namespace Int { - class OpenSequencePropagator : public Propagator { + class OpenListPropagator : public Propagator { protected: - OpenIntVarSequence sequence; + OpenIntVarList list; IntView length; int posted; - OpenSequencePropagator(Home home, OpenIntVarSequence sequence0) - : Propagator(home), sequence(sequence0), - length(sequence0.length()), + OpenListPropagator(Home home, OpenIntVarList list0) + : Propagator(home), list(list0), + length(list0.length()), posted(0) { length.subscribe(home,*this,PC_INT_BND); - sequence.subscribe(home,*this); + list.subscribe(home,*this); } - OpenSequencePropagator(Space& home, OpenSequencePropagator& p) + OpenListPropagator(Space& home, OpenListPropagator& p) : Propagator(home,p), posted(p.posted) { - sequence.update(home,p.sequence); + list.update(home,p.list); length.update(home,p.length); } bool closed(void) const { - return length.max() == sequence.size(); + return length.max() == list.prefix_size(); } void dispose_base(Space& home) { length.cancel(home,*this,PC_INT_BND); - sequence.cancel(home,*this); - sequence.~OpenIntVarSequence(); + list.cancel(home,*this); + list.~OpenIntVarList(); (void) Propagator::dispose(home); } public: virtual PropCost cost(const Space&, const ModEventDelta&) const { - return PropCost::linear(PropCost::LO,sequence.size()-posted); + return PropCost::linear(PropCost::LO,list.prefix_size()-posted); } virtual void reschedule(Space& home) { length.reschedule(home,*this,PC_INT_BND); - sequence.reschedule(home,*this); + list.reschedule(home,*this); } }; - class OpenDistinct : public OpenSequencePropagator { + class OpenDistinct : public OpenListPropagator { protected: - OpenDistinct(Home home, OpenIntVarSequence sequence) - : OpenSequencePropagator(home,sequence) {} + OpenDistinct(Home home, OpenIntVarList list) + : OpenListPropagator(home,list) {} OpenDistinct(Space& home, OpenDistinct& p) - : OpenSequencePropagator(home,p) {} + : OpenListPropagator(home,p) {} public: virtual PropCost cost(const Space&, const ModEventDelta&) const { - return PropCost::linear(PropCost::LO,sequence.size()); + return PropCost::linear(PropCost::LO,list.prefix_size()); } virtual Actor* @@ -146,10 +146,10 @@ namespace Gecode { namespace Int { virtual ExecStatus propagate(Space& home, const ModEventDelta&) { - const int size = sequence.size(); + const int size = list.prefix_size(); for (int i=posted; i(size); int n = 0; for (int i=0; i 1) { std::sort(values,values+n); for (int i=1; i - class OpenMinMax : public OpenSequencePropagator { + class OpenMinMax : public OpenListPropagator { protected: IntView result; IntPropLevel ipl; - OpenMinMax(Home home, OpenIntVarSequence sequence, + OpenMinMax(Home home, OpenIntVarList list, IntView result0, IntPropLevel ipl0) - : OpenSequencePropagator(home,sequence), + : OpenListPropagator(home,list), result(result0), ipl(ipl0) {} OpenMinMax(Space& home, OpenMinMax& p) - : OpenSequencePropagator(home,p), ipl(p.ipl) { + : OpenListPropagator(home,p), ipl(p.ipl) { result.update(home,p.result); } @@ -389,13 +389,13 @@ namespace Gecode { namespace Int { virtual ExecStatus propagate(Space& home, const ModEventDelta&) { - const int size = sequence.size(); + const int size = list.prefix_size(); for (int i=posted; i 0) seen.update(home,p.seen); @@ -458,17 +458,17 @@ namespace Gecode { namespace Int { propagate(Space& home, const ModEventDelta&) { if ((posted > 0) && seen.one()) return home.ES_SUBSUMED(*this); - const int size = sequence.size(); + const int size = list.prefix_size(); for (int i=posted; i - class OpenSequenceBrancher : public Brancher { + class OpenListBrancher : public Brancher { protected: typedef typename View::VarType Var; - OpenVarSequence sequence; + OpenVarList list; ViewSel* vs[n]; ValSelCommitBase* vsc; BrancherFilter filter; @@ -509,12 +509,12 @@ namespace Gecode { namespace Int { IntValBranch::Select values; mutable int start; - OpenSequenceBrancher(Home home, OpenVarSequence sequence0, - ViewSel* vs0[n], - ValSelCommitBase* vsc0, - OpenVarBranch order0, IntValBranch::Select values0, - BranchFilter bf, VarValPrint vvp) - : Brancher(home), sequence(sequence0), vsc(vsc0), + OpenListBrancher(Home home, OpenVarList list0, + ViewSel* vs0[n], + ValSelCommitBase* vsc0, + OpenVarBranch order0, IntValBranch::Select values0, + BranchFilter bf, VarValPrint vvp) + : Brancher(home), list(list0), vsc(vsc0), filter(bf ? bf : [](const Space&, Var, int) { return true; }), printer(vvp), order(order0), values(values0), start(0) { for (int i=0; i x(r,sequence.size()); + ViewArray x(r,list.prefix_size()); for (int i=0; iselect(home,x,start,filter); int* ties = r.alloc(x.size()-start); @@ -582,30 +582,30 @@ namespace Gecode { namespace Int { virtual bool status(const Space& home) const { if ((order == OVB_HORIZON_FIRST) && - (sequence.length().max() > sequence.size())) + (list.length().max() > list.prefix_size())) return true; - for (int i=start; i sequence.size(); + return list.length().max() > list.prefix_size(); } virtual const Choice* choice(Space& home) { if ((order == OVB_HORIZON_FIRST) && - (sequence.length().max() > sequence.size())) - return new PosValChoice(*this,2,Pos(-1),sequence.size()); - for (int i=start; i list.prefix_size())) + return new PosValChoice(*this,2,Pos(-1),list.prefix_size()); + for (int i=start; i(*this,2,Pos(p),vsc->val(home,x,p)) : value_choice(*this,p,x); } - return new PosValChoice(*this,2,Pos(-1),sequence.size()); + return new PosValChoice(*this,2,Pos(-1),list.prefix_size()); } virtual const Choice* @@ -626,7 +626,7 @@ namespace Gecode { namespace Int { commit(Space& home, const Choice& c, unsigned int a) { const int p = static_cast(c).pos().pos; if (p >= 0) { - View x(sequence[p]); + View x(list[p]); const ModEvent me = vsc ? vsc->commit(home,a,x,p,static_cast&>(c).val()) : x.eq(home,value(c,a)); @@ -634,9 +634,9 @@ namespace Gecode { namespace Int { } const int size = static_cast&>(c).val(); if (a == 0) - return me_failed(IntView(sequence.length()).eq(home,size)) + return me_failed(IntView(list.length()).eq(home,size)) ? ES_FAILED : ES_OK; - sequence.materialize(home,size+1); + list.materialize(home,size+1); return home.failed() ? ES_FAILED : ES_OK; } @@ -645,12 +645,12 @@ namespace Gecode { namespace Int { const int p = static_cast(c).pos().pos; if (p < 0) return (a == 0) ? new (home) Branch::EqNGL - (home,IntView(sequence.length()), + (home,IntView(list.length()), static_cast&>(c).val()) : nullptr; // No-good extraction can run in an ancestor with a shorter prefix. - if (p >= sequence.size()) + if (p >= list.prefix_size()) return nullptr; - View x(sequence[p]); + View x(list[p]); return vsc ? vsc->ngl(home,a,x,static_cast&>(c).val()) : new (home) Branch::EqNGL(home,x,value(c,a)); @@ -661,24 +661,24 @@ namespace Gecode { namespace Int { std::ostream& o) const { const int p = static_cast(c).pos().pos; if (p < 0) { - o << "sequence length " << ((a == 0) ? "=" : ">") << " " + o << "list length " << ((a == 0) ? "=" : ">") << " " << static_cast&>(c).val(); } else { - View x(sequence[p]); + View x(list[p]); const int v = vsc ? static_cast&>(c).val() : value(c,a); if (printer()) - printer()(home,*this,a,sequence[p],p,v,o); + printer()(home,*this,a,list[p],p,v,o); else if (vsc) vsc->print(home,a,x,p,v,o); else - o << "sequence[" << p << "] = " << v; + o << "list[" << p << "] = " << v; } } virtual Actor* copy(Space& home) { - return new (home) OpenSequenceBrancher(home,*this); + return new (home) OpenListBrancher(home,*this); } virtual size_t @@ -690,14 +690,14 @@ namespace Gecode { namespace Int { vsc->dispose(home); filter.dispose(home); printer.~SharedData>(); - sequence.~OpenVarSequence(); + list.~OpenVarList(); (void) Brancher::dispose(home); return sizeof(*this); } template static void - post(Home home, OpenVarSequence sequence, VarBranch vars[n], + post(Home home, OpenVarList list, VarBranch vars[n], ValSelCommitBase* vsc, OpenVarBranch order, IntValBranch::Select values, BranchFilter bf, VarValPrint vvp) { @@ -705,7 +705,7 @@ namespace Gecode { namespace Int { for (int i=0; i void - post_open_brancher(Home home, OpenVarSequence sequence, + post_open_brancher(Home home, OpenVarList list, TieBreak vars, ValBranch vals, OpenVarBranch order, BranchFilter bf, @@ -764,11 +764,11 @@ namespace Gecode { namespace Int { (selectors[n].select() != VarBranch::SEL_NONE)) n++; typedef typename View::VarType Var; - typename ArrayTraits>::ArgsType x(sequence.size()); + typename ArrayTraits>::ArgsType x(list.prefix_size()); for (int i=0; i sequence.size()); + check_open_selector(selectors[i],list.length().max() > list.prefix_size()); selectors[i].expand(home,x); } const IntValBranch::Select values = @@ -776,20 +776,20 @@ namespace Gecode { namespace Int { ValSelCommitBase* vsc = open_valselcommit(home,vals); switch (n) { case 1: - OpenSequenceBrancher::post - (home,sequence,selectors,vsc,order,values,bf,vvp); + OpenListBrancher::post + (home,list,selectors,vsc,order,values,bf,vvp); break; case 2: - OpenSequenceBrancher::post - (home,sequence,selectors,vsc,order,values,bf,vvp); + OpenListBrancher::post + (home,list,selectors,vsc,order,values,bf,vvp); break; case 3: - OpenSequenceBrancher::post - (home,sequence,selectors,vsc,order,values,bf,vvp); + OpenListBrancher::post + (home,list,selectors,vsc,order,values,bf,vvp); break; case 4: - OpenSequenceBrancher::post - (home,sequence,selectors,vsc,order,values,bf,vvp); + OpenListBrancher::post + (home,list,selectors,vsc,order,values,bf,vvp); break; } } @@ -799,13 +799,13 @@ namespace Gecode { namespace Int { namespace Gecode { void - distinct(Home home, OpenIntVarSequence sequence, IntPropLevel) { + distinct(Home home, OpenIntVarList list, IntPropLevel) { GECODE_POST; - Int::OpenDistinct::post(home,sequence); + Int::OpenDistinct::post(home,list); } void - rel(Home home, OpenIntVarSequence sequence, + rel(Home home, OpenIntVarList list, IntRelType irt, IntPropLevel ipl) { switch (irt) { case IRT_EQ: @@ -819,19 +819,19 @@ namespace Gecode { throw Int::UnknownRelation("Int::rel"); } GECODE_POST; - Int::OpenRel::post(home,sequence,irt,ipl); + Int::OpenRel::post(home,list,irt,ipl); } void - sequence(Home home, OpenIntVarSequence x, const IntSet& values, + sequence(Home home, OpenIntVarList x, const IntSet& values, int width, int lower, int upper, IntPropLevel ipl) { - Int::Limits::check(values.min(),"Int::sequence"); - Int::Limits::check(values.max(),"Int::sequence"); - Int::Limits::check(width,"Int::sequence"); - Int::Limits::check(lower,"Int::sequence"); - Int::Limits::check(upper,"Int::sequence"); + Int::Limits::check(values.min(),"Int::list"); + Int::Limits::check(values.max(),"Int::list"); + Int::Limits::check(width,"Int::list"); + Int::Limits::check(lower,"Int::list"); + Int::Limits::check(upper,"Int::list"); if (width < 1) - throw Int::OutOfLimits("Int::sequence"); + throw Int::OutOfLimits("Int::list"); GECODE_POST; lower = std::max(0,lower); upper = std::min(width,upper); @@ -845,7 +845,7 @@ namespace Gecode { } void - slidingsum(Home home, OpenIntVarSequence sequence, + slidingsum(Home home, OpenIntVarList list, int width, int lower, int upper, IntPropLevel ipl) { Int::Limits::check(width,"Int::slidingsum"); Int::Limits::check(lower,"Int::slidingsum"); @@ -854,37 +854,37 @@ namespace Gecode { throw Int::OutOfLimits("Int::slidingsum"); GECODE_POST; if (upper < lower) { - rel(home,sequence.length(),IRT_LE,width); + rel(home,list.length(),IRT_LE,width); return; } - Int::OpenSlidingSum::post(home,sequence,width,lower,upper,ipl); + Int::OpenSlidingSum::post(home,list,width,lower,upper,ipl); } void - min(Home home, OpenIntVarSequence sequence, + min(Home home, OpenIntVarList list, IntVar result, IntPropLevel ipl) { GECODE_POST; - Int::OpenMinMax::post(home,sequence,Int::IntView(result),ipl); + Int::OpenMinMax::post(home,list,Int::IntView(result),ipl); } void - max(Home home, OpenIntVarSequence sequence, + max(Home home, OpenIntVarList list, IntVar result, IntPropLevel ipl) { GECODE_POST; - Int::OpenMinMax::post(home,sequence,Int::IntView(result),ipl); + Int::OpenMinMax::post(home,list,Int::IntView(result),ipl); } void - precede(Home home, OpenIntVarSequence sequence, + precede(Home home, OpenIntVarList list, int before, int after, IntPropLevel) { Int::Limits::check(before,"Int::precede"); Int::Limits::check(after,"Int::precede"); GECODE_POST; - Int::OpenPrecede::post(home,sequence,before,after); + Int::OpenPrecede::post(home,list,before,after); } void - precede(Home home, OpenIntVarSequence sequence, + precede(Home home, OpenIntVarList list, const IntArgs& values, IntPropLevel ipl) { if (values.size() < 2) return; @@ -892,48 +892,48 @@ namespace Gecode { Int::Limits::check(values[i],"Int::precede"); GECODE_POST; for (int i=values.size()-1; i--; ) - Int::OpenPrecede::post(home,sequence,values[i],values[i+1]); + Int::OpenPrecede::post(home,list,values[i],values[i+1]); (void) ipl; } void - branch(Home home, OpenIntVarSequence sequence, OpenVarBranch order) { - branch(home,sequence,INT_VAR_NONE(),INT_VAL_MIN(),order); + branch(Home home, OpenIntVarList list, OpenVarBranch order) { + branch(home,list,INT_VAR_NONE(),INT_VAL_MIN(),order); } void - branch(Home home, OpenBoolVarSequence sequence, OpenVarBranch order) { - branch(home,sequence,BOOL_VAR_NONE(),BOOL_VAL_MIN(),order); + branch(Home home, OpenBoolVarList list, OpenVarBranch order) { + branch(home,list,BOOL_VAR_NONE(),BOOL_VAL_MIN(),order); } void - branch(Home home, OpenIntVarSequence sequence, + branch(Home home, OpenIntVarList list, IntVarBranch vars, IntValBranch vals, OpenVarBranch order, IntBranchFilter bf, IntVarValPrint vvp) { - branch(home,sequence,TieBreak(vars),vals,order,bf,vvp); + branch(home,list,TieBreak(vars),vals,order,bf,vvp); } void - branch(Home home, OpenIntVarSequence sequence, + branch(Home home, OpenIntVarList list, TieBreak vars, IntValBranch vals, OpenVarBranch order, IntBranchFilter bf, IntVarValPrint vvp) { GECODE_POST; - Int::post_open_brancher(home,sequence,vars,vals,order,bf,vvp); + Int::post_open_brancher(home,list,vars,vals,order,bf,vvp); } void - branch(Home home, OpenBoolVarSequence sequence, + branch(Home home, OpenBoolVarList list, BoolVarBranch vars, BoolValBranch vals, OpenVarBranch order, BoolBranchFilter bf, BoolVarValPrint vvp) { - branch(home,sequence,TieBreak(vars),vals,order,bf,vvp); + branch(home,list,TieBreak(vars),vals,order,bf,vvp); } void - branch(Home home, OpenBoolVarSequence sequence, + branch(Home home, OpenBoolVarList list, TieBreak vars, BoolValBranch vals, OpenVarBranch order, BoolBranchFilter bf, BoolVarValPrint vvp) { GECODE_POST; - Int::post_open_brancher(home,sequence,vars,vals,order,bf,vvp); + Int::post_open_brancher(home,list,vars,vals,order,bf,vvp); } } diff --git a/gecode/int/open-sequence.hpp b/gecode/int/open-var-list.hpp similarity index 70% rename from gecode/int/open-sequence.hpp rename to gecode/int/open-var-list.hpp index 319443d084..f46c56c8c2 100644 --- a/gecode/int/open-sequence.hpp +++ b/gecode/int/open-var-list.hpp @@ -34,7 +34,7 @@ namespace Gecode { template - class OpenVarSequence::Sequence : public LocalObject { + class OpenVarList::Object : public LocalObject { public: class Functions { public: @@ -54,27 +54,27 @@ namespace Gecode { static int maximum(int max) { - Int::Limits::check(max,"OpenVarSequence"); + Int::Limits::check(max,"OpenVarList"); if (max < 0) - throw Int::VariableEmptyDomain("OpenVarSequence"); + throw Int::VariableEmptyDomain("OpenVarList"); return max; } static Factory valid(Factory create) { if (!create) - throw InvalidFunction("OpenVarSequence"); + throw InvalidFunction("OpenVarList"); return create; } static Transition valid(Transition t) { if (!t) - throw InvalidFunction("OpenVarSequence"); + throw InvalidFunction("OpenVarList"); return t; } - Sequence(Home home, Factory create, int max) + Object(Home home, Factory create, int max) : LocalObject(home), length(home,0,maximum(max)), materialized(home,0,max), @@ -83,7 +83,7 @@ namespace Gecode { home.notice(*this,AP_DISPOSE); } - Sequence(Home home, Factory create, Transition t, int max) + Object(Home home, Factory create, Transition t, int max) : LocalObject(home), length(home,0,maximum(max)), materialized(home,0,max), @@ -92,7 +92,7 @@ namespace Gecode { home.notice(*this,AP_DISPOSE); } - Sequence(Space& home, Sequence& s) + Object(Space& home, Object& s) : LocalObject(home,s), x(nullptr), n(s.n), capacity(s.n), functions(s.functions) { length.update(home,s.length); @@ -111,7 +111,7 @@ namespace Gecode { virtual Actor* copy(Space& home) { - return new (home) Sequence(home,*this); + return new (home) Object(home,*this); } virtual size_t @@ -147,17 +147,17 @@ namespace Gecode { namespace Int { template class OpenMaterialize : public Propagator { protected: - OpenVarSequence sequence; + OpenVarList list; IntView length; - OpenMaterialize(Home home, OpenVarSequence sequence0) - : Propagator(home), sequence(sequence0), length(sequence0.length()) { + OpenMaterialize(Home home, OpenVarList list0) + : Propagator(home), list(list0), length(list0.length()) { length.subscribe(home,*this,PC_INT_BND); } OpenMaterialize(Space& home, OpenMaterialize& p) : Propagator(home,p) { - sequence.update(home,p.sequence); + list.update(home,p.list); length.update(home,p.length); } @@ -169,7 +169,7 @@ namespace Gecode { namespace Int { virtual PropCost cost(const Space&, const ModEventDelta&) const { - const int n = length.min()-sequence.size(); + const int n = length.min()-list.prefix_size(); return (n <= 1) ? PropCost::unary(PropCost::LO) : PropCost::linear(PropCost::LO,n); } @@ -181,7 +181,7 @@ namespace Gecode { namespace Int { virtual ExecStatus propagate(Space& home, const ModEventDelta&) { - sequence.materialize(home,length.min()); + list.materialize(home,length.min()); if (home.failed()) return ES_FAILED; if (length.assigned()) @@ -192,15 +192,15 @@ namespace Gecode { namespace Int { virtual size_t dispose(Space& home) { length.cancel(home,*this,PC_INT_BND); - sequence.~OpenVarSequence(); + list.~OpenVarList(); (void) Propagator::dispose(home); return sizeof(*this); } static void - post(Home home, OpenVarSequence sequence) { - if (!sequence.length().assigned()) - (void) new (home) OpenMaterialize(home,sequence); + post(Home home, OpenVarList list) { + if (!list.length().assigned()) + (void) new (home) OpenMaterialize(home,list); } }; @@ -209,61 +209,61 @@ namespace Gecode { namespace Int { namespace Gecode { template - OpenVarSequence::OpenVarSequence(void) {} + OpenVarList::OpenVarList(void) {} template - OpenVarSequence::OpenVarSequence(Space& home, Factory create, int max) - : LocalHandle(new (home) Sequence(home,create,max)) { + OpenVarList::OpenVarList(Space& home, Factory create, int max) + : LocalHandle(new (home) Object(home,create,max)) { Int::OpenMaterialize::post(home,*this); } template - OpenVarSequence::OpenVarSequence(Space& home, Factory create, - Transition t, int max) - : LocalHandle(new (home) Sequence(home,create,t,max)) { + OpenVarList::OpenVarList(Space& home, Factory create, + Transition t, int max) + : LocalHandle(new (home) Object(home,create,t,max)) { Int::OpenMaterialize::post(home,*this); } forceinline - OpenIntVarSequence::OpenIntVarSequence(const OpenVarSequence& x) - : OpenVarSequence(x) {} + OpenIntVarList::OpenIntVarList(const OpenVarList& x) + : OpenVarList(x) {} forceinline - OpenBoolVarSequence::OpenBoolVarSequence(const OpenVarSequence& x) - : OpenVarSequence(x) {} + OpenBoolVarList::OpenBoolVarList(const OpenVarList& x) + : OpenVarList(x) {} template void - OpenVarSequence::update(Space& home, OpenVarSequence& s) { + OpenVarList::update(Space& home, OpenVarList& s) { LocalHandle::update(home,s); } template int - OpenVarSequence::size(void) const { - return static_cast(object())->n; + OpenVarList::prefix_size(void) const { + return static_cast(object())->n; } template Var - OpenVarSequence::operator [](int i) const { - Sequence* s = static_cast(object()); + OpenVarList::operator [](int i) const { + Object* s = static_cast(object()); assert((i >= 0) && (i < s->n)); return s->x[i]; } template IntVar - OpenVarSequence::length(void) const { - return static_cast(object())->length; + OpenVarList::length(void) const { + return static_cast(object())->length; } template void - OpenVarSequence::append(Space& home, Var y) { + OpenVarList::append(Space& home, Var y) { if (home.failed()) return; - Sequence* s = static_cast(object()); + Object* s = static_cast(object()); if (s->n == Int::Limits::max) { home.fail(); return; @@ -271,7 +271,7 @@ namespace Gecode { for (int i=0; in; i++) if (!y.assigned() && !s->x[i].assigned() && (y.varimp() == s->x[i].varimp())) - throw Int::ArgumentSame("OpenVarSequence::append"); + throw Int::ArgumentSame("OpenVarList::append"); s->reserve(); const int next = s->n + 1; Int::IntView l(s->length); @@ -290,11 +290,11 @@ namespace Gecode { template void - OpenVarSequence::materialize(Space& home, int n) { + OpenVarList::materialize(Space& home, int n) { if (home.failed()) return; - Int::Limits::nonnegative(n,"OpenVarSequence::materialize"); - Sequence* s = static_cast(object()); + Int::Limits::nonnegative(n,"OpenVarList::materialize"); + Object* s = static_cast(object()); Int::IntView l(s->length); if (me_failed(l.gq(home,n))) { home.fail(); @@ -312,50 +312,50 @@ namespace Gecode { template Var - OpenVarSequence::get(Space& home, int i) { - Int::Limits::nonnegative(i,"OpenVarSequence::get"); + OpenVarList::get(Space& home, int i) { + Int::Limits::nonnegative(i,"OpenVarList::get"); if (home.failed()) return Var(); - Sequence* s = static_cast(object()); + Object* s = static_cast(object()); if (i >= s->length.max()) - throw Int::OutOfLimits("OpenVarSequence::get"); + throw Int::OutOfLimits("OpenVarList::get"); materialize(home,i+1); if (home.failed()) return Var(); - return static_cast(object())->x[i]; + return static_cast(object())->x[i]; } template void - OpenVarSequence::close(Space& home) { + OpenVarList::close(Space& home) { if (home.failed()) return; materialize(home,length().min()); if (home.failed()) return; - Sequence* s = static_cast(object()); + Object* s = static_cast(object()); if (me_failed(Int::IntView(s->length).eq(home,s->n))) home.fail(); } template void - OpenVarSequence::subscribe(Space& home, Propagator& p) { - Sequence* s = static_cast(object()); + OpenVarList::subscribe(Space& home, Propagator& p) { + Object* s = static_cast(object()); Int::IntView(s->materialized).subscribe(home,p,Int::PC_INT_BND); } template void - OpenVarSequence::cancel(Space& home, Propagator& p) { - Sequence* s = static_cast(object()); + OpenVarList::cancel(Space& home, Propagator& p) { + Object* s = static_cast(object()); Int::IntView(s->materialized).cancel(home,p,Int::PC_INT_BND); } template void - OpenVarSequence::reschedule(Space& home, Propagator& p) { - Sequence* s = static_cast(object()); + OpenVarList::reschedule(Space& home, Propagator& p) { + Object* s = static_cast(object()); Int::IntView(s->materialized).reschedule(home,p,Int::PC_INT_BND); } diff --git a/test/int/extensional.cpp b/test/int/extensional.cpp index da6ebd5f55..f0788a2115 100755 --- a/test/int/extensional.cpp +++ b/test/int/extensional.cpp @@ -854,17 +854,17 @@ namespace Test { namespace Int { class OpenRegularSpace : public Gecode::Space { public: Gecode::IntVarArray x; - Gecode::OpenIntVarSequence sequence; + Gecode::OpenIntVarList list; OpenRegularSpace(Gecode::DFA d, int max=8) - : x(*this,3,0,2), sequence(*this,max) { - Gecode::extensional(*this,sequence,d); + : x(*this,3,0,2), list(*this,max) { + Gecode::extensional(*this,list,d); } OpenRegularSpace(OpenRegularSpace& s) : Gecode::Space(s) { x.update(*this,s.x); - sequence.update(*this,s.sequence); + list.update(*this,s.list); } virtual Gecode::Space* @@ -873,69 +873,69 @@ namespace Test { namespace Int { } }; - /// Space used by open sequence materialization tests - class OpenSequenceSpace : public Gecode::Space { + /// Space used by open list materialization tests + class OpenListSpace : public Gecode::Space { public: - Gecode::OpenIntVarSequence sequence; + Gecode::OpenIntVarList list; - OpenSequenceSpace(void) - : sequence(*this, + OpenListSpace(void) + : list(*this, [](int i) { return Gecode::IntSet(i,i); },6) {} - OpenSequenceSpace(OpenSequenceSpace& s) + OpenListSpace(OpenListSpace& s) : Gecode::Space(s) { - sequence.update(*this,s.sequence); + list.update(*this,s.list); } virtual Gecode::Space* copy(void) { - return new OpenSequenceSpace(*this); + return new OpenListSpace(*this); } }; - /// Test automatic and explicit sequence materialization - class OpenSequenceMaterialize : public ::Test::Base { + /// Test automatic and explicit list materialization + class OpenListMaterialize : public ::Test::Base { public: - OpenSequenceMaterialize(void) - : ::Test::Base("Int::OpenSequence::Materialize") {} + OpenListMaterialize(void) + : ::Test::Base("Int::OpenList::Materialize") {} virtual bool run(void) { using namespace Gecode; - OpenSequenceSpace source; - rel(source,source.sequence.length(),IRT_GQ,3); + OpenListSpace source; + rel(source,source.list.length(),IRT_GQ,3); if ((source.status() == SS_FAILED) || - (source.sequence.size() != 3)) + (source.list.prefix_size() != 3)) return false; for (int i=0; i<3; i++) - if (!source.sequence[i].assigned() || - (source.sequence[i].val() != i)) + if (!source.list[i].assigned() || + (source.list[i].val() != i)) return false; - OpenSequenceSpace* clone = - static_cast(source.clone()); - rel(*clone,clone->sequence.length(),IRT_GQ,5); + OpenListSpace* clone = + static_cast(source.clone()); + rel(*clone,clone->list.length(),IRT_GQ,5); const bool clone_ok = (clone->status() != SS_FAILED) && - (clone->sequence.size() == 5) && - clone->sequence[4].assigned() && - (clone->sequence[4].val() == 4); + (clone->list.prefix_size() == 5) && + clone->list[4].assigned() && + (clone->list[4].val() == 4); delete clone; - if (!clone_ok || (source.sequence.size() != 3)) + if (!clone_ok || (source.list.prefix_size() != 3)) return false; - OpenSequenceSpace direct; - IntVar x = direct.sequence.get(direct,3); - return (direct.sequence.size() == 4) && - (direct.sequence.length().min() == 4) && + OpenListSpace direct; + IntVar x = direct.list.get(direct,3); + return (direct.list.prefix_size() == 4) && + (direct.list.length().min() == 4) && x.assigned() && (x.val() == 3) && (direct.status() != SS_FAILED); } }; - /// Test appending and closing an open regular sequence + /// Test appending and closing an open regular list class OpenRegularIncremental : public ::Test::Base { public: OpenRegularIncremental(void) @@ -949,18 +949,18 @@ namespace Test { namespace Int { if (s.status() == SS_FAILED) return false; - s.sequence.append(s,s.x[0]); + s.list.append(s,s.x[0]); if ((s.status() == SS_FAILED) || !s.x[0].assigned() || (s.x[0].val() != 0)) return false; - s.sequence.append(s,s.x[1]); + s.list.append(s,s.x[1]); if ((s.status() == SS_FAILED) || !s.x[1].assigned() || (s.x[1].val() != 1)) return false; - s.sequence.close(s); + s.list.close(s); return (s.status() != SS_FAILED) && - s.sequence.length().assigned() && - (s.sequence.length().val() == 2); + s.list.length().assigned() && + (s.list.length().val() == 2); } }; @@ -975,14 +975,14 @@ namespace Test { namespace Int { using namespace Gecode; DFA d(0,{{0,0,1},{1,1,2}},{2},false); OpenRegularSpace s(d,3); - rel(s,s.sequence.length(),IRT_GQ,2); + rel(s,s.list.length(),IRT_GQ,2); if (s.status() == SS_FAILED) return false; - return (s.sequence.size() == 2) && - s.sequence[0].assigned() && - (s.sequence[0].val() == 0) && - s.sequence[1].assigned() && - (s.sequence[1].val() == 1); + return (s.list.prefix_size() == 2) && + s.list[0].assigned() && + (s.list[0].val() == 0) && + s.list[1].assigned() && + (s.list[1].val() == 1); } }; @@ -1004,11 +1004,11 @@ namespace Test { namespace Int { {5},false); OpenRegularSpace s(d); rel(s,s.x[1],IRT_EQ,0); - s.sequence.append(s,s.x[0]); + s.list.append(s,s.x[0]); if ((s.status() == SS_FAILED) || (s.x[0].min() != 0) || (s.x[0].max() != 1)) return false; - s.sequence.append(s,s.x[1]); + s.list.append(s,s.x[1]); return (s.status() != SS_FAILED) && s.x[0].assigned() && (s.x[0].val() == 0); } @@ -1031,8 +1031,8 @@ namespace Test { namespace Int { }, {5},false); OpenRegularSpace s(d); - s.sequence.append(s,s.x[0]); - s.sequence.append(s,s.x[1]); + s.list.append(s,s.x[0]); + s.list.append(s,s.x[1]); if ((s.status() == SS_FAILED) || s.x[0].assigned()) return false; rel(s,s.x[1],IRT_EQ,0); @@ -1052,27 +1052,27 @@ namespace Test { namespace Int { using namespace Gecode; DFA d(0,{{0,0,1},{1,1,2}},{2},false); OpenRegularSpace source(d); - source.sequence.append(source,source.x[0]); + source.list.append(source,source.x[0]); if (source.status() == SS_FAILED) return false; OpenRegularSpace* clone = static_cast(source.clone()); - clone->sequence.append(*clone,clone->x[1]); - clone->sequence.close(*clone); + clone->list.append(*clone,clone->x[1]); + clone->list.close(*clone); const bool clone_ok = (clone->status() != SS_FAILED) && - (clone->sequence.size() == 2); + (clone->list.prefix_size() == 2); delete clone; - source.sequence.close(source); + source.list.close(source); const bool source_failed = source.status() == SS_FAILED; return clone_ok && source_failed && - (source.sequence.size() == 1); + (source.list.prefix_size() == 1); } }; - /// Test closing an empty sequence + /// Test closing an empty list class OpenRegularEmpty : public ::Test::Base { public: OpenRegularEmpty(void) @@ -1082,13 +1082,13 @@ namespace Test { namespace Int { run(void) { using namespace Gecode; OpenRegularSpace accepts{DFA()}; - accepts.sequence.close(accepts); + accepts.list.close(accepts); if (accepts.status() == SS_FAILED) return false; DFA d(0,{{0,0,1}},{1},false); OpenRegularSpace rejects(d); - rejects.sequence.close(rejects); + rejects.list.close(rejects); if (rejects.status() != SS_FAILED) return false; @@ -1102,17 +1102,17 @@ namespace Test { namespace Int { class OpenRegularComparisonSpace : public Gecode::Space { public: Gecode::IntVarArray x; - Gecode::OpenIntVarSequence sequence; + Gecode::OpenIntVarList list; OpenRegularComparisonSpace(Gecode::DFA d, bool open, int m0, int m1, int m2) - : x(*this,3,0,2), sequence(*this,3) { + : x(*this,3,0,2), list(*this,3) { using namespace Gecode; if (open) { for (int i=0; isequence.size(); + const int size = solution->list.prefix_size(); bool valid = - solution->sequence.length().assigned() && - (solution->sequence.length().val() == size); + solution->list.length().assigned() && + (solution->list.length().val() == size); for (int i=0; isequence[i].assigned(); + valid &= solution->list[i].assigned(); delete solution; if (!valid) return false; @@ -106,25 +106,25 @@ namespace Test { namespace Int { class BranchOrderSpace : public Gecode::Space { public: - Gecode::OpenIntVarSequence sequence; + Gecode::OpenIntVarList list; BranchOrderSpace(int order) - : sequence(*this,Gecode::IntSet(0,1),3) { + : list(*this,Gecode::IntSet(0,1),3) { using namespace Gecode; DFA accepts_one(0,{ {0,0,0}, {0,1,1}, {1,0,1}, {1,1,1} },{1}); - extensional(*this,sequence,accepts_one); + extensional(*this,list,accepts_one); if (order < 0) - branch(*this,sequence); + branch(*this,list); else - branch(*this,sequence,static_cast(order)); + branch(*this,list,static_cast(order)); } BranchOrderSpace(BranchOrderSpace& s) : Gecode::Space(s) { - sequence.update(*this,s.sequence); + list.update(*this,s.list); } virtual Gecode::Space* @@ -150,7 +150,7 @@ namespace Test { namespace Int { int first = -1; while (BranchOrderSpace* solution = engine.next()) { if (solutions == 0) - first = solution->sequence.size(); + first = solution->list.prefix_size(); solutions++; delete solution; } @@ -159,7 +159,7 @@ namespace Test { namespace Int { public: BranchOrder(void) - : ::Test::Base("Int::OpenSequence::BranchOrder") {} + : ::Test::Base("Int::OpenList::BranchOrder") {} virtual bool run(void) { @@ -172,17 +172,17 @@ namespace Test { namespace Int { class SelectorSpace : public Gecode::Space { public: - Gecode::OpenIntVarSequence sequence; + Gecode::OpenIntVarList list; SelectorSpace(Gecode::IntValBranch vals, Gecode::OpenVarBranch order) - : sequence(*this,[](int i) { return Gecode::IntSet(i,i+1); },3) { + : list(*this,[](int i) { return Gecode::IntSet(i,i+1); },3) { using namespace Gecode; - branch(*this,sequence,tiebreak(INT_VAR_SIZE_MIN(),INT_VAR_MAX_MAX()), + branch(*this,list,tiebreak(INT_VAR_SIZE_MIN(),INT_VAR_MAX_MAX()), vals,order); } SelectorSpace(SelectorSpace& s) : Gecode::Space(s) { - sequence.update(*this,s.sequence); + list.update(*this,s.list); } virtual Gecode::Space* @@ -193,7 +193,7 @@ namespace Test { namespace Int { class Selectors : public ::Test::Base { public: - Selectors(void) : ::Test::Base("Int::OpenSequence::Selectors") {} + Selectors(void) : ::Test::Base("Int::OpenList::Selectors") {} virtual bool run(void) { @@ -215,12 +215,12 @@ namespace Test { namespace Int { DFS engine(&root,options); int solutions = 0; while (SelectorSpace* solution = engine.next()) { - bool valid = solution->sequence.length().assigned() && - (solution->sequence.length().val() == solution->sequence.size()); - for (int i=0; isequence.size(); i++) - valid &= solution->sequence[i].assigned() && - (solution->sequence[i].val() >= i) && - (solution->sequence[i].val() <= i+1); + bool valid = solution->list.length().assigned() && + (solution->list.length().val() == solution->list.prefix_size()); + for (int i=0; ilist.prefix_size(); i++) + valid &= solution->list[i].assigned() && + (solution->list[i].val() >= i) && + (solution->list[i].val() <= i+1); delete solution; if (!valid) return false; @@ -235,13 +235,13 @@ namespace Test { namespace Int { class NoGoods : public ::Test::Base { public: - NoGoods(void) : ::Test::Base("Int::OpenSequence::NoGoods") {} + NoGoods(void) : ::Test::Base("Int::OpenList::NoGoods") {} virtual bool run(void) { using namespace Gecode; SelectorSpace root(INT_VAL_MIN(),OVB_VALUE_FIRST); - root.sequence.materialize(root,1); + root.list.materialize(root,1); Search::NodeStop stop(6); Search::Options options; options.stop = &stop; @@ -252,8 +252,8 @@ namespace Test { namespace Int { bool found[16] = {}; const auto record = [&found](SelectorSpace* solution) { int code = 1; - for (int i=0; isequence.size(); i++) - code = 2*code + solution->sequence[i].val()-i; + for (int i=0; ilist.prefix_size(); i++) + code = 2*code + solution->list[i].val()-i; found[code] = true; delete solution; }; @@ -276,13 +276,13 @@ namespace Test { namespace Int { class SelectorChoiceSpace : public Gecode::Space { public: - Gecode::OpenIntVarSequence sequence; + Gecode::OpenIntVarList list; SelectorChoiceSpace(Gecode::IntValBranch vals) - : sequence(*this,Gecode::IntSet({0,2,5}),3) { + : list(*this,Gecode::IntSet({0,2,5}),3) { using namespace Gecode; - sequence.materialize(*this,3); - branch(*this,sequence, + list.materialize(*this,3); + branch(*this,list, tiebreak(INT_VAR_SIZE_MIN(), INT_VAR_MERIT_MAX([](const Space&, IntVar, int i) { return i; @@ -295,7 +295,7 @@ namespace Test { namespace Int { } SelectorChoiceSpace(SelectorChoiceSpace& s) : Gecode::Space(s) { - sequence.update(*this,s.sequence); + list.update(*this,s.list); } virtual Gecode::Space* @@ -306,7 +306,7 @@ namespace Test { namespace Int { class SelectorChoice : public ::Test::Base { public: - SelectorChoice(void) : ::Test::Base("Int::OpenSequence::SelectorChoice") {} + SelectorChoice(void) : ::Test::Base("Int::OpenList::SelectorChoice") {} virtual bool run(void) { @@ -325,13 +325,13 @@ namespace Test { namespace Int { static_cast(source.clone()); clone->commit(*restored,a); const int expected[] = {5,2,0}; - valid &= !clone->failed() && !clone->sequence[0].assigned() && - !clone->sequence[1].assigned(); + valid &= !clone->failed() && !clone->list[0].assigned() && + !clone->list[1].assigned(); if (multi || (a == 0)) - valid &= clone->sequence[2].assigned() && - (clone->sequence[2].val() == expected[a]); + valid &= clone->list[2].assigned() && + (clone->list[2].val() == expected[a]); else - valid &= !clone->sequence[2].in(5); + valid &= !clone->list[2].in(5); delete clone; } SelectorChoiceSpace* excluded = @@ -340,7 +340,7 @@ namespace Test { namespace Int { valid &= (literal != nullptr) && (literal->status(*excluded) == NGL::NONE); if (literal) valid &= (literal->prune(*excluded) != ES_FAILED) && - !excluded->sequence[2].in(5); + !excluded->list[2].in(5); delete excluded; std::ostringstream printed; source.print(*restored,0,printed); @@ -356,20 +356,20 @@ namespace Test { namespace Int { class BoolSpace : public Gecode::Space { public: - Gecode::OpenBoolVarSequence sequence; + Gecode::OpenBoolVarList list; BoolSpace(Gecode::OpenVarBranch order) - : sequence(*this,3) { + : list(*this,3) { using namespace Gecode; DFA accepts_one(0,{{0,0,0},{0,1,1},{1,0,1},{1,1,1}},{1}); - extensional(*this,sequence,accepts_one); - branch(*this,sequence, + extensional(*this,list,accepts_one); + branch(*this,list, BOOL_VAR_MERIT_MAX([](const Space&, BoolVar, int i) { return i; }), BOOL_VAL_MAX(),order); } BoolSpace(BoolSpace& s) : Gecode::Space(s) { - sequence.update(*this,s.sequence); + list.update(*this,s.list); } virtual Gecode::Space* @@ -378,9 +378,9 @@ namespace Test { namespace Int { } }; - class BoolSequence : public ::Test::Base { + class BoolList : public ::Test::Base { public: - BoolSequence(void) : ::Test::Base("Int::OpenSequence::Bool") {} + BoolList(void) : ::Test::Base("Int::OpenList::Bool") {} virtual bool run(void) { @@ -395,12 +395,12 @@ namespace Test { namespace Int { DFS engine(&root,options); int solutions = 0; while (BoolSpace* solution = engine.next()) { - bool valid = solution->sequence.length().assigned() && - (solution->sequence.length().val() == solution->sequence.size()); + bool valid = solution->list.length().assigned() && + (solution->list.length().val() == solution->list.prefix_size()); int ones = 0; - for (int i=0; isequence.size(); i++) { - valid &= solution->sequence[i].assigned(); - ones += solution->sequence[i].val(); + for (int i=0; ilist.prefix_size(); i++) { + valid &= solution->list[i].assigned(); + ones += solution->list[i].val(); } delete solution; if (!valid || (ones == 0)) @@ -417,23 +417,23 @@ namespace Test { namespace Int { class FactorySpace : public Gecode::Space { public: #ifdef GECODE_HAS_SET_VARS - Gecode::OpenVarSequence sets; + Gecode::OpenVarList sets; #endif #ifdef GECODE_HAS_FLOAT_VARS - Gecode::OpenVarSequence floats; + Gecode::OpenVarList floats; #endif FactorySpace(void) { using namespace Gecode; #ifdef GECODE_HAS_SET_VARS - sets = OpenVarSequence(*this, + sets = OpenVarList(*this, [](Space& home, int i) { return SetVar(home,IntSet(i,i),IntSet(i,i)); },3); sets.materialize(*this,1); #endif #ifdef GECODE_HAS_FLOAT_VARS - floats = OpenVarSequence(*this, + floats = OpenVarList(*this, [](Space& home, int i) { return FloatVar(home,i,i); },3); floats.materialize(*this,1); #endif @@ -456,7 +456,7 @@ namespace Test { namespace Int { class Factory : public ::Test::Base { public: - Factory(void) : ::Test::Base("Int::OpenSequence::Factory") {} + Factory(void) : ::Test::Base("Int::OpenList::Factory") {} virtual bool run(void) { @@ -478,12 +478,14 @@ namespace Test { namespace Int { bool valid = (clone->status() != SS_FAILED) && (source.status() != SS_FAILED); #ifdef GECODE_HAS_SET_VARS - valid &= (source.sets.size() == 1) && (clone->sets.size() == 3) && + valid &= (source.sets.prefix_size() == 1) && + (clone->sets.prefix_size() == 3) && (clone->sets.length().val() == 3) && clone->sets[2].assigned() && (clone->sets[2].glbMin() == 2); #endif #ifdef GECODE_HAS_FLOAT_VARS - valid &= (source.floats.size() == 1) && (clone->floats.size() == 3) && + valid &= (source.floats.prefix_size() == 1) && + (clone->floats.prefix_size() == 3) && (clone->floats.length().val() == 3) && clone->floats[2].assigned() && (clone->floats[2].min() == 2); #endif @@ -494,7 +496,7 @@ namespace Test { namespace Int { class FixedStatistics : public ::Test::Base { public: - FixedStatistics(void) : ::Test::Base("Int::OpenSequence::FixedStatistics") {} + FixedStatistics(void) : ::Test::Base("Int::OpenList::FixedStatistics") {} virtual bool run(void) { @@ -503,7 +505,7 @@ namespace Test { namespace Int { SelectorSpace open(INT_VAL_MIN(),OVB_VALUE_FIRST); bool rejected = false; try { - branch(open,open.sequence, + branch(open,open.list, chb ? INT_VAR_CHB_MIN() : INT_VAR_ACTION_MIN(1.0), INT_VAL_MIN()); } catch (const Gecode::Int::UnknownBranching&) { @@ -512,7 +514,7 @@ namespace Test { namespace Int { if (!rejected) return false; SelectorChoiceSpace fixed(INT_VAL_MIN()); - branch(fixed,fixed.sequence, + branch(fixed,fixed.list, chb ? INT_VAR_CHB_MIN() : INT_VAR_ACTION_MIN(1.0), INT_VAL_MIN()); DFS engine(&fixed); @@ -533,15 +535,15 @@ namespace Test { namespace Int { Selectors selectors; NoGoods no_goods; SelectorChoice selector_choice; - BoolSequence bool_sequence; + BoolList bool_list; class TransitionSpace : public Gecode::Space { public: - Gecode::OpenIntVarSequence sequence; + Gecode::OpenIntVarList list; TransitionSpace(void) - : sequence(*this,Gecode::IntSet(0,4), - [](Gecode::Space& home, Gecode::OpenIntVarSequence x, int i) { + : list(*this,Gecode::IntSet(0,4), + [](Gecode::Space& home, Gecode::OpenIntVarList x, int i) { using namespace Gecode; if (i == 0) { rel(home,x[i],IRT_EQ,0); @@ -550,12 +552,12 @@ namespace Test { namespace Int { IntVarArgs({x[i-1],x[i]}),IRT_EQ,1); } },4) { - Gecode::branch(*this,sequence); + Gecode::branch(*this,list); } TransitionSpace(TransitionSpace& s) : Gecode::Space(s) { - sequence.update(*this,s.sequence); + list.update(*this,s.list); } virtual Gecode::Space* @@ -567,7 +569,7 @@ namespace Test { namespace Int { class Transition : public ::Test::Base { public: Transition(void) - : ::Test::Base("Int::OpenSequence::Transition") {} + : ::Test::Base("Int::OpenList::Transition") {} virtual bool run(void) { @@ -583,12 +585,12 @@ namespace Test { namespace Int { int solutions = 0; while (TransitionSpace* solution = engine.next()) { bool valid = - solution->sequence.length().assigned() && - (solution->sequence.length().val() == - solution->sequence.size()); - for (int i=0; isequence.size(); i++) - valid &= solution->sequence[i].assigned() && - (solution->sequence[i].val() == i); + solution->list.length().assigned() && + (solution->list.length().val() == + solution->list.prefix_size()); + for (int i=0; ilist.prefix_size(); i++) + valid &= solution->list[i].assigned() && + (solution->list[i].val() == i); delete solution; if (!valid) return false; @@ -610,44 +612,44 @@ namespace Test { namespace Int { PRECEDE }; - Gecode::OpenIntVarSequence sequence; + Gecode::OpenIntVarList list; Gecode::IntVar minimum; Gecode::IntVar maximum; ConstraintSpace(Kind kind, int size) - : sequence(*this,Gecode::IntSet(0,2),size), + : list(*this,Gecode::IntSet(0,2),size), minimum(*this,0,2), maximum(*this,0,2) { using namespace Gecode; switch (kind) { case DISTINCT: - distinct(*this,sequence); + distinct(*this,list); break; case REL: - rel(*this,sequence,IRT_LE); + rel(*this,list,IRT_LE); break; case SLIDING: - Gecode::sequence(*this,sequence,IntSet(1,1),2,1,1); + Gecode::sequence(*this,list,IntSet(1,1),2,1,1); break; case SLIDING_SUM: - slidingsum(*this,sequence,2,2,2); + slidingsum(*this,list,2,2,2); break; case MIN_MAX: - min(*this,sequence,minimum); - max(*this,sequence,maximum); + min(*this,list,minimum); + max(*this,list,maximum); rel(*this,minimum,IRT_EQ,0); rel(*this,maximum,IRT_EQ,2); break; case PRECEDE: - precede(*this,sequence,0,1); + precede(*this,list,0,1); break; } - rel(*this,sequence.length(),IRT_EQ,size); - branch(*this,sequence); + rel(*this,list.length(),IRT_EQ,size); + branch(*this,list); } ConstraintSpace(ConstraintSpace& s) : Gecode::Space(s) { - sequence.update(*this,s.sequence); + list.update(*this,s.list); minimum.update(*this,s.minimum); maximum.update(*this,s.maximum); } @@ -678,26 +680,26 @@ namespace Test { namespace Int { bool distinct_solution(const ConstraintSpace& s) { - for (int i=0; i= s.sequence[i].val()) + for (int i=1; i= s.list[i].val()) return false; return true; } bool sliding_solution(const ConstraintSpace& s) { - for (int i=1; i(source.clone()); - clone->sequence.materialize(*clone,2); - clone->sequence.close(*clone); + clone->list.materialize(*clone,2); + clone->list.close(*clone); const bool valid = (clone->status() != SS_FAILED) && - clone->sequence[1].assigned() && - (clone->sequence[1].val() == 2) && + clone->list[1].assigned() && + (clone->list[1].val() == 2) && clone->minimum.assigned() && (clone->minimum.val() == 0) && clone->maximum.assigned() && (clone->maximum.val() == 2); delete clone; - return valid && (source.sequence.size() == 1); + return valid && (source.list.prefix_size() == 1); } }; class CallbackSpace : public Gecode::Space { public: - Gecode::OpenIntVarSequence sequence; + Gecode::OpenIntVarList list; - CallbackSpace(Gecode::OpenIntVarSequence::Domain domain, - Gecode::OpenIntVarSequence::Transition transition) - : sequence(*this,domain,transition,8) {} + CallbackSpace(Gecode::OpenIntVarList::Domain domain, + Gecode::OpenIntVarList::Transition transition) + : list(*this,domain,transition,8) {} CallbackSpace(CallbackSpace& s) : Gecode::Space(s) { - sequence.update(*this,s.sequence); + list.update(*this,s.list); } virtual Gecode::Space* @@ -894,30 +896,30 @@ namespace Test { namespace Int { class GroupSpace : public Gecode::Space { public: enum Kind { REL, SUM, PRECEDE }; - Gecode::OpenIntVarSequence sequence; + Gecode::OpenIntVarList list; Gecode::PropagatorGroup group; GroupSpace(Kind kind, bool close) - : sequence(*this,Gecode::IntSet(0,2),3) { + : list(*this,Gecode::IntSet(0,2),3) { using namespace Gecode; switch (kind) { case REL: - rel((*this)(group),sequence,IRT_NQ); + rel((*this)(group),list,IRT_NQ); break; case SUM: - slidingsum((*this)(group),sequence,2,2,2); + slidingsum((*this)(group),list,2,2,2); break; case PRECEDE: - precede((*this)(group),sequence,0,1); + precede((*this)(group),list,0,1); break; } - sequence.materialize(*this,2); + list.materialize(*this,2); if (close) - sequence.close(*this); + list.close(*this); } GroupSpace(GroupSpace& s) : Gecode::Space(s), group(s.group) { - sequence.update(*this,s.sequence); + list.update(*this,s.list); } virtual Gecode::Space* @@ -933,7 +935,7 @@ namespace Test { namespace Int { bool kill; public: Group(const std::string& name, GroupSpace::Kind kind0, bool kill0) - : ::Test::Base("Int::OpenSequence::Group::"+name+ + : ::Test::Base("Int::OpenList::Group::"+name+ (kill0 ? "::Kill" : "::Disable")), kind(kind0), kill(kill0) {} @@ -949,9 +951,9 @@ namespace Test { namespace Int { else source.group.disable(source); // These values remain in the domains but violate each constraint. - rel(source,source.sequence[0],IRT_EQ, + rel(source,source.list[0],IRT_EQ, kind == GroupSpace::PRECEDE ? 2 : 0); - rel(source,source.sequence[1],IRT_EQ, + rel(source,source.list[1],IRT_EQ, kind == GroupSpace::PRECEDE ? 1 : 0); if (source.status() == SS_FAILED) return false; @@ -975,7 +977,7 @@ namespace Test { namespace Int { class Dispose : public ::Test::Base { public: Dispose(void) - : ::Test::Base("Int::OpenSequence::Dispose") {} + : ::Test::Base("Int::OpenList::Dispose") {} virtual bool run(void) { @@ -984,10 +986,10 @@ namespace Test { namespace Int { std::shared_ptr transition(new int(0)); CallbackSpace* source = new CallbackSpace( [domain](int) { return IntSet(0,1); }, - [transition](Space&, OpenIntVarSequence, int) {}); - source->sequence.materialize(*source,2); + [transition](Space&, OpenIntVarList, int) {}); + source->list.materialize(*source,2); DFA dfa(0,{{0,0,0},{0,1,0}},{0}); - extensional(*source,source->sequence,dfa); + extensional(*source,source->list,dfa); if (source->status() == SS_FAILED) { delete source; return false; @@ -1005,7 +1007,7 @@ namespace Test { namespace Int { class CallbackLength : public ::Test::Base { public: CallbackLength(void) - : ::Test::Base("Int::OpenSequence::CallbackLength") {} + : ::Test::Base("Int::OpenList::CallbackLength") {} virtual bool run(void) { @@ -1013,15 +1015,15 @@ namespace Test { namespace Int { for (int assign=0; assign<2; assign++) for (int close=0; close<2; close++) { CallbackSpace source([](int) { return IntSet(0,1); }, - [assign](Space& home, OpenIntVarSequence sequence, int i) { + [assign](Space& home, OpenIntVarList list, int i) { if (i == 0) - rel(home,sequence.length(),assign ? IRT_EQ : IRT_GQ,3); + rel(home,list.length(),assign ? IRT_EQ : IRT_GQ,3); }); - rel(source,source.sequence.length(),IRT_GQ,1); + rel(source,source.list.length(),IRT_GQ,1); if (close) - source.sequence.close(source); + source.list.close(source); if ((source.status() == SS_FAILED) || - (source.sequence.size() != 3)) + (source.list.prefix_size() != 3)) return false; } return true; @@ -1031,14 +1033,14 @@ namespace Test { namespace Int { class FailedGet : public ::Test::Base { public: FailedGet(void) - : ::Test::Base("Int::OpenSequence::FailedGet") {} + : ::Test::Base("Int::OpenList::FailedGet") {} virtual bool run(void) { using namespace Gecode; CallbackSpace source([](int) { return IntSet(0,1); }, - [](Space& home, OpenIntVarSequence, int) { home.fail(); }); - IntVar x = source.sequence.get(source,4); + [](Space& home, OpenIntVarList, int) { home.fail(); }); + IntVar x = source.list.get(source,4); return source.failed() && (x.varimp() == nullptr); } }; @@ -1046,29 +1048,29 @@ namespace Test { namespace Int { class ValueCommit : public ::Test::Base { public: ValueCommit(void) - : ::Test::Base("Int::OpenSequence::ValueCommit") {} + : ::Test::Base("Int::OpenList::ValueCommit") {} virtual bool run(void) { using namespace Gecode; CallbackSpace source([](int) { return IntSet(0,1); }, - [](Space& home, OpenIntVarSequence, int i) { + [](Space& home, OpenIntVarList, int i) { if (i == 1) home.fail(); }); - source.sequence.materialize(source,1); - branch(source,source.sequence,OVB_VALUE_FIRST); + source.list.materialize(source,1); + branch(source,source.list,OVB_VALUE_FIRST); if (source.status() != SS_BRANCH) return false; const Choice* choice = source.choice(); bool valid = true; for (unsigned int alternative=0; alternative<2; alternative++) { CallbackSpace* clone = static_cast(source.clone()); - rel(*clone,clone->sequence.length(),IRT_GQ,2); + rel(*clone,clone->list.length(),IRT_GQ,2); clone->commit(*choice,alternative); - valid &= !clone->failed() && (clone->sequence.size() == 1) && - clone->sequence[0].assigned() && - (clone->sequence[0].val() == static_cast(alternative)); + valid &= !clone->failed() && (clone->list.prefix_size() == 1) && + clone->list[0].assigned() && + (clone->list[0].val() == static_cast(alternative)); valid &= clone->status() == SS_FAILED; delete clone; } @@ -1080,7 +1082,7 @@ namespace Test { namespace Int { class ImpossibleWindow : public ::Test::Base { public: ImpossibleWindow(void) - : ::Test::Base("Int::OpenSequence::ImpossibleWindow") {} + : ::Test::Base("Int::OpenList::ImpossibleWindow") {} virtual bool run(void) { @@ -1088,16 +1090,16 @@ namespace Test { namespace Int { for (int sum=0; sum<2; sum++) for (int size=0; size<3; size++) { CallbackSpace source([](int) { return IntSet(0,1); }, - [](Space&, OpenIntVarSequence, int) {}); + [](Space&, OpenIntVarList, int) {}); if (sum) - slidingsum(source,source.sequence,2,2,1); + slidingsum(source,source.list,2,2,1); else - Gecode::sequence(source,source.sequence,IntSet(0,1),2,3,3); - rel(source,source.sequence.length(),IRT_EQ,size); + Gecode::sequence(source,source.list,IntSet(0,1),2,3,3); + rel(source,source.list.length(),IRT_EQ,size); const bool failed = source.status() == SS_FAILED; if (failed != (size == 2)) return false; - if (!failed && (source.sequence.size() != size)) + if (!failed && (source.list.prefix_size() != size)) return false; } return true; From ae6915f4b4db0a2433ba43c89cea481d5d1dccd5 Mon Sep 17 00:00:00 2001 From: Mikael Zayenz Lagerkvist Date: Mon, 12 Oct 2026 20:59:00 +0200 Subject: [PATCH 17/34] Use the standard harness for closed open-list constraints --- test/int/extensional.cpp | 133 +++++------------ test/int/open-var-list.cpp | 285 +++++++++++-------------------------- 2 files changed, 124 insertions(+), 294 deletions(-) diff --git a/test/int/extensional.cpp b/test/int/extensional.cpp index f0788a2115..c4df67af23 100755 --- a/test/int/extensional.cpp +++ b/test/int/extensional.cpp @@ -1072,109 +1072,52 @@ namespace Test { namespace Int { } }; - /// Test closing an empty list - class OpenRegularEmpty : public ::Test::Base { - public: - OpenRegularEmpty(void) - : ::Test::Base("Int::Extensional::OpenReg::Empty") {} - - virtual bool - run(void) { - using namespace Gecode; - OpenRegularSpace accepts{DFA()}; - accepts.list.close(accepts); - if (accepts.status() == SS_FAILED) - return false; - - DFA d(0,{{0,0,1}},{1},false); - OpenRegularSpace rejects(d); - rejects.list.close(rejects); - if (rejects.status() != SS_FAILED) - return false; - - DFA empty(0,{{0,0,0}},std::initializer_list{},false); - OpenRegularSpace no_continuation(empty); - return no_continuation.status() == SS_FAILED; - } - }; - - /// Space used to compare closed open regular with regular - class OpenRegularComparisonSpace : public Gecode::Space { + /// Test empty words and automata without accepting states + class OpenRegularEmpty : public Test { + protected: + int kind; public: - Gecode::IntVarArray x; - Gecode::OpenIntVarList list; - - OpenRegularComparisonSpace(Gecode::DFA d, bool open, - int m0, int m1, int m2) - : x(*this,3,0,2), list(*this,3) { + OpenRegularEmpty(int k) + : Test("Extensional::OpenReg::Empty::"+str(k),1,0,0), kind(k) {} + virtual bool solution(const Assignment&) const { return kind == 0; } + virtual void post(Gecode::Space& home, Gecode::IntVarArray&) { using namespace Gecode; - if (open) { - for (int i=0; i{},false)); } - const int mask[3] = {m0,m1,m2}; - for (int i=0; i= x[i]) + return false; + return true; + case SLIDING: + for (int i=1; i engine(root); - delete root; - int n = 0; - while (ConstraintSpace* solution = engine.next()) { - const bool ok = valid(*solution); - delete solution; - if (!ok) - return -1; - n++; - } - return n; - } - - bool - distinct_solution(const ConstraintSpace& s) { - for (int i=0; i= s.list[i].val()) - return false; - return true; - } - - bool - sliding_solution(const ConstraintSpace& s) { - for (int i=1; i Date: Mon, 12 Oct 2026 21:30:11 +0200 Subject: [PATCH 18/34] Harden open-list branching and clarify its public contract --- Makefile.dep | 4 +-- changelog.in | 12 +++++++ gecode/int.hh | 67 ++++++++++++++++++++++++------------ gecode/int/open-var-list.cpp | 36 ++++++++++++------- test/int/extensional.cpp | 7 ++-- test/int/open-var-list.cpp | 59 ++++++++++++++++++++++++++----- 6 files changed, 138 insertions(+), 47 deletions(-) diff --git a/Makefile.dep b/Makefile.dep index 8eee6c8279..e7d523797f 100644 --- a/Makefile.dep +++ b/Makefile.dep @@ -35321,7 +35321,7 @@ test/int/open-var-list$(OBJSUFFIX) test/int/open-var-list$(SBJSUFFIX): \ ./gecode/support/timer.hpp ./test/int.hh ./test/int.hpp \ ./test/test.hh ./test/test.hpp gecode/int/min-distance$(OBJSUFFIX) gecode/int/min-distance$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ @@ -35386,7 +35386,7 @@ gecode/int/min-distance$(OBJSUFFIX) gecode/int/min-distance$(SBJSUFFIX): \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp test/int/min-distance$(OBJSUFFIX) test/int/min-distance$(SBJSUFFIX): \ - ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ diff --git a/changelog.in b/changelog.in index 21287db675..315adb37bb 100755 --- a/changelog.in +++ b/changelog.in @@ -73,6 +73,17 @@ Date: unreleased [DESCRIPTION] This is the development changelog for the next Gecode release. +[ENTRY] +Module: int +What: new +Rank: major +[DESCRIPTION] +Add OpenIntVarList and OpenBoolVarList for lists whose length is decided +during propagation and search. OpenVarList supports other variable types +through a factory. Constraints follow the growing prefix, including regular +language constraints, and branching supports length-first and value-first +search with standard variable and value selectors. + [ENTRY] Module: kernel What: new @@ -88,6 +99,7 @@ Rank: minor [DESCRIPTION] Fix iterator invalidation during counting-based search cache cleanup. + [ENTRY] Module: int diff --git a/gecode/int.hh b/gecode/int.hh index 89684d2e67..d0a48c85d5 100755 --- a/gecode/int.hh +++ b/gecode/int.hh @@ -2441,7 +2441,12 @@ namespace Gecode { * Other variable types use a factory passed to OpenVarList, for * example a function returning SetVar or FloatVar. Storage, cloning, and * materialization are shared; constraint and branching overloads remain - * specific to the variable type. + * specific to the variable type. Var must provide the usual Gecode variable + * handle operations: default and copy construction, assignment, assigned(), + * varimp(), and update(). + * + * Operations require an initialized list belonging to the supplied space. + * Appended variables must also be initialized and belong to that space. * * A list can be used in an ordinary Space: * \code @@ -2449,7 +2454,7 @@ namespace Gecode { * public: * OpenIntVarList x; * Model(void) : x(*this,IntSet(0,1),3) { - * rel(*this,x.length(),IRT_EQ,2); + * rel(*this,x.length(),IRT_GQ,1); * distinct(*this,x); * branch(*this,x); * } @@ -2474,16 +2479,18 @@ namespace Gecode { * \brief Function creating the variable at position \a i in \a home * * The function object is shared between clones. It must be deterministic - * and must not capture space-local data. Returned variables must belong - * to \a home and be initialized. + * and safe for concurrent calls. Captured data must be owned or shared + * and must not be space-local. Returned variables must belong to \a home + * and be initialized. */ typedef std::function Factory; /** * \brief Function called after materializing position \a i * * The function object is shared between clones. It must be - * deterministic and must not capture space-local data; \a home and - * \a x refer to the current space. + * deterministic and safe for concurrent calls. Captured data must be + * owned or shared and must not be space-local; \a home and \a x refer + * to the current space. */ typedef std::function x, int i)> Transition; @@ -2528,7 +2535,9 @@ namespace Gecode { * positions through \a i. * * Returns an uninitialized variable if \a home is failed or - * materialization fails. + * materialization fails. Throws Int::OutOfLimits for a negative index, + * an index outside Int::Limits, or (in a nonfailed space) an index at + * least length().max(). */ Var get(Space& home, int i); /** @@ -2557,8 +2566,9 @@ namespace Gecode { /** * \brief Function returning the domain for position \a i * - * Like Factory, it must be deterministic and must not capture space-local - * data. The function object is shared between clones. + * Like Factory, it must be deterministic, safe for concurrent calls, and + * must not capture space-local data. Captured data must be owned or shared. + * The function object is shared between clones. */ typedef std::function Domain; using OpenVarList::OpenVarList; @@ -2664,7 +2674,8 @@ namespace Gecode { /** * \brief Constrain \a y to the minimum of the eventual sequence \a x * - * The eventual sequence must be nonempty. + * The eventual sequence must be nonempty. Bounds are enforced as positions + * appear; attainment of the extremum is enforced when the list closes. * * \ingroup TaskModelIntArith */ @@ -2675,7 +2686,8 @@ namespace Gecode { /** * \brief Constrain \a y to the maximum of the eventual sequence \a x * - * The eventual sequence must be nonempty. + * The eventual sequence must be nonempty. Bounds are enforced as positions + * appear; attainment of the extremum is enforced when the list closes. * * \ingroup TaskModelIntArith */ @@ -5181,8 +5193,8 @@ namespace Gecode { * \ingroup TaskModelIntBranch */ enum OpenVarBranch { - OVB_HORIZON_FIRST, ///< Select the horizon before list values - OVB_VALUE_FIRST ///< Select materialized values before the horizon + OVB_LENGTH_FIRST, ///< Select the length before list values + OVB_VALUE_FIRST ///< Select materialized values before the length }; /** @@ -6126,27 +6138,38 @@ namespace Gecode { /** * \brief Branch over the eventual integer list \a x * - * The default selects the horizon first, then the first unassigned + * The default selects the length first, then the first unassigned * variable and its minimum value. * \ingroup TaskModelIntBranch */ GECODE_INT_EXPORT void branch(Home home, OpenIntVarList x, - OpenVarBranch o=OVB_HORIZON_FIRST); + OpenVarBranch o=OVB_LENGTH_FIRST); /** * \brief Branch over the eventual Boolean list \a x * \ingroup TaskModelIntBranch */ GECODE_INT_EXPORT void branch(Home home, OpenBoolVarList x, - OpenVarBranch o=OVB_HORIZON_FIRST); + OpenVarBranch o=OVB_LENGTH_FIRST); /** * \brief Branch over an open integer list with standard selectors * - * Selectors consider all materialized positions. \a OVB_HORIZON_FIRST + * Selectors consider all materialized positions. \a OVB_LENGTH_FIRST * decides the length before values; \a OVB_VALUE_FIRST selects values * before closing or extending the list. Filters and callbacks receive - * the position in the list. + * the position in the list. The length decision first tries to close at + * prefix_size(), then requires at least one more position. With no finite + * application bound, exploring these lengths can be very expensive. + * + * To choose the length with another value selector, post an ordinary + * brancher on x.length() before the list brancher, for example: + * \code + * branch(home,x.length(),INT_VAL_SPLIT_MIN()); + * branch(home,x,INT_VAR_SIZE_MIN(),INT_VAL_MIN()); + * \endcode + * Branchers run in posting order. Once the length is assigned, propagation + * materializes that many positions before the list brancher selects values. * * Action and CHB selection require the complete list to be materialized * when posting; otherwise Int::UnknownBranching is thrown. @@ -6155,13 +6178,13 @@ namespace Gecode { GECODE_INT_EXPORT void branch(Home home, OpenIntVarList x, IntVarBranch vars, IntValBranch vals, - OpenVarBranch o=OVB_HORIZON_FIRST, + OpenVarBranch o=OVB_LENGTH_FIRST, IntBranchFilter bf=nullptr, IntVarValPrint vvp=nullptr); /// Branch over an open integer list with tie-breaking selectors GECODE_INT_EXPORT void branch(Home home, OpenIntVarList x, TieBreak vars, IntValBranch vals, - OpenVarBranch o=OVB_HORIZON_FIRST, + OpenVarBranch o=OVB_LENGTH_FIRST, IntBranchFilter bf=nullptr, IntVarValPrint vvp=nullptr); /** * \brief Branch over an open Boolean list with standard selectors @@ -6172,13 +6195,13 @@ namespace Gecode { GECODE_INT_EXPORT void branch(Home home, OpenBoolVarList x, BoolVarBranch vars, BoolValBranch vals, - OpenVarBranch o=OVB_HORIZON_FIRST, + OpenVarBranch o=OVB_LENGTH_FIRST, BoolBranchFilter bf=nullptr, BoolVarValPrint vvp=nullptr); /// Branch over an open Boolean list with tie-breaking selectors GECODE_INT_EXPORT void branch(Home home, OpenBoolVarList x, TieBreak vars, BoolValBranch vals, - OpenVarBranch o=OVB_HORIZON_FIRST, + OpenVarBranch o=OVB_LENGTH_FIRST, BoolBranchFilter bf=nullptr, BoolVarValPrint vvp=nullptr); /** * \brief Branch over \a x with variable selection \a vars and value selection \a vals diff --git a/gecode/int/open-var-list.cpp b/gecode/int/open-var-list.cpp index 8167a26b51..61446723e8 100644 --- a/gecode/int/open-var-list.cpp +++ b/gecode/int/open-var-list.cpp @@ -507,16 +507,19 @@ namespace Gecode { namespace Int { SharedData> printer; OpenVarBranch order; IntValBranch::Select values; + bool select_first; mutable int start; OpenListBrancher(Home home, OpenVarList list0, ViewSel* vs0[n], ValSelCommitBase* vsc0, OpenVarBranch order0, IntValBranch::Select values0, + bool select_first0, BranchFilter bf, VarValPrint vvp) : Brancher(home), list(list0), vsc(vsc0), filter(bf ? bf : [](const Space&, Var, int) { return true; }), - printer(vvp), order(order0), values(values0), start(0) { + printer(vvp), order(order0), values(values0), + select_first(select_first0), start(0) { for (int i=0; i x(r,list.prefix_size()); for (int i=0; i list.prefix_size())) return true; for (int i=start; i list.prefix_size())) return new PosValChoice(*this,2,Pos(-1),list.prefix_size()); for (int i=start; i(c).pos().pos; if (p >= 0) { + // Recomputation can replay choices before propagation grows the prefix. + if (p >= list.prefix_size()) { + list.materialize(home,p+1); + if (home.failed()) + return ES_FAILED; + } View x(list[p]); const ModEvent me = vsc ? vsc->commit(home,a,x,p,static_cast&>(c).val()) @@ -705,7 +716,8 @@ namespace Gecode { namespace Int { for (int i=0; i bf, VarValPrint vvp) { - if ((order != OVB_HORIZON_FIRST) && (order != OVB_VALUE_FIRST)) + if ((order != OVB_LENGTH_FIRST) && (order != OVB_VALUE_FIRST)) throw UnknownBranching("Int::branch"); VarBranch selectors[4] = {vars.a,vars.b,vars.c,vars.d}; int n = 1; @@ -825,13 +837,13 @@ namespace Gecode { void sequence(Home home, OpenIntVarList x, const IntSet& values, int width, int lower, int upper, IntPropLevel ipl) { - Int::Limits::check(values.min(),"Int::list"); - Int::Limits::check(values.max(),"Int::list"); - Int::Limits::check(width,"Int::list"); - Int::Limits::check(lower,"Int::list"); - Int::Limits::check(upper,"Int::list"); + Int::Limits::check(values.min(),"Int::sequence"); + Int::Limits::check(values.max(),"Int::sequence"); + Int::Limits::check(width,"Int::sequence"); + Int::Limits::check(lower,"Int::sequence"); + Int::Limits::check(upper,"Int::sequence"); if (width < 1) - throw Int::OutOfLimits("Int::list"); + throw Int::OutOfLimits("Int::sequence"); GECODE_POST; lower = std::max(0,lower); upper = std::min(width,upper); diff --git a/test/int/extensional.cpp b/test/int/extensional.cpp index c4df67af23..6416b3d688 100755 --- a/test/int/extensional.cpp +++ b/test/int/extensional.cpp @@ -899,7 +899,7 @@ namespace Test { namespace Int { class OpenListMaterialize : public ::Test::Base { public: OpenListMaterialize(void) - : ::Test::Base("Int::OpenList::Materialize") {} + : ::Test::Base("Int::OpenList::Materialize",TestTags::check()) {} virtual bool run(void) { @@ -939,7 +939,8 @@ namespace Test { namespace Int { class OpenRegularIncremental : public ::Test::Base { public: OpenRegularIncremental(void) - : ::Test::Base("Int::Extensional::OpenReg::Incremental") {} + : ::Test::Base("Int::Extensional::OpenReg::Incremental", + TestTags::check()) {} virtual bool run(void) { @@ -1045,7 +1046,7 @@ namespace Test { namespace Int { class OpenRegularClone : public ::Test::Base { public: OpenRegularClone(void) - : ::Test::Base("Int::Extensional::OpenReg::Clone") {} + : ::Test::Base("Int::Extensional::OpenReg::Clone",TestTags::check()) {} virtual bool run(void) { diff --git a/test/int/open-var-list.cpp b/test/int/open-var-list.cpp index a2aa2a8fe9..640dc4c656 100644 --- a/test/int/open-var-list.cpp +++ b/test/int/open-var-list.cpp @@ -74,7 +74,7 @@ namespace Test { namespace Int { class Branch : public ::Test::Base { public: Branch(void) - : ::Test::Base("Int::OpenList::Branch") {} + : ::Test::Base("Int::OpenList::Branch",TestTags::check()) {} virtual bool run(void) { @@ -116,6 +116,8 @@ namespace Test { namespace Int { {1,0,1}, {1,1,1} },{1}); extensional(*this,list,accepts_one); + if (order == -2) + branch(*this,list.length(),INT_VAL_MAX()); if (order < 0) branch(*this,list); else @@ -164,8 +166,8 @@ namespace Test { namespace Int { virtual bool run(void) { using namespace Gecode; - return check(-1,1) && - check(OVB_HORIZON_FIRST,1) && + return check(-2,3) && check(-1,1) && + check(OVB_LENGTH_FIRST,1) && check(OVB_VALUE_FIRST,3); } }; @@ -380,7 +382,7 @@ namespace Test { namespace Int { class BoolList : public ::Test::Base { public: - BoolList(void) : ::Test::Base("Int::OpenList::Bool") {} + BoolList(void) : ::Test::Base("Int::OpenList::Bool",TestTags::check()) {} virtual bool run(void) { @@ -456,7 +458,7 @@ namespace Test { namespace Int { class Factory : public ::Test::Base { public: - Factory(void) : ::Test::Base("Int::OpenList::Factory") {} + Factory(void) : ::Test::Base("Int::OpenList::Factory",TestTags::check()) {} virtual bool run(void) { @@ -707,7 +709,8 @@ namespace Test { namespace Int { class IncrementalConstraints : public ::Test::Base { public: IncrementalConstraints(void) - : ::Test::Base("Int::OpenList::IncrementalConstraints") {} + : ::Test::Base("Int::OpenList::IncrementalConstraints", + TestTags::check()) {} virtual bool run(void) { @@ -866,7 +869,7 @@ namespace Test { namespace Int { class Dispose : public ::Test::Base { public: Dispose(void) - : ::Test::Base("Int::OpenList::Dispose") {} + : ::Test::Base("Int::OpenList::Dispose",TestTags::check()) {} virtual bool run(void) { @@ -896,7 +899,7 @@ namespace Test { namespace Int { class CallbackLength : public ::Test::Base { public: CallbackLength(void) - : ::Test::Base("Int::OpenList::CallbackLength") {} + : ::Test::Base("Int::OpenList::CallbackLength",TestTags::check()) {} virtual bool run(void) { @@ -968,6 +971,45 @@ namespace Test { namespace Int { } }; + /// Replay value choices after propagation has extended the original list + class ValueReplay : public ::Test::Base { + public: + ValueReplay(void) + : ::Test::Base("Int::OpenList::ValueReplay",TestTags::check()) {} + + virtual bool + run(void) { + using namespace Gecode; + CallbackSpace source([](int) { return IntSet(0,1); }, + [](Space& home, OpenIntVarList list, int i) { + if (i == 0) { + BoolVar zero(home,0,1); + rel(home,list[0],IRT_EQ,0,Reify(zero)); + rel(home,list.length(),IRT_GQ,2,Reify(zero,RM_IMP)); + } + }); + source.list.materialize(source,1); + branch(source,source.list,OVB_VALUE_FIRST); + if (source.status() != SS_BRANCH) + return false; + std::unique_ptr first(source.choice()); + std::unique_ptr replay + (static_cast(source.clone())); + source.commit(*first,0); + if ((source.status() != SS_BRANCH) || + (source.list.prefix_size() != 2)) + return false; + std::unique_ptr second(source.choice()); + // Recomputation commits the path without propagating between choices. + replay->commit(*first,0); + replay->commit(*second,0); + return (replay->status() != SS_FAILED) && + (replay->list.prefix_size() == 2) && + replay->list[0].assigned() && (replay->list[0].val() == 0) && + replay->list[1].assigned() && (replay->list[1].val() == 0); + } + }; + class ImpossibleWindow : public ::Test::Base { public: ImpossibleWindow(void) @@ -996,6 +1038,7 @@ namespace Test { namespace Int { }; ValueCommit value_commit; + ValueReplay value_replay; ImpossibleWindow impossible_window; Dispose disposal; From 4c8309cbcbce3b5cac396d3c484ec6e9d154ff21 Mon Sep 17 00:00:00 2001 From: Mikael Zayenz Lagerkvist Date: Tue, 13 Oct 2026 06:29:51 +0200 Subject: [PATCH 19/34] Simplify open-list branching and add a route example --- Makefile.dep | 93 +++++++++++++++++++++++++ Makefile.in | 2 +- changelog.in | 6 +- examples/CMakeLists.txt | 1 + examples/open-route.cpp | 129 +++++++++++++++++++++++++++++++++++ gecode/int.hh | 61 ++++++++--------- gecode/int/open-var-list.cpp | 52 ++++++-------- test/int/open-var-list.cpp | 52 +++++++------- 8 files changed, 306 insertions(+), 90 deletions(-) create mode 100644 examples/open-route.cpp diff --git a/Makefile.dep b/Makefile.dep index e7d523797f..e9e4a046af 100644 --- a/Makefile.dep +++ b/Makefile.dep @@ -15250,6 +15250,99 @@ examples/crossword$(OBJSUFFIX) examples/crossword$(SBJSUFFIX): \ ./gecode/support/marked-pointer.hpp ./gecode/support/random.hpp ./gecode/support/ref-count.hpp \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp +examples/open-route$(OBJSUFFIX) examples/open-route$(SBJSUFFIX): \ + ./gecode/driver.hh ./gecode/driver/options.hpp ./gecode/driver/script.hpp \ + ./gecode/float.hh ./gecode/float/array-traits.hpp ./gecode/float/array.hpp \ + ./gecode/float/branch.hpp ./gecode/float/branch/action.hpp ./gecode/float/branch/afc.hpp \ + ./gecode/float/branch/assign.hpp ./gecode/float/branch/chb.hpp ./gecode/float/branch/traits.hpp \ + ./gecode/float/branch/val.hpp ./gecode/float/branch/var.hpp ./gecode/float/channel.hpp \ + ./gecode/float/exception.hpp ./gecode/float/limits.hpp ./gecode/float/nextafter.hpp \ + ./gecode/float/num.hpp ./gecode/float/rounding.hpp ./gecode/float/trace.hpp \ + ./gecode/float/trace/delta.hpp ./gecode/float/trace/trace-view.hpp ./gecode/float/trace/traits.hpp \ + ./gecode/float/val.hpp ./gecode/float/var-imp.hpp ./gecode/float/var-imp/delta.hpp \ + ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ + ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ + ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ + ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ + ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ + ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ + ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ + ./gecode/int/div.hh ./gecode/int/div.hpp ./gecode/int/exception.hpp \ + ./gecode/int/extensional.hpp ./gecode/int/extensional/dfa.hpp ./gecode/int/extensional/tuple-set.hpp \ + ./gecode/int/int-set-1.hpp ./gecode/int/int-set-2.hpp ./gecode/int/ipl.hpp \ + ./gecode/int/irt.hpp ./gecode/int/limits.hpp ./gecode/int/min-distance.hpp \ + ./gecode/int/open-var-list.hpp ./gecode/int/propagator.hpp ./gecode/int/reify.hpp \ + ./gecode/int/trace.hpp ./gecode/int/trace/bool-delta.hpp ./gecode/int/trace/bool-trace-view.hpp \ + ./gecode/int/trace/int-delta.hpp ./gecode/int/trace/int-trace-view.hpp ./gecode/int/trace/traits.hpp \ + ./gecode/int/var-imp.hpp ./gecode/int/var-imp/bool.hpp ./gecode/int/var-imp/delta.hpp \ + ./gecode/int/var-imp/int.hpp ./gecode/int/var/bool.hpp ./gecode/int/var/int.hpp \ + ./gecode/int/var/print.hpp ./gecode/int/view.hpp ./gecode/int/view/bool-test.hpp \ + ./gecode/int/view/bool.hpp ./gecode/int/view/cached.hpp ./gecode/int/view/constint.hpp \ + ./gecode/int/view/int.hpp ./gecode/int/view/iter.hpp ./gecode/int/view/minus.hpp \ + ./gecode/int/view/neg-bool.hpp ./gecode/int/view/offset.hpp ./gecode/int/view/print.hpp \ + ./gecode/int/view/rel-test.hpp ./gecode/int/view/scale.hpp ./gecode/int/view/zero.hpp \ + ./gecode/iter.hh ./gecode/iter/ranges-add.hpp ./gecode/iter/ranges-append.hpp \ + ./gecode/iter/ranges-array.hpp ./gecode/iter/ranges-cache.hpp ./gecode/iter/ranges-compl.hpp \ + ./gecode/iter/ranges-diff.hpp ./gecode/iter/ranges-empty.hpp ./gecode/iter/ranges-inter.hpp \ + ./gecode/iter/ranges-list.hpp ./gecode/iter/ranges-map.hpp ./gecode/iter/ranges-minmax.hpp \ + ./gecode/iter/ranges-minus.hpp ./gecode/iter/ranges-negative.hpp ./gecode/iter/ranges-offset.hpp \ + ./gecode/iter/ranges-operations.hpp ./gecode/iter/ranges-positive.hpp ./gecode/iter/ranges-rangelist.hpp \ + ./gecode/iter/ranges-scale.hpp ./gecode/iter/ranges-singleton-append.hpp ./gecode/iter/ranges-singleton.hpp \ + ./gecode/iter/ranges-size.hpp ./gecode/iter/ranges-union.hpp ./gecode/iter/ranges-values.hpp \ + ./gecode/iter/values-array.hpp ./gecode/iter/values-bitset.hpp ./gecode/iter/values-bitsetoffset.hpp \ + ./gecode/iter/values-inter.hpp ./gecode/iter/values-list.hpp ./gecode/iter/values-map.hpp \ + ./gecode/iter/values-minus.hpp ./gecode/iter/values-negative.hpp ./gecode/iter/values-offset.hpp \ + ./gecode/iter/values-positive.hpp ./gecode/iter/values-ranges.hpp ./gecode/iter/values-singleton.hpp \ + ./gecode/iter/values-union.hpp ./gecode/iter/values-unique.hpp ./gecode/kernel.hh \ + ./gecode/kernel/archive.hpp ./gecode/kernel/branch/action.hpp ./gecode/kernel/branch/afc.hpp \ + ./gecode/kernel/branch/chb.hpp ./gecode/kernel/branch/filter.hpp ./gecode/kernel/branch/merit.hpp \ + ./gecode/kernel/branch/print.hpp ./gecode/kernel/branch/tiebreak.hpp ./gecode/kernel/branch/traits.hpp \ + ./gecode/kernel/branch/val-commit.hpp ./gecode/kernel/branch/val-sel-commit.hpp ./gecode/kernel/branch/val-sel.hpp \ + ./gecode/kernel/branch/val.hpp ./gecode/kernel/branch/var.hpp ./gecode/kernel/branch/view-sel.hpp \ + ./gecode/kernel/branch/view-val.hpp ./gecode/kernel/branch/view.hpp ./gecode/kernel/core.hpp \ + ./gecode/kernel/data/array.hpp ./gecode/kernel/data/rnd.hpp ./gecode/kernel/data/shared-array.hpp \ + ./gecode/kernel/data/shared-data.hpp ./gecode/kernel/exception.hpp ./gecode/kernel/gpi.hpp \ + ./gecode/kernel/macros.hpp ./gecode/kernel/memory/allocators.hpp ./gecode/kernel/memory/config.hpp \ + ./gecode/kernel/memory/manager.hpp ./gecode/kernel/memory/region.hpp ./gecode/kernel/modevent.hpp \ + ./gecode/kernel/propagator/advisor.hpp ./gecode/kernel/propagator/pattern.hpp ./gecode/kernel/propagator/subscribed.hpp \ + ./gecode/kernel/propagator/wait.hpp ./gecode/kernel/range-list.hpp ./gecode/kernel/shared-object.hpp \ + ./gecode/kernel/shared-space-data.hpp ./gecode/kernel/trace/filter.hpp ./gecode/kernel/trace/general.hpp \ + ./gecode/kernel/trace/print.hpp ./gecode/kernel/trace/recorder.hpp ./gecode/kernel/trace/tracer.hpp \ + ./gecode/kernel/trace/traits.hpp ./gecode/kernel/var-imp.hpp ./gecode/kernel/var-type.hpp \ + ./gecode/kernel/var.hpp ./gecode/kernel/view.hpp ./gecode/minimodel.hh \ + ./gecode/minimodel/aliases.hpp ./gecode/minimodel/bool-expr.hpp ./gecode/minimodel/channel.hpp \ + ./gecode/minimodel/exception.hpp ./gecode/minimodel/float-expr.hpp ./gecode/minimodel/float-rel.hpp \ + ./gecode/minimodel/int-expr.hpp ./gecode/minimodel/int-rel.hpp ./gecode/minimodel/ipl.hpp \ + ./gecode/minimodel/ldsb.hpp ./gecode/minimodel/matrix.hpp ./gecode/minimodel/optimize.hpp \ + ./gecode/minimodel/reg.hpp ./gecode/minimodel/set-expr.hpp ./gecode/minimodel/set-rel.hpp \ + ./gecode/search.hh ./gecode/search/bab.hpp ./gecode/search/base.hpp \ + ./gecode/search/build.hpp ./gecode/search/cutoff.hpp ./gecode/search/dfs.hpp \ + ./gecode/search/engine.hpp ./gecode/search/exception.hpp ./gecode/search/lds.hpp \ + ./gecode/search/options.hpp ./gecode/search/pbs.hpp ./gecode/search/rbs.hpp \ + ./gecode/search/sebs.hpp ./gecode/search/seq/dead.hh ./gecode/search/statistics.hpp \ + ./gecode/search/stop.hpp ./gecode/search/support.hh ./gecode/search/trace-recorder.hpp \ + ./gecode/search/tracer.hpp ./gecode/search/traits.hpp ./gecode/search/worker-control.hh \ + ./gecode/set.hh ./gecode/set/array-traits.hpp ./gecode/set/array.hpp \ + ./gecode/set/branch.hpp ./gecode/set/branch/action.hpp ./gecode/set/branch/afc.hpp \ + ./gecode/set/branch/assign.hpp ./gecode/set/branch/chb.hpp ./gecode/set/branch/traits.hpp \ + ./gecode/set/branch/val.hpp ./gecode/set/branch/var.hpp ./gecode/set/exception.hpp \ + ./gecode/set/int.hpp ./gecode/set/limits.hpp ./gecode/set/trace.hpp \ + ./gecode/set/trace/delta.hpp ./gecode/set/trace/trace-view.hpp ./gecode/set/trace/traits.hpp \ + ./gecode/set/var-imp.hpp ./gecode/set/var-imp/delta.hpp ./gecode/set/var-imp/integerset.hpp \ + ./gecode/set/var-imp/iter.hpp ./gecode/set/var-imp/set.hpp ./gecode/set/var/print.hpp \ + ./gecode/set/var/set.hpp ./gecode/set/view.hpp ./gecode/set/view/cached.hpp \ + ./gecode/set/view/complement.hpp ./gecode/set/view/const.hpp ./gecode/set/view/print.hpp \ + ./gecode/set/view/set.hpp ./gecode/set/view/singleton.hpp ./gecode/support.hh \ + ./gecode/support/allocator.hpp ./gecode/support/auto-link.hpp ./gecode/support/bitset-base.hpp \ + ./gecode/support/bitset-offset.hpp ./gecode/support/bitset.hpp ./gecode/support/block-allocator.hpp \ + ./gecode/support/cast.hpp ./gecode/support/config.hpp ./gecode/support/dynamic-array.hpp \ + ./gecode/support/dynamic-queue.hpp ./gecode/support/dynamic-stack.hpp ./gecode/support/exception.hpp \ + ./gecode/support/failpoint.hpp ./gecode/support/hash.hpp ./gecode/support/heap.hpp \ + ./gecode/support/hw-rnd.hpp ./gecode/support/int-type.hpp ./gecode/support/macros.hpp \ + ./gecode/support/marked-pointer.hpp ./gecode/support/random.hpp ./gecode/support/ref-count.hpp \ + ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ + ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp examples/open-shop$(OBJSUFFIX) examples/open-shop$(SBJSUFFIX): \ ./gecode/driver.hh ./gecode/driver/options.hpp ./gecode/driver/script.hpp \ ./gecode/float.hh ./gecode/float/array-traits.hpp ./gecode/float/array.hpp \ diff --git a/Makefile.in b/Makefile.in index 1ef33463fc..386faed0c6 100755 --- a/Makefile.in +++ b/Makefile.in @@ -909,7 +909,7 @@ INTEXAMPLESRC0 = \ word-square crossword open-shop car-sequencing sat \ bin-packing knights tsp perfect-square schurs-lemma \ dominating-queens colored-matrix multi-bin-packing \ - qcp job-shop + qcp job-shop open-route INTEXAMPLEHDR = $(INTEXAMPLEHDR0:%=examples/%.hpp) diff --git a/changelog.in b/changelog.in index 315adb37bb..c22d70bb92 100755 --- a/changelog.in +++ b/changelog.in @@ -81,8 +81,10 @@ Rank: major Add OpenIntVarList and OpenBoolVarList for lists whose length is decided during propagation and search. OpenVarList supports other variable types through a factory. Constraints follow the growing prefix, including regular -language constraints, and branching supports length-first and value-first -search with standard variable and value selectors. +language constraints. Branching assigns prefix values before closing or +extending the list, using standard variable and value selectors. Posting a +brancher on the length first selects the length before list values. The +open-route example demonstrates routes of varying lengths. [ENTRY] Module: kernel diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt index a223ae844a..7425f2a3fd 100755 --- a/examples/CMakeLists.txt +++ b/examples/CMakeLists.txt @@ -40,6 +40,7 @@ set(GECODE_EXAMPLE_SOURCES money.cpp multi-bin-packing.cpp nonogram.cpp + open-route.cpp open-shop.cpp ortho-latin.cpp partition.cpp diff --git a/examples/open-route.cpp b/examples/open-route.cpp new file mode 100644 index 0000000000..d2bc7691c5 --- /dev/null +++ b/examples/open-route.cpp @@ -0,0 +1,129 @@ +/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */ +/* + * Main author: + * Mikael Zayenz Lagerkvist + * + * Copyright: + * Mikael Zayenz Lagerkvist, 2026 + * + * This file is part of Gecode, the generic constraint + * development environment: + * http://www.gecode.dev + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + */ + +#include +#include + +using namespace Gecode; + +/** + * \brief %Example: simple routes of unknown length + * + * Find all simple routes from node 0 to node 4 in this directed graph: + * 0 -> 1, 2, 4 + * 1 -> 2, 4 + * 2 -> 1, 3 + * 3 -> 2, 4 + * + * The graph contains cycles, but distinct node variables exclude revisits. + * A simple route uses at most the five nodes, so this finite bound preserves + * every solution while ensuring that search terminates. + * + * \ingroup Example + */ +class OpenRoute : public Script { +protected: + /// Number of graph nodes and maximal route length + static const int n = 5; + /// Node IDs in route order, including source and destination + OpenIntVarList route; +public: + /// Branching to use for the route + enum { + BRANCH_INCREMENTAL, ///< Assign the current prefix before extending it + BRANCH_LENGTH ///< Choose the complete route length first + }; + + /// Construct the model + OpenRoute(const Options& opt) + : Script(opt), route(*this,IntSet(0,n-1),n) { + // State 5 consumes the source node. Each remaining transition consumes + // the destination of a graph arc; only node 4 is an accepting state. + DFA paths(5,{ + {5,0,0}, + {0,1,1}, {0,2,2}, {0,4,4}, + {1,2,2}, {1,4,4}, + {2,1,1}, {2,3,3}, + {3,2,2}, {3,4,4} + },{4}); + extensional(*this,route,paths); + distinct(*this,route); + + // Ordinary brancher posting order gives length-first search when wanted. + if (opt.branching() == BRANCH_LENGTH) + branch(*this,route.length(),INT_VAL_MIN()); + branch(*this,route,INT_VAR_NONE(),INT_VAL_MIN()); + } + + /// Constructor for cloning \a s, including the space-local open list + OpenRoute(OpenRoute& s) : Script(s) { + route.update(*this,s.route); + } + + /// Perform copying during cloning + virtual Space* + copy(void) { + return new OpenRoute(*this); + } + + /// Print the materialized route (complete in a solution) + virtual void + print(std::ostream& os) const { + os << "\t"; + for (int i=0; i 0) + os << " -> "; + os << route[i]; + } + os << " (length " << route.length() << ")" << std::endl; + } +}; + +/** \brief Main-function + * \relates OpenRoute + */ +int +main(int argc, char* argv[]) { + Options opt("OpenRoute"); + opt.solutions(0); + opt.branching(OpenRoute::BRANCH_INCREMENTAL); + opt.branching(OpenRoute::BRANCH_INCREMENTAL,"incremental", + "Assign the current prefix before extending the route"); + opt.branching(OpenRoute::BRANCH_LENGTH,"length", + "Choose the complete route length first"); + opt.parse(argc,argv); + Script::run(opt); + return 0; +} + +// STATISTICS: example-any diff --git a/gecode/int.hh b/gecode/int.hh index d0a48c85d5..b595cdf33f 100755 --- a/gecode/int.hh +++ b/gecode/int.hh @@ -2453,7 +2453,7 @@ namespace Gecode { * class Model : public Space { * public: * OpenIntVarList x; - * Model(void) : x(*this,IntSet(0,1),3) { + * Model(void) : x(*this,IntSet(0,2),3) { * rel(*this,x.length(),IRT_GQ,1); * distinct(*this,x); * branch(*this,x); @@ -2467,6 +2467,9 @@ namespace Gecode { * }; * \endcode * + * The \ref OpenRoute "open-route example" gives a complete model of routes + * with varying lengths, including search and printing solutions. + * * \ingroup TaskModelInt */ template @@ -2537,7 +2540,14 @@ namespace Gecode { * Returns an uninitialized variable if \a home is failed or * materialization fails. Throws Int::OutOfLimits for a negative index, * an index outside Int::Limits, or (in a nonfailed space) an index at - * least length().max(). + * least length().max(). Check for failure before using the result, + * for example with an integer list: + * \code + * IntVar y = x.get(home,i); + * if (home.failed()) + * return; + * rel(home,y,IRT_NQ,0); + * \endcode */ Var get(Space& home, int i); /** @@ -2628,7 +2638,7 @@ namespace Gecode { * \brief Constrain all materialized variables in \a x to be distinct * * The constraint is value consistent and applies to variables added - * after posting. + * after posting. The propagation level \a ipl is ignored. * * \ingroup TaskModelIntDistinct */ @@ -5188,15 +5198,6 @@ namespace Gecode { * \ingroup TaskModelInt */ - /** - * \brief Branching order for an open list - * \ingroup TaskModelIntBranch - */ - enum OpenVarBranch { - OVB_LENGTH_FIRST, ///< Select the length before list values - OVB_VALUE_FIRST ///< Select materialized values before the length - }; - /** * \brief Branch filter function type for integer variables * @@ -6138,34 +6139,33 @@ namespace Gecode { /** * \brief Branch over the eventual integer list \a x * - * The default selects the length first, then the first unassigned - * variable and its minimum value. + * Selects the first unassigned materialized variable and its minimum + * value. Once all materialized variables are assigned, tries closing the + * list before extending it by one position. * \ingroup TaskModelIntBranch */ GECODE_INT_EXPORT void - branch(Home home, OpenIntVarList x, - OpenVarBranch o=OVB_LENGTH_FIRST); + branch(Home home, OpenIntVarList x); /** * \brief Branch over the eventual Boolean list \a x * \ingroup TaskModelIntBranch */ GECODE_INT_EXPORT void - branch(Home home, OpenBoolVarList x, - OpenVarBranch o=OVB_LENGTH_FIRST); + branch(Home home, OpenBoolVarList x); /** * \brief Branch over an open integer list with standard selectors * - * Selectors consider all materialized positions. \a OVB_LENGTH_FIRST - * decides the length before values; \a OVB_VALUE_FIRST selects values - * before closing or extending the list. Filters and callbacks receive - * the position in the list. The length decision first tries to close at - * prefix_size(), then requires at least one more position. With no finite - * application bound, exploring these lengths can be very expensive. + * Selectors consider all materialized positions accepted by the filter. + * Once these variables are assigned, the brancher first tries to close at + * prefix_size(), then requires at least one more position and resumes + * value selection. Filters and callbacks receive the position in the list. + * With no finite application bound, exploring these lengths can be very + * expensive. * - * To choose the length with another value selector, post an ordinary - * brancher on x.length() before the list brancher, for example: + * To decide the length before list values, post an ordinary brancher on + * x.length() before the list brancher, for example: * \code - * branch(home,x.length(),INT_VAL_SPLIT_MIN()); + * branch(home,x.length(),INT_VAL_MIN()); * branch(home,x,INT_VAR_SIZE_MIN(),INT_VAL_MIN()); * \endcode * Branchers run in posting order. Once the length is assigned, propagation @@ -6178,30 +6178,27 @@ namespace Gecode { GECODE_INT_EXPORT void branch(Home home, OpenIntVarList x, IntVarBranch vars, IntValBranch vals, - OpenVarBranch o=OVB_LENGTH_FIRST, IntBranchFilter bf=nullptr, IntVarValPrint vvp=nullptr); /// Branch over an open integer list with tie-breaking selectors GECODE_INT_EXPORT void branch(Home home, OpenIntVarList x, TieBreak vars, IntValBranch vals, - OpenVarBranch o=OVB_LENGTH_FIRST, IntBranchFilter bf=nullptr, IntVarValPrint vvp=nullptr); /** * \brief Branch over an open Boolean list with standard selectors * - * The order, filter, and Action/CHB restrictions are as for integers. + * The incremental branching, filter, and Action/CHB restrictions are as + * for integers. * \ingroup TaskModelIntBranch */ GECODE_INT_EXPORT void branch(Home home, OpenBoolVarList x, BoolVarBranch vars, BoolValBranch vals, - OpenVarBranch o=OVB_LENGTH_FIRST, BoolBranchFilter bf=nullptr, BoolVarValPrint vvp=nullptr); /// Branch over an open Boolean list with tie-breaking selectors GECODE_INT_EXPORT void branch(Home home, OpenBoolVarList x, TieBreak vars, BoolValBranch vals, - OpenVarBranch o=OVB_LENGTH_FIRST, BoolBranchFilter bf=nullptr, BoolVarValPrint vvp=nullptr); /** * \brief Branch over \a x with variable selection \a vars and value selection \a vals diff --git a/gecode/int/open-var-list.cpp b/gecode/int/open-var-list.cpp index 61446723e8..3d05c28c64 100644 --- a/gecode/int/open-var-list.cpp +++ b/gecode/int/open-var-list.cpp @@ -505,7 +505,6 @@ namespace Gecode { namespace Int { ValSelCommitBase* vsc; BrancherFilter filter; SharedData> printer; - OpenVarBranch order; IntValBranch::Select values; bool select_first; mutable int start; @@ -513,12 +512,12 @@ namespace Gecode { namespace Int { OpenListBrancher(Home home, OpenVarList list0, ViewSel* vs0[n], ValSelCommitBase* vsc0, - OpenVarBranch order0, IntValBranch::Select values0, + IntValBranch::Select values0, bool select_first0, BranchFilter bf, VarValPrint vvp) : Brancher(home), list(list0), vsc(vsc0), filter(bf ? bf : [](const Space&, Var, int) { return true; }), - printer(vvp), order(order0), values(values0), + printer(vvp), values(values0), select_first(select_first0), start(0) { for (int i=0; i list.prefix_size())) - return true; for (int i=start; i list.prefix_size())) - return new PosValChoice(*this,2,Pos(-1),list.prefix_size()); for (int i=start; i list, VarBranch vars[n], ValSelCommitBase* vsc, - OpenVarBranch order, IntValBranch::Select values, + IntValBranch::Select values, BranchFilter bf, VarValPrint vvp) { ViewSel* vs[n]; for (int i=0; i list, TieBreak vars, ValBranch vals, - OpenVarBranch order, BranchFilter bf, VarValPrint vvp) { - if ((order != OVB_LENGTH_FIRST) && (order != OVB_VALUE_FIRST)) - throw UnknownBranching("Int::branch"); VarBranch selectors[4] = {vars.a,vars.b,vars.c,vars.d}; int n = 1; while ((n < 4) && (selectors[n-1].select() != VarBranch::SEL_NONE) && @@ -789,19 +779,19 @@ namespace Gecode { namespace Int { switch (n) { case 1: OpenListBrancher::post - (home,list,selectors,vsc,order,values,bf,vvp); + (home,list,selectors,vsc,values,bf,vvp); break; case 2: OpenListBrancher::post - (home,list,selectors,vsc,order,values,bf,vvp); + (home,list,selectors,vsc,values,bf,vvp); break; case 3: OpenListBrancher::post - (home,list,selectors,vsc,order,values,bf,vvp); + (home,list,selectors,vsc,values,bf,vvp); break; case 4: OpenListBrancher::post - (home,list,selectors,vsc,order,values,bf,vvp); + (home,list,selectors,vsc,values,bf,vvp); break; } } @@ -909,43 +899,43 @@ namespace Gecode { } void - branch(Home home, OpenIntVarList list, OpenVarBranch order) { - branch(home,list,INT_VAR_NONE(),INT_VAL_MIN(),order); + branch(Home home, OpenIntVarList list) { + branch(home,list,INT_VAR_NONE(),INT_VAL_MIN()); } void - branch(Home home, OpenBoolVarList list, OpenVarBranch order) { - branch(home,list,BOOL_VAR_NONE(),BOOL_VAL_MIN(),order); + branch(Home home, OpenBoolVarList list) { + branch(home,list,BOOL_VAR_NONE(),BOOL_VAL_MIN()); } void branch(Home home, OpenIntVarList list, - IntVarBranch vars, IntValBranch vals, OpenVarBranch order, + IntVarBranch vars, IntValBranch vals, IntBranchFilter bf, IntVarValPrint vvp) { - branch(home,list,TieBreak(vars),vals,order,bf,vvp); + branch(home,list,TieBreak(vars),vals,bf,vvp); } void branch(Home home, OpenIntVarList list, - TieBreak vars, IntValBranch vals, OpenVarBranch order, + TieBreak vars, IntValBranch vals, IntBranchFilter bf, IntVarValPrint vvp) { GECODE_POST; - Int::post_open_brancher(home,list,vars,vals,order,bf,vvp); + Int::post_open_brancher(home,list,vars,vals,bf,vvp); } void branch(Home home, OpenBoolVarList list, - BoolVarBranch vars, BoolValBranch vals, OpenVarBranch order, + BoolVarBranch vars, BoolValBranch vals, BoolBranchFilter bf, BoolVarValPrint vvp) { - branch(home,list,TieBreak(vars),vals,order,bf,vvp); + branch(home,list,TieBreak(vars),vals,bf,vvp); } void branch(Home home, OpenBoolVarList list, - TieBreak vars, BoolValBranch vals, OpenVarBranch order, + TieBreak vars, BoolValBranch vals, BoolBranchFilter bf, BoolVarValPrint vvp) { GECODE_POST; - Int::post_open_brancher(home,list,vars,vals,order,bf,vvp); + Int::post_open_brancher(home,list,vars,vals,bf,vvp); } } diff --git a/test/int/open-var-list.cpp b/test/int/open-var-list.cpp index 640dc4c656..2f0d229184 100644 --- a/test/int/open-var-list.cpp +++ b/test/int/open-var-list.cpp @@ -108,7 +108,9 @@ namespace Test { namespace Int { public: Gecode::OpenIntVarList list; - BranchOrderSpace(int order) + enum Order { INCREMENTAL, LENGTH_MIN, LENGTH_MAX }; + + BranchOrderSpace(Order order) : list(*this,Gecode::IntSet(0,1),3) { using namespace Gecode; DFA accepts_one(0,{ @@ -116,12 +118,11 @@ namespace Test { namespace Int { {1,0,1}, {1,1,1} },{1}); extensional(*this,list,accepts_one); - if (order == -2) + if (order == LENGTH_MIN) + branch(*this,list.length(),INT_VAL_MIN()); + else if (order == LENGTH_MAX) branch(*this,list.length(),INT_VAL_MAX()); - if (order < 0) - branch(*this,list); - else - branch(*this,list,static_cast(order)); + branch(*this,list); } BranchOrderSpace(BranchOrderSpace& s) @@ -138,7 +139,7 @@ namespace Test { namespace Int { class BranchOrder : public ::Test::Base { protected: static bool - check(int order, int first_length) { + check(BranchOrderSpace::Order order, int first_length) { using namespace Gecode; Search::Options options; options.threads = 1; @@ -166,9 +167,9 @@ namespace Test { namespace Int { virtual bool run(void) { using namespace Gecode; - return check(-2,3) && check(-1,1) && - check(OVB_LENGTH_FIRST,1) && - check(OVB_VALUE_FIRST,3); + return check(BranchOrderSpace::INCREMENTAL,3) && + check(BranchOrderSpace::LENGTH_MIN,1) && + check(BranchOrderSpace::LENGTH_MAX,3); } }; @@ -176,11 +177,12 @@ namespace Test { namespace Int { public: Gecode::OpenIntVarList list; - SelectorSpace(Gecode::IntValBranch vals, Gecode::OpenVarBranch order) + SelectorSpace(Gecode::IntValBranch vals, bool length_first=false) : list(*this,[](int i) { return Gecode::IntSet(i,i+1); },3) { using namespace Gecode; - branch(*this,list,tiebreak(INT_VAR_SIZE_MIN(),INT_VAR_MAX_MAX()), - vals,order); + if (length_first) + branch(*this,list.length(),INT_VAL_MIN()); + branch(*this,list,tiebreak(INT_VAR_SIZE_MIN(),INT_VAR_MAX_MAX()),vals); } SelectorSpace(SelectorSpace& s) : Gecode::Space(s) { @@ -208,8 +210,8 @@ namespace Test { namespace Int { INT_VAL([](const Space&, IntVar x, int) { return x.max(); }) }; for (const IntValBranch& vals : values) - for (int order=0; order<2; order++) { - SelectorSpace root(vals,static_cast(order)); + for (bool length_first : {false,true}) { + SelectorSpace root(vals,length_first); Search::Options options; options.threads = 1; options.c_d = 1000; @@ -242,7 +244,7 @@ namespace Test { namespace Int { virtual bool run(void) { using namespace Gecode; - SelectorSpace root(INT_VAL_MIN(),OVB_VALUE_FIRST); + SelectorSpace root(INT_VAL_MIN()); root.list.materialize(root,1); Search::NodeStop stop(6); Search::Options options; @@ -288,7 +290,7 @@ namespace Test { namespace Int { tiebreak(INT_VAR_SIZE_MIN(), INT_VAR_MERIT_MAX([](const Space&, IntVar, int i) { return i; - })),vals,OVB_VALUE_FIRST, + })),vals, [](const Space&, IntVar, int i) { return i != 1; }, [](const Space&, const Brancher&, unsigned int, IntVar, int i, const int& value, std::ostream& out) { @@ -360,14 +362,16 @@ namespace Test { namespace Int { public: Gecode::OpenBoolVarList list; - BoolSpace(Gecode::OpenVarBranch order) + BoolSpace(bool length_first) : list(*this,3) { using namespace Gecode; DFA accepts_one(0,{{0,0,0},{0,1,1},{1,0,1},{1,1,1}},{1}); extensional(*this,list,accepts_one); + if (length_first) + branch(*this,list.length(),INT_VAL_MIN()); branch(*this,list, BOOL_VAR_MERIT_MAX([](const Space&, BoolVar, int i) { return i; }), - BOOL_VAL_MAX(),order); + BOOL_VAL_MAX()); } BoolSpace(BoolSpace& s) : Gecode::Space(s) { @@ -387,9 +391,9 @@ namespace Test { namespace Int { virtual bool run(void) { using namespace Gecode; - for (int order=0; order<2; order++) + for (bool length_first : {false,true}) for (int recompute=0; recompute<2; recompute++) { - BoolSpace root(static_cast(order)); + BoolSpace root(length_first); Search::Options options; options.threads = 1; options.c_d = recompute ? 1000 : 1; @@ -504,7 +508,7 @@ namespace Test { namespace Int { run(void) { using namespace Gecode; for (int chb=0; chb<2; chb++) { - SelectorSpace open(INT_VAL_MIN(),OVB_VALUE_FIRST); + SelectorSpace open(INT_VAL_MIN()); bool rejected = false; try { branch(open,open.list, @@ -951,7 +955,7 @@ namespace Test { namespace Int { home.fail(); }); source.list.materialize(source,1); - branch(source,source.list,OVB_VALUE_FIRST); + branch(source,source.list); if (source.status() != SS_BRANCH) return false; const Choice* choice = source.choice(); @@ -989,7 +993,7 @@ namespace Test { namespace Int { } }); source.list.materialize(source,1); - branch(source,source.list,OVB_VALUE_FIRST); + branch(source,source.list); if (source.status() != SS_BRANCH) return false; std::unique_ptr first(source.choice()); From 3df5b43672146fea661e2f806112b34b15535dec Mon Sep 17 00:00:00 2001 From: Mikael Zayenz Lagerkvist Date: Tue, 13 Oct 2026 07:01:59 +0200 Subject: [PATCH 20/34] Add constrained common-pattern mining example --- Makefile.dep | 93 +++++++++++++++ Makefile.in | 2 +- changelog.in | 3 +- examples/CMakeLists.txt | 1 + examples/common-pattern.cpp | 229 ++++++++++++++++++++++++++++++++++++ gecode/int.hh | 9 +- 6 files changed, 333 insertions(+), 4 deletions(-) create mode 100644 examples/common-pattern.cpp diff --git a/Makefile.dep b/Makefile.dep index e9e4a046af..8f8a0f9aa2 100644 --- a/Makefile.dep +++ b/Makefile.dep @@ -15250,6 +15250,99 @@ examples/crossword$(OBJSUFFIX) examples/crossword$(SBJSUFFIX): \ ./gecode/support/marked-pointer.hpp ./gecode/support/random.hpp ./gecode/support/ref-count.hpp \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp +examples/common-pattern$(OBJSUFFIX) examples/common-pattern$(SBJSUFFIX): \ + ./gecode/driver.hh ./gecode/driver/options.hpp ./gecode/driver/script.hpp \ + ./gecode/float.hh ./gecode/float/array-traits.hpp ./gecode/float/array.hpp \ + ./gecode/float/branch.hpp ./gecode/float/branch/action.hpp ./gecode/float/branch/afc.hpp \ + ./gecode/float/branch/assign.hpp ./gecode/float/branch/chb.hpp ./gecode/float/branch/traits.hpp \ + ./gecode/float/branch/val.hpp ./gecode/float/branch/var.hpp ./gecode/float/channel.hpp \ + ./gecode/float/exception.hpp ./gecode/float/limits.hpp ./gecode/float/nextafter.hpp \ + ./gecode/float/num.hpp ./gecode/float/rounding.hpp ./gecode/float/trace.hpp \ + ./gecode/float/trace/delta.hpp ./gecode/float/trace/trace-view.hpp ./gecode/float/trace/traits.hpp \ + ./gecode/float/val.hpp ./gecode/float/var-imp.hpp ./gecode/float/var-imp/delta.hpp \ + ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ + ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ + ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ + ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ + ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ + ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ + ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ + ./gecode/int/div.hh ./gecode/int/div.hpp ./gecode/int/exception.hpp \ + ./gecode/int/extensional.hpp ./gecode/int/extensional/dfa.hpp ./gecode/int/extensional/tuple-set.hpp \ + ./gecode/int/int-set-1.hpp ./gecode/int/int-set-2.hpp ./gecode/int/ipl.hpp \ + ./gecode/int/irt.hpp ./gecode/int/limits.hpp ./gecode/int/min-distance.hpp \ + ./gecode/int/open-var-list.hpp ./gecode/int/propagator.hpp ./gecode/int/reify.hpp \ + ./gecode/int/trace.hpp ./gecode/int/trace/bool-delta.hpp ./gecode/int/trace/bool-trace-view.hpp \ + ./gecode/int/trace/int-delta.hpp ./gecode/int/trace/int-trace-view.hpp ./gecode/int/trace/traits.hpp \ + ./gecode/int/var-imp.hpp ./gecode/int/var-imp/bool.hpp ./gecode/int/var-imp/delta.hpp \ + ./gecode/int/var-imp/int.hpp ./gecode/int/var/bool.hpp ./gecode/int/var/int.hpp \ + ./gecode/int/var/print.hpp ./gecode/int/view.hpp ./gecode/int/view/bool-test.hpp \ + ./gecode/int/view/bool.hpp ./gecode/int/view/cached.hpp ./gecode/int/view/constint.hpp \ + ./gecode/int/view/int.hpp ./gecode/int/view/iter.hpp ./gecode/int/view/minus.hpp \ + ./gecode/int/view/neg-bool.hpp ./gecode/int/view/offset.hpp ./gecode/int/view/print.hpp \ + ./gecode/int/view/rel-test.hpp ./gecode/int/view/scale.hpp ./gecode/int/view/zero.hpp \ + ./gecode/iter.hh ./gecode/iter/ranges-add.hpp ./gecode/iter/ranges-append.hpp \ + ./gecode/iter/ranges-array.hpp ./gecode/iter/ranges-cache.hpp ./gecode/iter/ranges-compl.hpp \ + ./gecode/iter/ranges-diff.hpp ./gecode/iter/ranges-empty.hpp ./gecode/iter/ranges-inter.hpp \ + ./gecode/iter/ranges-list.hpp ./gecode/iter/ranges-map.hpp ./gecode/iter/ranges-minmax.hpp \ + ./gecode/iter/ranges-minus.hpp ./gecode/iter/ranges-negative.hpp ./gecode/iter/ranges-offset.hpp \ + ./gecode/iter/ranges-operations.hpp ./gecode/iter/ranges-positive.hpp ./gecode/iter/ranges-rangelist.hpp \ + ./gecode/iter/ranges-scale.hpp ./gecode/iter/ranges-singleton-append.hpp ./gecode/iter/ranges-singleton.hpp \ + ./gecode/iter/ranges-size.hpp ./gecode/iter/ranges-union.hpp ./gecode/iter/ranges-values.hpp \ + ./gecode/iter/values-array.hpp ./gecode/iter/values-bitset.hpp ./gecode/iter/values-bitsetoffset.hpp \ + ./gecode/iter/values-inter.hpp ./gecode/iter/values-list.hpp ./gecode/iter/values-map.hpp \ + ./gecode/iter/values-minus.hpp ./gecode/iter/values-negative.hpp ./gecode/iter/values-offset.hpp \ + ./gecode/iter/values-positive.hpp ./gecode/iter/values-ranges.hpp ./gecode/iter/values-singleton.hpp \ + ./gecode/iter/values-union.hpp ./gecode/iter/values-unique.hpp ./gecode/kernel.hh \ + ./gecode/kernel/archive.hpp ./gecode/kernel/branch/action.hpp ./gecode/kernel/branch/afc.hpp \ + ./gecode/kernel/branch/chb.hpp ./gecode/kernel/branch/filter.hpp ./gecode/kernel/branch/merit.hpp \ + ./gecode/kernel/branch/print.hpp ./gecode/kernel/branch/tiebreak.hpp ./gecode/kernel/branch/traits.hpp \ + ./gecode/kernel/branch/val-commit.hpp ./gecode/kernel/branch/val-sel-commit.hpp ./gecode/kernel/branch/val-sel.hpp \ + ./gecode/kernel/branch/val.hpp ./gecode/kernel/branch/var.hpp ./gecode/kernel/branch/view-sel.hpp \ + ./gecode/kernel/branch/view-val.hpp ./gecode/kernel/branch/view.hpp ./gecode/kernel/core.hpp \ + ./gecode/kernel/data/array.hpp ./gecode/kernel/data/rnd.hpp ./gecode/kernel/data/shared-array.hpp \ + ./gecode/kernel/data/shared-data.hpp ./gecode/kernel/exception.hpp ./gecode/kernel/gpi.hpp \ + ./gecode/kernel/macros.hpp ./gecode/kernel/memory/allocators.hpp ./gecode/kernel/memory/config.hpp \ + ./gecode/kernel/memory/manager.hpp ./gecode/kernel/memory/region.hpp ./gecode/kernel/modevent.hpp \ + ./gecode/kernel/propagator/advisor.hpp ./gecode/kernel/propagator/pattern.hpp ./gecode/kernel/propagator/subscribed.hpp \ + ./gecode/kernel/propagator/wait.hpp ./gecode/kernel/range-list.hpp ./gecode/kernel/shared-object.hpp \ + ./gecode/kernel/shared-space-data.hpp ./gecode/kernel/trace/filter.hpp ./gecode/kernel/trace/general.hpp \ + ./gecode/kernel/trace/print.hpp ./gecode/kernel/trace/recorder.hpp ./gecode/kernel/trace/tracer.hpp \ + ./gecode/kernel/trace/traits.hpp ./gecode/kernel/var-imp.hpp ./gecode/kernel/var-type.hpp \ + ./gecode/kernel/var.hpp ./gecode/kernel/view.hpp ./gecode/minimodel.hh \ + ./gecode/minimodel/aliases.hpp ./gecode/minimodel/bool-expr.hpp ./gecode/minimodel/channel.hpp \ + ./gecode/minimodel/exception.hpp ./gecode/minimodel/float-expr.hpp ./gecode/minimodel/float-rel.hpp \ + ./gecode/minimodel/int-expr.hpp ./gecode/minimodel/int-rel.hpp ./gecode/minimodel/ipl.hpp \ + ./gecode/minimodel/ldsb.hpp ./gecode/minimodel/matrix.hpp ./gecode/minimodel/optimize.hpp \ + ./gecode/minimodel/reg.hpp ./gecode/minimodel/set-expr.hpp ./gecode/minimodel/set-rel.hpp \ + ./gecode/search.hh ./gecode/search/bab.hpp ./gecode/search/base.hpp \ + ./gecode/search/build.hpp ./gecode/search/cutoff.hpp ./gecode/search/dfs.hpp \ + ./gecode/search/engine.hpp ./gecode/search/exception.hpp ./gecode/search/lds.hpp \ + ./gecode/search/options.hpp ./gecode/search/pbs.hpp ./gecode/search/rbs.hpp \ + ./gecode/search/sebs.hpp ./gecode/search/seq/dead.hh ./gecode/search/statistics.hpp \ + ./gecode/search/stop.hpp ./gecode/search/support.hh ./gecode/search/trace-recorder.hpp \ + ./gecode/search/tracer.hpp ./gecode/search/traits.hpp ./gecode/search/worker-control.hh \ + ./gecode/set.hh ./gecode/set/array-traits.hpp ./gecode/set/array.hpp \ + ./gecode/set/branch.hpp ./gecode/set/branch/action.hpp ./gecode/set/branch/afc.hpp \ + ./gecode/set/branch/assign.hpp ./gecode/set/branch/chb.hpp ./gecode/set/branch/traits.hpp \ + ./gecode/set/branch/val.hpp ./gecode/set/branch/var.hpp ./gecode/set/exception.hpp \ + ./gecode/set/int.hpp ./gecode/set/limits.hpp ./gecode/set/trace.hpp \ + ./gecode/set/trace/delta.hpp ./gecode/set/trace/trace-view.hpp ./gecode/set/trace/traits.hpp \ + ./gecode/set/var-imp.hpp ./gecode/set/var-imp/delta.hpp ./gecode/set/var-imp/integerset.hpp \ + ./gecode/set/var-imp/iter.hpp ./gecode/set/var-imp/set.hpp ./gecode/set/var/print.hpp \ + ./gecode/set/var/set.hpp ./gecode/set/view.hpp ./gecode/set/view/cached.hpp \ + ./gecode/set/view/complement.hpp ./gecode/set/view/const.hpp ./gecode/set/view/print.hpp \ + ./gecode/set/view/set.hpp ./gecode/set/view/singleton.hpp ./gecode/support.hh \ + ./gecode/support/allocator.hpp ./gecode/support/auto-link.hpp ./gecode/support/bitset-base.hpp \ + ./gecode/support/bitset-offset.hpp ./gecode/support/bitset.hpp ./gecode/support/block-allocator.hpp \ + ./gecode/support/cast.hpp ./gecode/support/config.hpp ./gecode/support/dynamic-array.hpp \ + ./gecode/support/dynamic-queue.hpp ./gecode/support/dynamic-stack.hpp ./gecode/support/exception.hpp \ + ./gecode/support/failpoint.hpp ./gecode/support/hash.hpp ./gecode/support/heap.hpp \ + ./gecode/support/hw-rnd.hpp ./gecode/support/int-type.hpp ./gecode/support/macros.hpp \ + ./gecode/support/marked-pointer.hpp ./gecode/support/random.hpp ./gecode/support/ref-count.hpp \ + ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ + ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp examples/open-route$(OBJSUFFIX) examples/open-route$(SBJSUFFIX): \ ./gecode/driver.hh ./gecode/driver/options.hpp ./gecode/driver/script.hpp \ ./gecode/float.hh ./gecode/float/array-traits.hpp ./gecode/float/array.hpp \ diff --git a/Makefile.in b/Makefile.in index 386faed0c6..335ac99671 100755 --- a/Makefile.in +++ b/Makefile.in @@ -909,7 +909,7 @@ INTEXAMPLESRC0 = \ word-square crossword open-shop car-sequencing sat \ bin-packing knights tsp perfect-square schurs-lemma \ dominating-queens colored-matrix multi-bin-packing \ - qcp job-shop open-route + qcp job-shop open-route common-pattern INTEXAMPLEHDR = $(INTEXAMPLEHDR0:%=examples/%.hpp) diff --git a/changelog.in b/changelog.in index c22d70bb92..05f6ffd211 100755 --- a/changelog.in +++ b/changelog.in @@ -84,7 +84,8 @@ through a factory. Constraints follow the growing prefix, including regular language constraints. Branching assigns prefix values before closing or extending the list, using standard variable and value selectors. Posting a brancher on the length first selects the length before list values. The -open-route example demonstrates routes of varying lengths. +common-pattern example demonstrates constrained subsequence mining without +padding; open-route provides a smaller introduction. [ENTRY] Module: kernel diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt index 7425f2a3fd..aa85f6a937 100755 --- a/examples/CMakeLists.txt +++ b/examples/CMakeLists.txt @@ -13,6 +13,7 @@ set(GECODE_EXAMPLE_SOURCES car-sequencing.cpp cartesian-heart.cpp colored-matrix.cpp + common-pattern.cpp crew.cpp crossword.cpp crowded-chess.cpp diff --git a/examples/common-pattern.cpp b/examples/common-pattern.cpp new file mode 100644 index 0000000000..f244e930e0 --- /dev/null +++ b/examples/common-pattern.cpp @@ -0,0 +1,229 @@ +/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */ +/* + * Main author: + * Mikael Zayenz Lagerkvist + * + * Copyright: + * Mikael Zayenz Lagerkvist, 2026 + * + * This file is part of Gecode, the generic constraint + * development environment: + * http://www.gecode.dev + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + */ + +#include +#include +#include + +#include +#include +#include +#include + +using namespace Gecode; + +/// Options for the input sequences and the pattern language +class CommonPatternOptions : public Options { +protected: + /// Input sequences as a comma-separated command-line value + Driver::StringValueOption _sequences; + /// Whether the pattern must start with A and end with C + Driver::BoolOption _motif; + /// Validated input sequences + std::vector input; +public: + /// Initialize the example options + CommonPatternOptions(void) + : Options("CommonPattern"), + _sequences("sequences","comma-separated nonempty sequences over A..Z", + "ABCBC,BABC,ABDC"), + _motif("motif","require the pattern to start with A and end with C",true) { + add(_sequences); + add(_motif); + } + + /// Read and validate the input after parsing command-line options + bool read(void) { + const std::string text(_sequences.value()); + if (text.empty() || (text.back() == ',')) + return false; + std::istringstream stream(text); + std::string sequence; + while (std::getline(stream,sequence,',')) { + if (sequence.empty() || + (sequence.size() >= static_cast(Int::Limits::max)) || + (sequence.find_first_not_of("ABCDEFGHIJKLMNOPQRSTUVWXYZ") != + std::string::npos)) + return false; + input.push_back(sequence); + } + return true; + } + + /// Return the input sequences + const std::vector& sequences(void) const { return input; } + /// Whether to impose the pattern language + bool motif(void) const { return _motif.value(); } +}; + +namespace { + + /** + * \brief Automaton accepting all subsequences of \a text + * + * State i means that the next match must occur at or after position i. + * Matching the earliest occurrence of a symbol leaves every later match + * available. All states accept, including the state after the final item. + */ + DFA + subsequences(const std::string& text) { + const int n = static_cast(text.size()); + int next[26]; + std::fill(next,next+26,-1); + std::vector transitions; + for (int i=n; i--; ) { + next[text[i]-'A'] = i+1; + for (int a=0; a<26; a++) + if (next[a] >= 0) + transitions.emplace_back(i,'A'+a,next[a]); + } + transitions.emplace_back(-1,0,0); + std::vector finals(n+2); + for (int i=0; i<=n; i++) + finals[i] = i; + finals[n+1] = -1; + return DFA(0,transitions.data(),finals.data()); + } + +} + +/** + * \brief %Example: constrained common subsequences of unknown length + * + * Find a longest nonempty pattern occurring as a subsequence of every input. + * Matching preserves order but may skip input items. By default the pattern + * must also start with A and end with C. The inputs ABCBC, BABC, and ABDC have + * two such patterns, AC and ABC, with ABC the unique longest one. + * + * This is the all-input-support case of constrained sequential pattern mining. + * Kemmar et al., "PREFIX-PROJECTION Global Constraint for Sequential Pattern + * Mining", CP 2015, doi:10.1007/978-3-319-23219-5_17, model varying pattern + * lengths with a fixed array and a special termination item. An OpenIntVarList + * instead contains only actual pattern positions: no padding symbol, suffix + * implications, or padding transitions in the pattern-language automaton. + * The shortest input bounds the length, but does not allocate that many + * decision variables. Constraints posted once follow the growing list. + * + * Each input is represented by a subsequence DFA. This keeps the example in + * the modelling API; it does not implement the paper's shared prefix-projection + * propagator or arbitrary minimum-support thresholds. Automata still require + * storage for the inputs, and lazy variables alone do not guarantee faster + * search. OpenRoute provides a smaller introduction to open lists. + * + * Run with -search dfs to enumerate all feasible patterns, -motif false to + * remove the pattern-language restriction, or -sequences ABCBC,BABC,ABDC to + * supply input sequences. Default branch-and-bound search maximizes length. + * For example, -search dfs -motif false enumerates seven patterns on the + * default input: A, B, C, AB, AC, BC, and ABC. + * + * \ingroup Example + */ +class CommonPattern : public IntMaximizeScript { +protected: + /// Items of the pattern, materialized as required by propagation and search + OpenIntVarList pattern; +public: + /// Search engines + enum { SEARCH_BAB, SEARCH_DFS }; + + /// Construct the model + CommonPattern(const CommonPatternOptions& opt) + : IntMaximizeScript(opt) { + int bound = Int::Limits::max; + for (const std::string& sequence : opt.sequences()) + bound = std::min(bound,static_cast(sequence.size())); + pattern = OpenIntVarList(*this,IntSet('A','Z'),bound); + rel(*this,pattern.length(),IRT_GQ,1); + + for (const std::string& sequence : opt.sequences()) + extensional(*this,pattern,subsequences(sequence)); + if (opt.motif()) { + REG alphabet(IntArgs::create(26,'A',1)); + extensional(*this,pattern,REG('A') + *alphabet + REG('C')); + } + + // Assign the current prefix, then close it or add another item. + branch(*this,pattern,INT_VAR_NONE(),INT_VAL_MIN()); + } + + /// Maximize the eventual pattern length + virtual IntVar cost(void) const { + return pattern.length(); + } + + /// Constructor for cloning \a s + CommonPattern(CommonPattern& s) : IntMaximizeScript(s) { + pattern.update(*this,s.pattern); + } + + /// Copy during cloning + virtual Space* copy(void) { + return new CommonPattern(*this); + } + + /// Print the current prefix (complete in a solution) + virtual void print(std::ostream& os) const { + os << "\t"; + for (int i=0; i(pattern[i].val()); + else + os << pattern[i]; + os << " (length " << pattern.length() << ")" << std::endl; + } +}; + +/** \brief Main-function + * \relates CommonPattern + */ +int +main(int argc, char* argv[]) { + CommonPatternOptions opt; + opt.solutions(0); + opt.search(CommonPattern::SEARCH_BAB); + opt.search(CommonPattern::SEARCH_BAB,"bab","find a longest pattern"); + opt.search(CommonPattern::SEARCH_DFS,"dfs","enumerate feasible patterns"); + opt.parse(argc,argv); + if (!opt.read()) { + std::cerr << "Expected comma-separated nonempty sequences over A..Z" + << std::endl; + return 1; + } + if (opt.search() == CommonPattern::SEARCH_DFS) + IntMaximizeScript::run(opt); + else + IntMaximizeScript::run(opt); + return 0; +} + +// STATISTICS: example-any diff --git a/gecode/int.hh b/gecode/int.hh index b595cdf33f..788aae47f3 100755 --- a/gecode/int.hh +++ b/gecode/int.hh @@ -2467,8 +2467,13 @@ namespace Gecode { * }; * \endcode * - * The \ref OpenRoute "open-route example" gives a complete model of routes - * with varying lengths, including search and printing solutions. + * The \ref CommonPattern "common-pattern example" finds constrained + * subsequences shared by several inputs. The pattern length is a decision; + * the open list avoids allocating an array up to the input-length bound + * and encoding an unused suffix with a termination symbol. Regular + * constraints on both the inputs and the pattern language follow growth. + * The \ref OpenRoute "open-route example" is a smaller introduction, + * including search and printing solutions. * * \ingroup TaskModelInt */ From 7e5829aaa23c78d837e39de84d08920456efbafc Mon Sep 17 00:00:00 2001 From: Mikael Zayenz Lagerkvist Date: Tue, 13 Oct 2026 08:20:13 +0200 Subject: [PATCH 21/34] Add reproducible common-pattern comparisons --- misc/common-pattern/README.md | 187 +++++++++++++++ misc/common-pattern/benchmark.py | 396 +++++++++++++++++++++++++++++++ misc/common-pattern/compare.cpp | 315 ++++++++++++++++++++++++ 3 files changed, 898 insertions(+) create mode 100644 misc/common-pattern/README.md create mode 100755 misc/common-pattern/benchmark.py create mode 100644 misc/common-pattern/compare.cpp diff --git a/misc/common-pattern/README.md b/misc/common-pattern/README.md new file mode 100644 index 0000000000..0a673e5a62 --- /dev/null +++ b/misc/common-pattern/README.md @@ -0,0 +1,187 @@ +# Common-pattern comparisons + +This compares the `common-pattern.cpp` model with the positional encoding and +prefix filtering in Kemmar et al., +[PREFIX-PROJECTION Global Constraint for Sequential Pattern Mining](https://loudni.users.greyc.fr/Papers/cp15final.pdf), +CP 2015, DOI [10.1007/978-3-319-23219-5_17](https://doi.org/10.1007/978-3-319-23219-5_17). + +The comparison asks how open-list DFA propagation behaves relative to a padded +array using DFAs and a padded array using the paper's Algorithm 2. It measures +complete enumeration of **nonempty patterns present in every input sequence**: +100% support, with each sequence counted once regardless of how many embeddings +it contains. Matching repeated symbols consumes distinct input positions. + +## Models + +| Variant | Representation | Subsequence filtering | +| --- | --- | --- | +| `open-dfa` | `OpenIntVarList`, following the example | One open regular constraint per input | +| `padded-dfa` | Fixed `IntVarArray`, zero termination | One ordinary regular constraint per input; zeroes only at the end | +| `paper-projection` | Fixed `IntVarArray`, zero termination | Reimplementation of Algorithm 2, specialized to 100% support | + +The projection model maintains one earliest-match cursor per input and intersects +the items available in their remaining suffixes. It removes unavailable items +from every remaining pattern position. Empty suffixes still support the current +prefix and allow termination. The database is immutable and shared; the current +projection is copied with each space. Parent spaces and recomputation supply the +projection history instead of an explicit stack inside the propagator. There is +no general minimum-support or gap constraint added to Gecode. + +All variants initialize item domains from the actual database alphabet, following +the paper's Section 4.1. The example's A..Z domains give the same open DFA model +after initial propagation. All variants use ascending, left-to-right item +decisions and single-threaded DFS. +The open brancher interleaves closure and growth; the fixed branchers select zero +before another item. Propagation can nevertheless produce different trees. The +ordinary and open regular implementations also differ, so an open/padded timing +ratio does not isolate variable allocation cost alone. Nodes and propagation +calls measure different work across these implementations. + +## Relationship to the paper + +The paper's Section 5 enumerates all patterns, uses the longest input as its +positional bound, varies support thresholds, and reports CPU seconds on an Intel +Xeon X5670 with 24 GB RAM and a one-hour limit. This runner defaults to that +length-bound convention. `--bound shortest` gives all variants the tighter bound +used by the common-pattern example; it preserves solutions at 100% support. + +Built-in cases include Table 1's exact four-sequence database, the example's +database, repeated items, disjoint alphabets, increasing input counts, increasing +input lengths, and increasing common-pattern lengths. Scaling databases are +seeded, planted-pattern workloads. They are **not** the paper's `data-200K` +generator or its other evaluation datasets. Restrictions include the example's +motif and Section 5(d)'s exact RE10, RE14 and RE2 expressions. + +This is an algorithm and representation comparison, **not a reproduction of +Tables 3–4 or the published timing curves**. The paper's project link, +, redirected to Google +sign-in when checked on 2026-10-13. The authors' implementation and dataset +bundle could not be retrieved. `paper-projection` must not be labelled as their +binary. BAB longest-pattern search is excluded because the paper enumerates +all patterns. Runtime ratios against its historical seconds would be misleading. + +Reproducing the complete published experiment would require the original data +and implementation, arbitrary support thresholds in the compared model, and +integer-item input beyond this example's A..Z alphabet. Alphabet truncation, +sampling sequences, or using 100% support would change that experiment. Custom +A..Z databases can be compared here without changing the example's modelling API. + +## Build + +Run these commands from the repository root. The benchmark is compiled separately +against the normal Gecode libraries; no CMake targets or test infrastructure are +added. The commands work with the shared-library build on macOS and Linux. + +```sh +cmake -S . -B build/common-pattern-benchmark -G Ninja \ + -DCMAKE_BUILD_TYPE=Release -DBUILD_TESTING=OFF \ + -DGECODE_ENABLE_SET_VARS=OFF -DGECODE_ENABLE_FLOAT_VARS=OFF \ + -DGECODE_ENABLE_FLATZINC=OFF -DGECODE_ENABLE_CPPROFILER=OFF \ + -DGECODE_ENABLE_MPFR=OFF +cmake --build build/common-pattern-benchmark --target common-pattern -j 6 +c++ -std=c++17 -O3 -DNDEBUG \ + -I build/common-pattern-benchmark -I . misc/common-pattern/compare.cpp \ + -L build/common-pattern-benchmark \ + -Wl,-rpath,"$PWD/build/common-pattern-benchmark" \ + -lgecodeminimodel -lgecodeint -lgecodesearch -lgecodekernel -lgecodesupport \ + -o build/common-pattern-benchmark/bin/common-pattern-compare +``` + +Use the same compiler and optimized build for all variants. Keep the executable +in `BUILD/bin/` and its Gecode libraries in `BUILD/`; the runner fingerprints +that layout's libraries to reject resume after a changed build. Rebuild the +companion after editing its source. `--build-label` records compiler and flags; +it does not check that the supplied label describes the build accurately. + +## Collect and analyze + +```sh +uv run --script misc/common-pattern/benchmark.py run \ + --name release-max --binary build/common-pattern-benchmark/bin/common-pattern-compare \ + --build-label 'AppleClang 21; Release; -O3 -DNDEBUG' --dry-run +uv run --script misc/common-pattern/benchmark.py run \ + --name release-max --binary build/common-pattern-benchmark/bin/common-pattern-compare \ + --build-label 'AppleClang 21; Release; -O3 -DNDEBUG' +uv run --script misc/common-pattern/benchmark.py analyze --name release-max +``` + +The default scaling suite has 24 cases, three variants and five repetitions: +72 correctness invocations followed by 360 measured invocations, serially, with +a 30-second timeout per invocation. Use `--suite smoke --repetitions 2` for a +small check. `--limit N` bounds the number of new measured samples collected in +one call; correctness runs still precede measurement. Repeat the same command +to resume. Use a new name when changing the bound, seed, inputs, timeout, build, +or repetition plan. Only one process should write a named run at a time. + +Before timing, every variant prints its patterns for validation. The runner +rejects duplicate, infeasible or language-invalid patterns and requires identical +solution sets across all variants. It independently enumerates subsequences of +the shortest input when its length is at most 16, checking completeness as well. +Every built-in case meets that oracle bound. Larger custom inputs get feasibility +and cross-implementation checks; completeness is not independently established. + +Measured invocations count solutions without printing them. The target timer +includes model and DFA construction, DFS construction, complete enumeration and +solution disposal; it excludes input parsing, process startup and final engine +destruction. End-to-end wall seconds include these costs and input I/O. Validation +invocations warm filesystem/library caches but are excluded from timing. Variant +and repetition order is shuffled with the saved seed; there is no concurrent +measurement or CPU pinning. Very small timings are useful for exercising the +runner, not for deciding a performance ranking. + +The named directory under `build/common-pattern-results/` contains configuration, +generated inputs, validation evidence, individual sample JSON, and stdout/stderr. +Completed records are replaced atomically and remain unchanged on resume. Missing +or malformed records are unfinished and rerun; partial output for that unfinished +invocation is replaced. Errors, invalid output and timeouts are terminal records +retained on resume, with a nonzero collection exit status. A new run name retries +them without selecting away failures. Analysis does not execute the target and +reports completed, failed and unfinished samples, with median and range in +seconds. Timed-out work is excluded from successful timing summaries, never +assigned the timeout value as a runtime. Keep host conditions comparable when +resuming across sessions. + +For an existing database, provide one nonempty A..Z sequence per line: + +```sh +uv run --script misc/common-pattern/benchmark.py run \ + --name custom --binary build/common-pattern-benchmark/bin/common-pattern-compare \ + --build-label 'your compiler and optimized flags' \ + --database /absolute/path/sequences.txt --language re10 +``` + +Raw timings and generated data stay in the ignored build tree. A comparison +report should name the database, support, restriction, length bound, build, +machine and timing boundary, and retain completion counts beside any timing ratio. + +## Bounded first comparison + +On 2026-10-13, the 24-case scaling suite completed with both length bounds: +720/720 measured samples succeeded, with 144/144 independent enumeration checks +and no disagreements. Each configuration used five repetitions, seed 20261013, +AppleClang 21, a Release Gecode build, and `-O3 -DNDEBUG` for the companion on +macOS 26.6.2 / arm64. These were serial local runs, without CPU pinning. + +Selected medians below are **model construction plus exhaustive search in +milliseconds**, with the paper's maximum length bound. Raw per-sample ranges, +node counts and propagation counts are in the named run `release-max-100`. + +| Case | Open DFA | Padded DFA | Paper projection | +| --- | ---: | ---: | ---: | +| 128 inputs, no language restriction | 8.227 | 7.766 | 0.450 | +| 128 inserted input items, no restriction | 3.915 | 4.106 | 0.281 | +| Common pattern length 12, no restriction | 13.292 | 11.578 | 3.228 | +| RE14 workload | 2.922 | 1.730 | 0.719 | + +The projection implementation was cheaper on these workloads. Open DFA did not +show a consistent timing advantage over padded DFA. Its useful modelling +property remains the absence of padded decision positions; a runtime advantage +is not established. These small planted workloads do not establish performance +on the paper's large mining databases or at lower support thresholds. + +The matching shortest-bound run is `release-shortest-serial`. Resume, partial +collection, malformed-record recovery, changed-configuration rejection, timeout, +execution error, invalid output, and analysis of failures were exercised +separately. An additional 30 seeded small databases, each with and without the +motif, matched the independent oracle across all three variants and the actual +`common-pattern` executable. No repository tests or CMake test targets were added. diff --git a/misc/common-pattern/benchmark.py b/misc/common-pattern/benchmark.py new file mode 100755 index 0000000000..4512812aa1 --- /dev/null +++ b/misc/common-pattern/benchmark.py @@ -0,0 +1,396 @@ +#!/usr/bin/env -S uv run --script +# /// script +# requires-python = ">=3.11" +# dependencies = [] +# /// +"""Compare open/padded DFA models with CP2015 prefix projection at 100% support. + +One writer per named run. See README.md for the build and comparison limits. +""" + +import argparse +from collections import Counter +import hashlib +import json +import math +import os +from pathlib import Path +import platform +import random +import re +import signal +import statistics +import subprocess +import sys +import time + + +VARIANTS = ("open-dfa", "padded-dfa", "paper-projection") +LANGUAGES = { + "none": r"[A-Z]+", + "motif": r"A[A-Z]*C", + "re10": r"A*B(B|C)D*EF*(G|H)I*", + "re14": r"A*(Q|BS*(B|C))D*E(I|S)*(F|H)G*R", + "re2": r"(S|T)[A-Z](R|K)", +} +METRICS = ("solutions", "nodes", "failures", "propagations", + "model_search_seconds") + + +def digest(path: Path) -> str: + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def save_json(path: Path, value: object) -> None: + temporary = path.with_suffix(".tmp") + temporary.write_text(json.dumps(value, indent=2) + "\n") + temporary.replace(path) + + +def planted(rng: random.Random, pattern: str, count: int, + noise: int) -> list[str]: + """Keep the pattern's order while inserting independently sampled items.""" + sequences = [] + for _ in range(count): + text = list(pattern) + for _ in range(noise): + text.insert(rng.randrange(len(text) + 1), rng.choice("DEFGHIJKLMNOP")) + sequences.append("".join(text)) + return sequences + + +def cases(seed: int, suite: str, database: Path | None, + restriction: str) -> list[dict]: + if database: + sequences = database.read_text().splitlines() + if not sequences or any(not re.fullmatch("[A-Z]+", s) for s in sequences): + raise ValueError("database must contain one nonempty A..Z sequence per line") + return [{"id": "input", "sequences": sequences, "language": restriction}] + rng = random.Random(seed) + workloads = [ + ("paper-table1", ["ABCBC", "BABC", "AB", "BCD"], ["none"]), + ("example", ["ABCBC", "BABC", "ABDC"], ["none", "motif"]), + ("repeated", ["AAAAAA", "AAAAAAAA", "AAAAAAAAAA"], ["none", "motif"]), + ("no-common", ["ABC", "DEF"], ["none"]), + ] + if suite == "scaling": + for count in (8, 32, 128): + workloads.append((f"database-{count}", + planted(rng, "ABCABC", count, 10), ["none", "motif"])) + for length in (8, 32, 128): + workloads.append((f"suffix-{length}", + ["ABCBC"] + planted(rng, "ABCBC", 7, length), + ["none", "motif"])) + for length in (4, 8, 12): + pattern = ("ABC" * 4)[:length] + workloads.append((f"pattern-{length}", + [pattern] + planted(rng, pattern, 7, 12), ["none"])) + workloads.extend([ + ("paper-re10", ["AABCDDEFFGII"] + + planted(rng, "AABCDDEFFGII", 7, 8), ["re10"]), + ("paper-re14", ["AABCDDEISHGGR"] + + planted(rng, "AABCDDEISHGGR", 7, 8), ["re14"]), + ("paper-re2", ["SAR"] + planted(rng, "SAR", 7, 16), ["re2"]), + ]) + return [{"id": f"{name}-{language}", "sequences": sequences, + "language": language} + for name, sequences, languages in workloads for language in languages] + + +def common_patterns(sequences: list[str], restriction: str) -> set[str] | None: + """Independent exhaustive oracle when the shortest input is small enough.""" + shortest = min(sequences, key=len) + if len(shortest) > 16: + return None + candidates = {""} + for item in shortest: + candidates |= {prefix + item for prefix in candidates} + expression = re.compile(LANGUAGES[restriction]) + return {pattern for pattern in candidates if expression.fullmatch(pattern) + and all(is_subsequence(pattern, sequence) for sequence in sequences)} + + +def is_subsequence(pattern: str, sequence: str) -> bool: + items = iter(sequence) + return all(item in items for item in pattern) + + +def execute(command: list[str], stdout: Path, stderr: Path, + timeout: float) -> dict: + """Capture one invocation, including startup, and reap its process group.""" + start = time.perf_counter() + with stdout.open("w") as out, stderr.open("w") as err: + try: + process = subprocess.Popen(command, stdout=out, stderr=err, + start_new_session=True) + except OSError as error: + return {"status": "error", "detail": str(error), + "wall_seconds": time.perf_counter() - start} + try: + returncode = process.wait(timeout=timeout) + except subprocess.TimeoutExpired: + kill_process_group(process) + return {"status": "timeout", "wall_seconds": time.perf_counter() - start} + except BaseException: + kill_process_group(process) + raise + elapsed = time.perf_counter() - start + if returncode: + return {"status": "error", "returncode": returncode, "wall_seconds": elapsed} + try: + metrics = json.loads(stderr.read_text()) + if not isinstance(metrics, dict) or set(metrics) != set(METRICS): + raise ValueError("unexpected target metrics") + for key in METRICS: + value = metrics[key] + if (type(value) not in (int, float) or value < 0 or + not math.isfinite(value) or + (key != "model_search_seconds" and type(value) is not int)): + raise ValueError(f"invalid {key}") + except (ValueError, TypeError) as error: + return {"status": "invalid", "detail": str(error), "wall_seconds": elapsed} + return {"status": "ok", "wall_seconds": elapsed, "metrics": metrics} + + +def kill_process_group(process: subprocess.Popen) -> None: + try: + os.killpg(process.pid, signal.SIGKILL) + except ProcessLookupError: + pass + process.wait() + + +def check_patterns(result: dict, output: Path, case: dict, + expected: set[str] | None) -> dict: + if result["status"] != "ok": + return result + patterns = output.read_text().splitlines() + actual = set(patterns) + expression = re.compile(LANGUAGES[case["language"]]) + if (len(patterns) != result["metrics"]["solutions"] or + len(actual) != len(patterns) or + any(not expression.fullmatch(p) or + not all(is_subsequence(p, s) for s in case["sequences"]) + for p in patterns) or (expected is not None and actual != expected)): + return {**result, "status": "invalid", "detail": "incorrect pattern enumeration"} + fingerprint = hashlib.sha256("\n".join(sorted(actual)).encode()).hexdigest() + return {**result, "patterns_sha256": fingerprint, + "oracle": "exhaustive" if expected is not None else "feasibility"} + + +def valid_record(path: Path, identity: dict, validation: bool = False) -> dict | None: + if not path.exists(): + return None + try: + record = json.loads(path.read_text()) + if not isinstance(record, dict): + raise ValueError("record must be an object") + if any(record.get(key) != value for key, value in identity.items()): + raise ValueError("record identity mismatch") + if record.get("status") not in ("ok", "timeout", "error", "invalid"): + raise ValueError("missing terminal status") + elapsed = record["wall_seconds"] + if type(elapsed) not in (int, float) or not math.isfinite(elapsed) or elapsed < 0: + raise ValueError("invalid wall time") + if record["status"] == "ok": + metrics = record["metrics"] + if not isinstance(metrics, dict) or set(metrics) != set(METRICS): + raise ValueError("missing metrics") + for key, value in metrics.items(): + if (type(value) not in (int, float) or not math.isfinite(value) or + value < 0 or (key != "model_search_seconds" and type(value) is not int)): + raise ValueError("invalid saved metrics") + if validation and (not re.fullmatch("[0-9a-f]{64}", + record.get("patterns_sha256", "")) or + record.get("oracle") not in ("exhaustive", "feasibility")): + raise ValueError("missing correctness evidence") + return record + except (ValueError, TypeError, KeyError) as error: + print(f"Unfinished record {path.name}: {error}", file=sys.stderr) + return None + + +def command(binary: str, case: dict, variant: str, database: Path, + output: str, bound: str) -> list[str]: + return [binary, variant, case["language"], str(database), output, bound] + + +def collect(args: argparse.Namespace, directory: Path) -> None: + binary = args.binary.resolve(strict=True) + workloads = cases(args.seed, args.suite, args.database, args.language) + # Mutable shared libraries count as part of the target, not just the executable. + libraries = sorted({p.resolve() for p in binary.parent.parent.glob("libgecode*") + if p.suffix in (".so", ".dylib", ".a")}) + if not libraries: + raise ValueError("expected binary in BUILD/bin and Gecode libraries in BUILD") + config = {"format": 1, "binary": str(binary), "binary_sha256": digest(binary), + "libraries": {str(p): digest(p) for p in libraries}, + "build_label": args.build_label, + "runner_sha256": digest(Path(__file__)), + "source_sha256": digest(Path(__file__).with_name("compare.cpp")), + "machine": {"system": platform.platform(), "node": platform.node(), + "processor": platform.processor()}, + "cases": workloads, "repetitions": args.repetitions, + "seed": args.seed, "timeout_seconds": args.timeout, + "bound": args.bound, "variants": list(VARIANTS)} + print(f"{len(workloads)} cases; {len(workloads)*3} correctness runs; " + f"{len(workloads)*3*args.repetitions} measured runs; " + f"{args.timeout}s timeout per invocation; bound={args.bound}") + print("Serial, shuffled repetitions; model construction + exhaustive DFS; " + "measured runs count solutions without printing them.") + if args.dry_run: + print(" ".join(command(str(binary), workloads[0], VARIANTS[0], + directory / "inputs" / (workloads[0]["id"] + ".txt"), + "count", args.bound))) + return + if directory.exists(): + if json.loads((directory / "config.json").read_text()) != config: + raise ValueError("configuration changed; use a new run name") + else: + directory.mkdir(parents=True) + save_json(directory / "config.json", config) + for part in ("inputs", "validation", "samples"): + (directory / part).mkdir(exist_ok=True) + passed = set() + for case in workloads: + database = directory / "inputs" / (case["id"] + ".txt") + database.write_text("\n".join(case["sequences"]) + "\n") + oracle = common_patterns(case["sequences"], case["language"]) + checks = [] + for variant in VARIANTS: + identity = {"case": case["id"], "variant": variant} + path = directory / "validation" / f"{case['id']}-{variant}.json" + record = valid_record(path, identity, validation=True) + if record is None: + cmd = command(str(binary), case, variant, database, "print", args.bound) + record = execute(cmd, path.with_suffix(".stdout"), + path.with_suffix(".stderr"), args.timeout) + record = check_patterns(record, path.with_suffix(".stdout"), case, oracle) + record.update(identity) + save_json(path, record) + checks.append(record) + if (all(r["status"] == "ok" for r in checks) and + len({r["patterns_sha256"] for r in checks}) == 1): + passed.add(case["id"]) + else: + print(f"{case['id']}: correctness failed or incomplete; timings skipped") + schedule = [(case, variant, repeat) for repeat in range(args.repetitions) + for case in workloads for variant in VARIANTS] + random.Random(args.seed).shuffle(schedule) + executed = 0 + failures = 0 + for case, variant, repeat in schedule: + if case["id"] not in passed: + continue + identity = {"case": case["id"], "variant": variant, "repeat": repeat} + path = directory / "samples" / f"{case['id']}-{variant}-{repeat}.json" + saved = valid_record(path, identity) + if saved is not None: + failures += saved["status"] != "ok" + continue + if args.limit is not None and executed >= args.limit: + break + database = directory / "inputs" / (case["id"] + ".txt") + cmd = command(str(binary), case, variant, database, "count", args.bound) + record = execute(cmd, path.with_suffix(".stdout"), + path.with_suffix(".stderr"), args.timeout) + checked = json.loads((directory / "validation" / + f"{case['id']}-{variant}.json").read_text()) + if record["status"] == "ok" and ( + record["metrics"]["solutions"] != checked["metrics"]["solutions"] or + path.with_suffix(".stdout").read_text()): + record.update(status="invalid", detail="count run differs from validation") + record.update(identity) + save_json(path, record) + executed += 1 + failures += record["status"] != "ok" + print(f"{case['id']} / {variant} / {repeat}: {record['status']}") + print(f"Collected {executed} new measured samples in {directory}") + if len(passed) != len(workloads) or failures: + raise ValueError("comparison has failed or timed-out work; inspect saved records") + + +def analyze(directory: Path) -> None: + config = json.loads((directory / "config.json").read_text()) + print(f"Build: {config['build_label']}; bound: {config['bound']}; " + "support: 100%; all-pattern enumeration") + print("Model+search seconds: median [min, max]; only validated successful samples.") + print("End-to-end wall seconds include process startup and teardown.") + print("case | variant | ok/expected | other | patterns | model+search s | wall s | nodes | propagations") + totals = Counter() + validation_counts = Counter() + mismatched_cases = 0 + for case in config["cases"]: + checks = [valid_record(directory / "validation" / f"{case['id']}-{v}.json", + {"case": case["id"], "variant": v}, validation=True) + for v in config["variants"]] + comparable = (all(r is not None and r["status"] == "ok" for r in checks) and + len({r["patterns_sha256"] for r in checks}) == 1) + validation_counts.update(r["status"] if r else "unfinished" for r in checks) + if all(r is not None and r["status"] == "ok" for r in checks) and not comparable: + mismatched_cases += 1 + for variant in config["variants"]: + records = [valid_record( + directory / "samples" / f"{case['id']}-{variant}-{repeat}.json", + {"case": case["id"], "variant": variant, "repeat": repeat}) + for repeat in range(config["repetitions"])] + counts = Counter(r["status"] if r else "unfinished" for r in records) + totals.update(counts) + successful = [r for r in records if r and r["status"] == "ok"] if comparable else [] + other = ",".join(f"{key}:{value}" for key, value in counts.items() if key != "ok") or "-" + if not successful: + print(f"{case['id']} | {variant} | 0/{config['repetitions']} | {other} " + "| unavailable (correctness or collection incomplete)") + continue + seconds = [r["metrics"]["model_search_seconds"] for r in successful] + wall = statistics.median(r["wall_seconds"] for r in successful) + metrics = successful[0]["metrics"] + print(f"{case['id']} | {variant} | {len(successful)}/{config['repetitions']} | " + f"{other} | {metrics['solutions']} | {statistics.median(seconds):.6f} " + f"[{min(seconds):.6f}, {max(seconds):.6f}] | {wall:.6f} | " + f"{metrics['nodes']} | {metrics['propagations']}") + print(f"Measured sample status: {dict(totals)}") + print(f"Correctness status: {dict(validation_counts)}; " + f"cases with disagreeing pattern sets: {mismatched_cases}") + print("Paper-projection is an Algorithm 2 reimplementation at 100% support, " + "not the authors' executable or a replication of their dataset timings.") + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--results-root", type=Path, default=Path("build/common-pattern-results")) + subparsers = parser.add_subparsers(dest="action", required=True) + run = subparsers.add_parser("run", help="collect or resume a named comparison") + run.add_argument("--name", required=True) + run.add_argument("--binary", type=Path, required=True) + run.add_argument("--build-label", required=True, help="compiler, flags and build configuration") + run.add_argument("--suite", choices=("smoke", "scaling"), default="scaling") + run.add_argument("--database", type=Path, help="custom A..Z database, one sequence per line") + run.add_argument("--language", choices=tuple(LANGUAGES), default="none", + help="restriction for a custom database") + run.add_argument("--bound", choices=("max", "shortest"), default="max") + run.add_argument("--repetitions", type=int, default=5) + run.add_argument("--timeout", type=float, default=30) + run.add_argument("--seed", type=int, default=20261013) + run.add_argument("--limit", type=int, help="collect at most this many new timed samples") + run.add_argument("--dry-run", action="store_true") + report = subparsers.add_parser("analyze", help="summarize saved measurements without running targets") + report.add_argument("--name", required=True) + args = parser.parse_args() + if not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9_.-]*", args.name): + parser.error("name must be one safe path component") + directory = args.results_root.resolve() / args.name + try: + if args.action == "run": + if (args.repetitions < 1 or not math.isfinite(args.timeout) or args.timeout <= 0 or + (args.limit is not None and args.limit < 0)): + parser.error("repetitions and timeout must be positive; limit must be nonnegative") + collect(args, directory) + else: + analyze(directory) + except (ValueError, OSError) as error: + parser.exit(1, f"{error}\n") + + +if __name__ == "__main__": + main() diff --git a/misc/common-pattern/compare.cpp b/misc/common-pattern/compare.cpp new file mode 100644 index 0000000000..9d0caad95e --- /dev/null +++ b/misc/common-pattern/compare.cpp @@ -0,0 +1,315 @@ +/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */ +/* + * Benchmark companion to examples/common-pattern.cpp. + * Copyright Mikael Zayenz Lagerkvist, 2026. + * Distributed under the MIT license; see LICENSE. + */ + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +using namespace Gecode; + +namespace { + + /// The representations compared on identical enumeration problems + enum class Model { OpenDFA, PaddedDFA, PaperProjection }; + + /// Earliest-match subsequence DFA, optionally accepting trailing zeroes + DFA + subsequences(const std::string& text, bool padded) { + const int n = static_cast(text.size()); + int next[26]; + std::fill(next,next+26,-1); + std::vector transitions; + for (int i=n; i--; ) { + next[text[i]-'A'] = i+1; + for (int a=0; a<26; a++) + if (next[a] >= 0) + transitions.emplace_back(i,'A'+a,next[a]); + } + if (padded) { + for (int i=0; i<=n+1; i++) + transitions.emplace_back(i,0,n+1); + } + transitions.emplace_back(-1,0,0); + const int states = n+1+static_cast(padded); + std::vector finals(states+1); + for (int i=0; i { + protected: + /// Immutable concatenated database and exclusive sequence ends + IntSharedArray items, ends; + /// Next unmatched input position for each sequence + int* cursor; + /// Number of consumed contiguous pattern positions + int consumed; + public: + /// Post the initial projection + PaperProjection(Space& home, ViewArray& x, + const IntSharedArray& data, const IntSharedArray& limits) + : NaryPropagator(home,x), + items(data), ends(limits), cursor(home.alloc(ends.size())), + consumed(0) { + for (int i=0; i(home,p), + items(p.items), ends(p.ends), cursor(home.alloc(ends.size())), + consumed(p.consumed) { + std::copy(p.cursor,p.cursor+ends.size(),cursor); + } + + virtual Actor* copy(Space& home) { + return new (home) PaperProjection(home,*this); + } + + virtual PropCost cost(const Space&, const ModEventDelta&) const { + return PropCost::linear(PropCost::HI,items.size()+x.size()); + } + + virtual size_t dispose(Space& home) { + home.ignore(*this,AP_DISPOSE); + items.~IntSharedArray(); + ends.~IntSharedArray(); + (void) NaryPropagator::dispose(home); + return sizeof(*this); + } + + virtual ExecStatus propagate(Space& home, const ModEventDelta&) { + for (;;) { + while ((consumed < x.size()) && x[consumed].assigned()) { + const int a = x[consumed].val(); + if (a == 0) { + for (int j=consumed+1; j& input, Model m, + const std::string& restriction, int bound) + : model(m) { + bool present[26] = {}; + for (const std::string& sequence : input) + for (char a : sequence) + present[a-'A'] = true; + int values[27]; + int n = 1; + values[0] = 0; + for (int a=0; a<26; a++) + if (present[a]) + values[n++] = 'A'+a; + if (model == Model::OpenDFA) { + open = OpenIntVarList(*this,IntSet(values+1,n-1),bound); + rel(*this,open.length(),IRT_GQ,1); + for (const std::string& sequence : input) + extensional(*this,open,subsequences(sequence,false)); + if (restriction != "none") + extensional(*this,open,language(restriction)); + branch(*this,open,INT_VAR_NONE(),INT_VAL_MIN()); + return; + } + padded = IntVarArray(*this,bound,IntSet(values,n)); + rel(*this,padded[0],IRT_NQ,0); + if (model == Model::PaddedDFA) { + for (const std::string& sequence : input) + extensional(*this,padded,subsequences(sequence,true)); + } else { + int size = 0; + for (const std::string& sequence : input) + size += static_cast(sequence.size()); + IntSharedArray items(size), ends(static_cast(input.size())); + int k = 0, i = 0; + for (const std::string& sequence : input) { + for (char a : sequence) + items[k++] = a; + ends[i++] = k; + } + ViewArray x(*this,IntVarArgs(padded)); + (void) new (*this) PaperProjection(*this,x,items,ends); + } + if (restriction != "none") + extensional(*this,padded,language(restriction) + *REG(0)); + branch(*this,padded,INT_VAR_NONE(),INT_VAL_MIN()); + } + + Pattern(Pattern& s) : Space(s), model(s.model) { + if (model == Model::OpenDFA) + open.update(*this,s.open); + else + padded.update(*this,s.padded); + } + + virtual Space* copy(void) { return new Pattern(*this); } + + /// Emit actual items only, in the same format for all representations + void print(void) const { + if (model == Model::OpenDFA) { + for (int i=0; i(open[i].val()); + } else { + for (int i=0; (i(padded[i].val()); + } + std::cout << '\n'; + } + }; + +} + +int +main(int argc, char* argv[]) { + if (argc != 6) { + std::cerr << "Usage: compare open-dfa|padded-dfa|paper-projection " + << "none|motif|re10|re14|re2 FILE print|count max|shortest\n"; + return 1; + } + const std::string variant(argv[1]), restriction(argv[2]), + output(argv[4]), length_bound(argv[5]); + if (((variant != "open-dfa") && (variant != "padded-dfa") && + (variant != "paper-projection")) || + ((restriction != "none") && (restriction != "motif") && + (restriction != "re10") && (restriction != "re14") && + (restriction != "re2")) || + ((output != "print") && (output != "count")) || + ((length_bound != "max") && (length_bound != "shortest"))) + return 1; + std::ifstream file(argv[3]); + std::vector input; + std::string sequence; + size_t total = 0; + while (std::getline(file,sequence)) { + if (sequence.empty() || (sequence.find_first_not_of( + "ABCDEFGHIJKLMNOPQRSTUVWXYZ") != std::string::npos)) { + std::cerr << "Expected one nonempty A..Z sequence per line\n"; + return 1; + } + total += sequence.size(); + if (total >= static_cast(Int::Limits::max)) + return 1; + input.push_back(sequence); + } + if (!file.eof() || input.empty()) + return 1; + int bound = static_cast(input.front().size()); + for (const std::string& text : input) + bound = (length_bound == "max") ? + std::max(bound,static_cast(text.size())) : + std::min(bound,static_cast(text.size())); + const Model model = (variant == "open-dfa") ? Model::OpenDFA : + (variant == "padded-dfa") ? Model::PaddedDFA : Model::PaperProjection; + const auto start = std::chrono::steady_clock::now(); + Pattern* root = new Pattern(input,model,restriction,bound); + Search::Options options; + options.threads = 1; + options.clone = false; + DFS engine(root,options); + unsigned long long solutions = 0; + while (Pattern* solution = engine.next()) { + solutions++; + if (output == "print") + solution->print(); + delete solution; + } + const auto end = std::chrono::steady_clock::now(); + const Search::Statistics stats = engine.statistics(); + std::cerr << "{\"solutions\":" << solutions + << ",\"nodes\":" << stats.node + << ",\"failures\":" << stats.fail + << ",\"propagations\":" << stats.propagate + << ",\"model_search_seconds\":" + << std::chrono::duration(end-start).count() << "}\n"; + return 0; +} From dfbffd1204f061b9e8d17fc3334548104cc57658 Mon Sep 17 00:00:00 2001 From: Mikael Zayenz Lagerkvist Date: Tue, 13 Oct 2026 10:31:16 +0200 Subject: [PATCH 22/34] Model constrained frequent subsequences with open lists --- Makefile.dep | 12 +- changelog.in | 5 +- examples/common-pattern.cpp | 279 ++++++++++++---------- examples/common-pattern.hh | 391 +++++++++++++++++++++++++++++++ gecode/int.hh | 6 +- misc/common-pattern/README.md | 368 +++++++++++++++++++---------- misc/common-pattern/benchmark.py | 218 +++++++++++------ misc/common-pattern/compare.cpp | 383 +++++++++++++++--------------- test/int/open-var-list.cpp | 208 ++++++++++++++++ 9 files changed, 1353 insertions(+), 517 deletions(-) create mode 100644 examples/common-pattern.hh diff --git a/Makefile.dep b/Makefile.dep index 8f8a0f9aa2..75ddc9b2ac 100644 --- a/Makefile.dep +++ b/Makefile.dep @@ -15342,7 +15342,8 @@ examples/common-pattern$(OBJSUFFIX) examples/common-pattern$(SBJSUFFIX): \ ./gecode/support/hw-rnd.hpp ./gecode/support/int-type.hpp ./gecode/support/macros.hpp \ ./gecode/support/marked-pointer.hpp ./gecode/support/random.hpp ./gecode/support/ref-count.hpp \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ - ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp + ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp \ + ./examples/common-pattern.hh examples/open-route$(OBJSUFFIX) examples/open-route$(SBJSUFFIX): \ ./gecode/driver.hh ./gecode/driver/options.hpp ./gecode/driver/script.hpp \ ./gecode/float.hh ./gecode/float/array-traits.hpp ./gecode/float/array.hpp \ @@ -35505,7 +35506,14 @@ test/int/open-var-list$(OBJSUFFIX) test/int/open-var-list$(SBJSUFFIX): \ ./gecode/support/ref-count.hpp ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp \ ./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \ ./gecode/support/timer.hpp ./test/int.hh ./test/int.hpp \ - ./test/test.hh ./test/test.hpp + ./test/test.hh ./test/test.hpp \ + ./examples/common-pattern.hh ./gecode/int/min-distance.hpp ./gecode/minimodel.hh \ + ./gecode/minimodel/aliases.hpp ./gecode/minimodel/bool-expr.hpp ./gecode/minimodel/channel.hpp \ + ./gecode/minimodel/exception.hpp ./gecode/minimodel/float-expr.hpp ./gecode/minimodel/float-rel.hpp \ + ./gecode/minimodel/int-expr.hpp ./gecode/minimodel/int-rel.hpp ./gecode/minimodel/ipl.hpp \ + ./gecode/minimodel/ldsb.hpp ./gecode/minimodel/matrix.hpp ./gecode/minimodel/optimize.hpp \ + ./gecode/minimodel/reg.hpp ./gecode/minimodel/set-expr.hpp ./gecode/minimodel/set-rel.hpp \ + ./gecode/search/worker-control.hh gecode/int/min-distance$(OBJSUFFIX) gecode/int/min-distance$(SBJSUFFIX): \ ./gecode/int.hh ./gecode/int/open-var-list.hpp ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ diff --git a/changelog.in b/changelog.in index 05f6ffd211..b0e782aedd 100755 --- a/changelog.in +++ b/changelog.in @@ -84,8 +84,9 @@ through a factory. Constraints follow the growing prefix, including regular language constraints. Branching assigns prefix values before closing or extending the list, using standard variable and value selectors. Posting a brancher on the length first selects the length before list values. The -common-pattern example demonstrates constrained subsequence mining without -padding; open-route provides a smaller introduction. +common-pattern example demonstrates constrained frequent subsequence mining +without padding, with support thresholds and integer database input; +open-route provides a smaller introduction. [ENTRY] Module: kernel diff --git a/examples/common-pattern.cpp b/examples/common-pattern.cpp index f244e930e0..8672817900 100644 --- a/examples/common-pattern.cpp +++ b/examples/common-pattern.cpp @@ -32,174 +32,194 @@ */ #include -#include -#include -#include -#include -#include -#include +#include "common-pattern.hh" + +#include +#include using namespace Gecode; -/// Options for the input sequences and the pattern language +/// Sequence database and restrictions on the patterns to mine class CommonPatternOptions : public Options { protected: - /// Input sequences as a comma-separated command-line value - Driver::StringValueOption _sequences; - /// Whether the pattern must start with A and end with C + Driver::StringValueOption _sequences, _file, _support, _required; + Driver::StringOption _format, _language; + Driver::UnsignedIntOption _min_length; Driver::BoolOption _motif; - /// Validated input sequences - std::vector input; + std::unique_ptr input; + std::vector required_items; + int threshold; public: - /// Initialize the example options CommonPatternOptions(void) : Options("CommonPattern"), - _sequences("sequences","comma-separated nonempty sequences over A..Z", - "ABCBC,BABC,ABDC"), - _motif("motif","require the pattern to start with A and end with C",true) { - add(_sequences); - add(_motif); + _sequences("sequences","comma-separated sequences over A..Z","ABCBC,BABC,ABDC"), + _file("file","sequence database; one sequence per line",""), + _support("support","minimum supporting sequences, as a percentage","100"), + _required("required","items that must occur, comma-separated letters or IDs",""), + _format("format","database format",PatternMining::LETTERS), + _language("language","pattern language",PatternMining::DEFAULT), + _min_length("min-length","minimum pattern length",1), + _motif("motif","default language starts with A and ends with C",true), + threshold(0) { + _format.add(PatternMining::LETTERS,"letters"); + _format.add(PatternMining::INTEGERS,"integers"); + _format.add(PatternMining::SPMF,"spmf"); + _language.add(PatternMining::DEFAULT,"default","use -motif"); + _language.add(PatternMining::NONE,"none"); + _language.add(PatternMining::MOTIF,"motif"); + _language.add(PatternMining::RE10,"re10"); + _language.add(PatternMining::RE14,"re14"); + _language.add(PatternMining::RE2,"re2"); + add(_sequences); add(_file); add(_format); add(_support); + add(_min_length); add(_required); add(_language); add(_motif); } - /// Read and validate the input after parsing command-line options - bool read(void) { - const std::string text(_sequences.value()); - if (text.empty() || (text.back() == ',')) - return false; - std::istringstream stream(text); - std::string sequence; - while (std::getline(stream,sequence,',')) { - if (sequence.empty() || - (sequence.size() >= static_cast(Int::Limits::max)) || - (sequence.find_first_not_of("ABCDEFGHIJKLMNOPQRSTUVWXYZ") != - std::string::npos)) - return false; - input.push_back(sequence); + /// Validate external input before constructing a space + void read(void) { + if (_min_length.value() < 1 || _min_length.value() > Int::Limits::max) + throw std::invalid_argument("Minimum length must be a positive Gecode integer"); + PatternMining::Sequences sequences; + const std::string filename(_file.value()); + if (filename.empty()) { + if (_format.value() != PatternMining::LETTERS) + throw std::invalid_argument("Integer and SPMF formats require -file"); + const std::string text(_sequences.value()); + if (text.empty() || text.back() == ',') + throw std::invalid_argument("Expected comma-separated nonempty A..Z sequences"); + std::istringstream stream(text); + std::string sequence; + while (std::getline(stream,sequence,',')) + sequences.push_back(PatternMining::read_sequence(sequence,PatternMining::LETTERS)); + } else { + std::ifstream stream(filename); + sequences = PatternMining::read_database(stream, + static_cast(_format.value())); } - return true; - } - - /// Return the input sequences - const std::vector& sequences(void) const { return input; } - /// Whether to impose the pattern language - bool motif(void) const { return _motif.value(); } -}; - -namespace { - - /** - * \brief Automaton accepting all subsequences of \a text - * - * State i means that the next match must occur at or after position i. - * Matching the earliest occurrence of a symbol leaves every later match - * available. All states accept, including the state after the final item. - */ - DFA - subsequences(const std::string& text) { - const int n = static_cast(text.size()); - int next[26]; - std::fill(next,next+26,-1); - std::vector transitions; - for (int i=n; i--; ) { - next[text[i]-'A'] = i+1; - for (int a=0; a<26; a++) - if (next[a] >= 0) - transitions.emplace_back(i,'A'+a,next[a]); + input.reset(new PatternMining::Database(sequences)); + threshold = PatternMining::minimum_support(_support.value(),input->ends.size()); + const std::string items(_required.value()); + if (!items.empty()) { + if (items.back() == ',') + throw std::invalid_argument("Empty required item"); + std::istringstream stream(items); + std::string item; + while (std::getline(stream,item,',')) { + const std::vector parsed = PatternMining::read_sequence(item, + letters() ? PatternMining::LETTERS : PatternMining::INTEGERS); + if (parsed.size() != 1) + throw std::invalid_argument("Required items must be single letters or IDs"); + required_items.push_back(parsed[0]); + } } - transitions.emplace_back(-1,0,0); - std::vector finals(n+2); - for (int i=0; i<=n; i++) - finals[i] = i; - finals[n+1] = -1; - return DFA(0,transitions.data(),finals.data()); } -} + const PatternMining::Database& database(void) const { return *input; } + const std::vector& required(void) const { return required_items; } + int support(void) const { return threshold; } + int min_length(void) const { return static_cast(_min_length.value()); } + bool letters(void) const { return _format.value() == PatternMining::LETTERS; } + PatternMining::Language language(void) const { + if (_language.value() == PatternMining::DEFAULT) + return _motif.value() ? PatternMining::MOTIF : PatternMining::NONE; + return static_cast(_language.value()); + } +}; /** - * \brief %Example: constrained common subsequences of unknown length + * \brief %Example: constrained frequent subsequences of unknown length + * + * A pattern must occur in at least -support percent of the input sequences. + * Matching preserves order and may skip items; repeated items match distinct + * positions. Support counts records, including duplicate records, once each. + * By default the inputs ABCBC, BABC, ABDC must all support the pattern, which + * must start with A and end with C. AC and ABC are feasible; ABC is longest. * - * Find a longest nonempty pattern occurring as a subsequence of every input. - * Matching preserves order but may skip input items. By default the pattern - * must also start with A and end with C. The inputs ABCBC, BABC, and ABDC have - * two such patterns, AC and ABC, with ABC the unique longest one. + * The decision is an ordered list of items with unknown length. The frequency + * constraint requires sufficiently many records to contain that list as a + * subsequence. Ordinary length and regular constraints restrict the pattern: + * they do not restrict the matching positions in the input records. Default + * DFS enumerates every qualifying pattern; -search bab finds a longest one. + * These are different queries from closed, maximal, or top-k frequent mining. * - * This is the all-input-support case of constrained sequential pattern mining. + * An OpenIntVarList constructs pattern positions as needed, without an end + * marker or unused suffix variables. Pattern languages therefore describe + * just the pattern, without padding transitions. The private frequency + * constraint maintains supporting suffixes after the assigned prefix and + * removes items with insufficient support. This prefix projection follows * Kemmar et al., "PREFIX-PROJECTION Global Constraint for Sequential Pattern - * Mining", CP 2015, doi:10.1007/978-3-319-23219-5_17, model varying pattern - * lengths with a fixed array and a special termination item. An OpenIntVarList - * instead contains only actual pattern positions: no padding symbol, suffix - * implications, or padding transitions in the pattern-language automaton. - * The shortest input bounds the length, but does not allocate that many - * decision variables. Constraints posted once follow the growing list. + * Mining", CP 2015, doi:10.1007/978-3-319-23219-5_17, with an additional + * remaining-suffix length bound. Projection is a filtering method, independent + * of the pattern's length, item and language restrictions. OpenRoute is the + * simpler introduction to open lists. * - * Each input is represented by a subsequence DFA. This keeps the example in - * the modelling API; it does not implement the paper's shared prefix-projection - * propagator or arbitrary minimum-support thresholds. Automata still require - * storage for the inputs, and lazy variables alone do not guarantee faster - * search. OpenRoute provides a smaller introduction to open lists. + * The paper's Table 1 can be mined with: + * -sequences ABCBC,BABC,AB,BCD -support 50 -language none. + * -min-length and -required constrain length and item membership. -language + * also accepts motif (A, any items, C), re10, re14, re2 (comparison presets + * from the paper). Their letters mean item IDs A=1 through Z=26; integer data + * must use the corresponding mapping for these named expressions. * - * Run with -search dfs to enumerate all feasible patterns, -motif false to - * remove the pattern-language restriction, or -sequences ABCBC,BABC,ABDC to - * supply input sequences. Default branch-and-bound search maximizes length. - * For example, -search dfs -motif false enumerates seven patterns on the - * default input: A, B, C, AB, AC, BC, and ABC. + * -file reads one sequence per line in -format letters, integers, or spmf. + * Integer IDs are positive and preserved in output. SPMF records must have + * singleton itemsets: "1 -1 2 -1 3 -1 -2" is the sequence ABC. Multi-item + * itemsets are rejected because they define a different mining problem. + * No gap or time restrictions are supported. The comparison runner in + * misc/common-pattern/README.md uses identical mining queries across models. * * \ingroup Example */ class CommonPattern : public IntMaximizeScript { protected: - /// Items of the pattern, materialized as required by propagation and search OpenIntVarList pattern; + PatternMining::Database database; + bool letters; public: - /// Search engines enum { SEARCH_BAB, SEARCH_DFS }; - /// Construct the model CommonPattern(const CommonPatternOptions& opt) - : IntMaximizeScript(opt) { - int bound = Int::Limits::max; - for (const std::string& sequence : opt.sequences()) - bound = std::min(bound,static_cast(sequence.size())); - pattern = OpenIntVarList(*this,IntSet('A','Z'),bound); - rel(*this,pattern.length(),IRT_GQ,1); - - for (const std::string& sequence : opt.sequences()) - extensional(*this,pattern,subsequences(sequence)); - if (opt.motif()) { - REG alphabet(IntArgs::create(26,'A',1)); - extensional(*this,pattern,REG('A') + *alphabet + REG('C')); - } - - // Assign the current prefix, then close it or add another item. + : IntMaximizeScript(opt), database(opt.database()), letters(opt.letters()) { + pattern = OpenIntVarList(*this,database.domain(),database.max_length()); + rel(*this,pattern.length(),IRT_GQ,opt.min_length()); + PatternMining::frequent(*this,pattern,database,opt.support()); + if (opt.language() != PatternMining::NONE) + extensional(*this,pattern,PatternMining::language(opt.language(),database)); + REG alphabet(IntArgs(database.alphabet)); + for (int item : opt.required()) + extensional(*this,pattern,*alphabet + REG(item) + *alphabet); branch(*this,pattern,INT_VAR_NONE(),INT_VAL_MIN()); } - /// Maximize the eventual pattern length - virtual IntVar cost(void) const { - return pattern.length(); - } + virtual IntVar cost(void) const { return pattern.length(); } - /// Constructor for cloning \a s - CommonPattern(CommonPattern& s) : IntMaximizeScript(s) { + CommonPattern(CommonPattern& s) + : IntMaximizeScript(s), database(s.database), letters(s.letters) { pattern.update(*this,s.pattern); } - /// Copy during cloning - virtual Space* copy(void) { - return new CommonPattern(*this); - } + virtual Space* copy(void) { return new CommonPattern(*this); } - /// Print the current prefix (complete in a solution) virtual void print(std::ostream& os) const { + std::vector items; os << "\t"; - for (int i=0; i(pattern[i].val()); - else + for (int i=0; i('A'+item-1); + else + os << item; + } else { os << pattern[i]; - os << " (length " << pattern.length() << ")" << std::endl; + } + } + os << " (length " << pattern.length(); + if (static_cast(items.size()) == pattern.prefix_size()) + os << ", support " << database.support(items) << '/' << database.ends.size(); + os << ")" << std::endl; } }; @@ -210,13 +230,14 @@ int main(int argc, char* argv[]) { CommonPatternOptions opt; opt.solutions(0); - opt.search(CommonPattern::SEARCH_BAB); + opt.search(CommonPattern::SEARCH_DFS); opt.search(CommonPattern::SEARCH_BAB,"bab","find a longest pattern"); - opt.search(CommonPattern::SEARCH_DFS,"dfs","enumerate feasible patterns"); + opt.search(CommonPattern::SEARCH_DFS,"dfs","enumerate frequent patterns"); opt.parse(argc,argv); - if (!opt.read()) { - std::cerr << "Expected comma-separated nonempty sequences over A..Z" - << std::endl; + try { + opt.read(); + } catch (const std::invalid_argument& error) { + std::cerr << error.what() << std::endl; return 1; } if (opt.search() == CommonPattern::SEARCH_DFS) diff --git a/examples/common-pattern.hh b/examples/common-pattern.hh new file mode 100644 index 0000000000..2c942af884 --- /dev/null +++ b/examples/common-pattern.hh @@ -0,0 +1,391 @@ +/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */ +/* + * Private modelling support for the common-pattern example and its comparison. + * Copyright Mikael Zayenz Lagerkvist, 2026. + * Distributed under the MIT license; see LICENSE. + */ + +#ifndef GECODE_EXAMPLES_COMMON_PATTERN_HH +#define GECODE_EXAMPLES_COMMON_PATTERN_HH + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace PatternMining { + + using namespace Gecode; + typedef std::vector> Sequences; + + enum Format { LETTERS, INTEGERS, SPMF }; + enum Language { DEFAULT, NONE, MOTIF, RE10, RE14, RE2 }; + + /// Read positive integer items or A..Z (represented by item IDs 1..26) + inline std::vector + read_sequence(const std::string& line, Format format) { + std::vector sequence; + if (format == LETTERS) { + for (char a : line) { + if ((a < 'A') || (a > 'Z')) + throw std::invalid_argument("Letter sequences must contain A..Z only"); + sequence.push_back(a-'A'+1); + } + } else { + std::istringstream stream(line); + std::string token; + bool open_itemset = false, ended = false; + while (stream >> token) { + int item; + const auto parsed = std::from_chars(token.data(),token.data()+token.size(),item); + if ((parsed.ec != std::errc()) || (parsed.ptr != token.data()+token.size())) + throw std::invalid_argument("Invalid integer item"); + if (ended) + throw std::invalid_argument("Items after SPMF sequence end"); + if ((format == SPMF) && (item == -1)) { + if (!open_itemset) + throw std::invalid_argument("Empty SPMF itemset"); + open_itemset = false; + } else if ((format == SPMF) && (item == -2)) { + if (open_itemset) + throw std::invalid_argument("Missing SPMF itemset end"); + ended = true; + } else { + if ((item <= 0) || (item > Int::Limits::max) || + ((format == SPMF) && open_itemset)) + throw std::invalid_argument("Expected positive items; SPMF itemsets must be singletons"); + sequence.push_back(item); + open_itemset = true; + } + } + if (!stream.eof() || ((format == SPMF) && !ended)) + throw std::invalid_argument("Invalid sequence or missing SPMF sequence end"); + } + if (sequence.empty()) + throw std::invalid_argument("Empty sequence"); + return sequence; + } + + /// Read one sequence per line, retaining duplicate rows as distinct records + inline Sequences + read_database(std::istream& stream, Format format) { + Sequences input; + std::string line; + while (std::getline(stream,line)) { + if (!line.empty() && (line.back() == '\r')) + line.pop_back(); + if (line.empty() || ((format == SPMF) && + ((line[0] == '#') || (line[0] == '%') || (line[0] == '@')))) + continue; + input.push_back(read_sequence(line,format)); + } + if (!stream.eof() || input.empty()) + throw std::invalid_argument("Cannot read a nonempty sequence database"); + return input; + } + + /// Convert a percentage with at most six decimals to an exact sequence count + inline int + minimum_support(const std::string& percent, int sequences) { + unsigned long long numerator = 0, scale = 1; + bool decimal = false, digit = false; + for (char c : percent) { + if ((c == '.') && !decimal) { + decimal = true; + } else if ((c >= '0') && (c <= '9')) { + digit = true; + numerator = numerator*10 + (c-'0'); + if (decimal) + scale *= 10; + if ((numerator > 100000000ULL) || (scale > 1000000ULL)) + throw std::invalid_argument("Support needs at most six decimals"); + } else { + throw std::invalid_argument("Support must be a percentage in (0,100]"); + } + } + if (!digit || (numerator == 0) || (numerator > 100*scale)) + throw std::invalid_argument("Support must be a percentage in (0,100]"); + const unsigned long long denominator = 100*scale; + return static_cast((sequences*numerator+denominator-1)/denominator); + } + + /// Immutable input, with dense ranks internally and original IDs externally + class Database { + public: + IntSharedArray items, ends, alphabet; + + explicit Database(const Sequences& input) { + if (input.empty()) + throw std::invalid_argument("Empty database"); + std::vector symbols; + for (const std::vector& sequence : input) { + if (sequence.empty() || + (sequence.size() >= static_cast(Int::Limits::max)-symbols.size())) + throw std::invalid_argument("Empty sequence or database too large"); + for (int item : sequence) { + if ((item <= 0) || (item > Int::Limits::max)) + throw std::invalid_argument("Item IDs must be positive Gecode integers"); + symbols.push_back(item); + } + } + items.init(static_cast(symbols.size())); + std::sort(symbols.begin(),symbols.end()); + symbols.erase(std::unique(symbols.begin(),symbols.end()),symbols.end()); + alphabet.init(static_cast(symbols.size())); + std::copy(symbols.begin(),symbols.end(),alphabet.begin()); + ends.init(static_cast(input.size())); + int k = 0, i = 0; + for (const std::vector& sequence : input) { + for (int item : sequence) + items[k++] = static_cast(std::lower_bound( + symbols.begin(),symbols.end(),item)-symbols.begin()); + ends[i++] = k; + } + } + + IntSet domain(void) const { return IntSet(alphabet.begin(),alphabet.size()); } + + int max_length(void) const { + int bound = 0, start = 0; + for (int end : ends) { + bound = std::max(bound,end-start); + start = end; + } + return bound; + } + + /// Count supporting records, rather than embeddings within a record + int support(const std::vector& pattern) const { + int count = 0, start = 0; + for (int end : ends) { + size_t matched = 0; + for (int i=start; (i(data.ends.size())) { + for (int i=0; i(data.ends.size())) { + std::copy(p.cursor,p.cursor+data.ends.size(),cursor); + } + + /// Advance supporting records past the earliest occurrence of an item + bool advance(int item) { + const int rank = static_cast(std::lower_bound( + data.alphabet.begin(),data.alphabet.end(),item)-data.alphabet.begin()); + if ((rank == data.alphabet.size()) || (data.alphabet[rank] != item)) + return false; + int count = 0; + for (int i=0; i= threshold; + } + + /// Locally frequent items, counting each item once per supporting record + IntSet frequent(Region& region, bool termination) const { + const int d = data.alphabet.size(); + int* count = region.alloc(d); + int* seen = region.alloc(d); + std::fill(count,count+d,0); + std::fill(seen,seen+d,-1); + for (int i=0; i(d+1); + int n = 0; + if (termination) + values[n++] = 0; + for (int a=0; a= threshold) + values[n++] = data.alphabet[a]; + return IntSet(values,n); + } + + /// The threshold-th largest suffix length bounds every frequent extension + int remaining(Region& region) const { + int* sizes = region.alloc(data.ends.size()); + int n = 0; + for (int i=0; i= 0) + sizes[n++] = data.ends[i]-cursor[i]; + std::nth_element(sizes,sizes+threshold-1,sizes+n,std::greater()); + return sizes[threshold-1]; + } + }; + + /** + * \brief Private prefix projection for a growing list + * + * Adapts CP2015 Algorithms 1--2: no termination item, future variables or + * per-input DFA. Unconstructed positions are filtered when they appear. + * Earliest matching is sound for ordinary subsequences, not gap constraints. + */ + class OpenProjection : public Propagator { + protected: + OpenIntVarList list; + Int::IntView length; + Projection projection; + int consumed, subscribed; + + OpenProjection(Space& home, OpenIntVarList pattern, + const Database& database, int support) + : Propagator(home), list(pattern), length(pattern.length()), + projection(home,database,support), consumed(0), + subscribed(pattern.prefix_size()) { + home.notice(*this,AP_DISPOSE); + list.subscribe(home,*this); + length.subscribe(home,*this,Int::PC_INT_BND); + for (int i=0; i database.ends.size())) { + home.fail(); + return; + } + (void) new (home) OpenProjection(home,pattern,database,support); + } + }; + + /// Require at least support records to contain the pattern as a subsequence + inline void + frequent(Home home, OpenIntVarList pattern, + const Database& database, int support) { + OpenProjection::post(home,pattern,database,support); + } + + /// Pattern languages from the example and CP2015 Section 5(d) + inline REG + language(Language name, const Database& database) { + REG alphabet(IntArgs(database.alphabet.size(),database.alphabet.begin())); + if (name == MOTIF) + return REG(1) + *alphabet + REG(3); + if (name == RE10) + return *REG(1) + REG(2) + (REG(2) | REG(3)) + *REG(4) + + REG(5) + *REG(6) + (REG(7) | REG(8)) + *REG(9); + if (name == RE14) + return *REG(1) + (REG(17) | (REG(2) + *REG(19) + + (REG(2) | REG(3)))) + *REG(4) + REG(5) + *(REG(9) | REG(19)) + + (REG(6) | REG(8)) + *REG(7) + REG(18); + return (REG(19) | REG(20)) + alphabet + (REG(18) | REG(11)); + } + +} + +#endif diff --git a/gecode/int.hh b/gecode/int.hh index 788aae47f3..164895484d 100755 --- a/gecode/int.hh +++ b/gecode/int.hh @@ -2468,10 +2468,10 @@ namespace Gecode { * \endcode * * The \ref CommonPattern "common-pattern example" finds constrained - * subsequences shared by several inputs. The pattern length is a decision; + * frequent subsequences across several inputs. The pattern length is a decision; * the open list avoids allocating an array up to the input-length bound - * and encoding an unused suffix with a termination symbol. Regular - * constraints on both the inputs and the pattern language follow growth. + * and encoding an unused suffix with a termination symbol. Shared prefix + * projection and regular constraints on the pattern language follow growth. * The \ref OpenRoute "open-route example" is a smaller introduction, * including search and printing solutions. * diff --git a/misc/common-pattern/README.md b/misc/common-pattern/README.md index 0a673e5a62..939ddd579d 100644 --- a/misc/common-pattern/README.md +++ b/misc/common-pattern/README.md @@ -1,76 +1,138 @@ -# Common-pattern comparisons +# Common-pattern mining and comparisons -This compares the `common-pattern.cpp` model with the positional encoding and -prefix filtering in Kemmar et al., +`examples/common-pattern.cpp` mines frequent ordered subsequences, with optional +constraints on their length, items and language. Its decision variable is a list +of items of unknown length. DFS enumerates all qualifying patterns; BAB finds a +maximum-length qualifying pattern. + +## The mining model + +For a database of records `D`, a record supports pattern `P` when there are strictly +increasing positions in that record matching every item of `P`. Matching may skip +items. Each supporting record contributes one unit, regardless of how many +embeddings it contains; duplicate rows are distinct records. The frequency +constraint is `support(P) >= ceil(percent * |D| / 100)`. + +This separates three familiar CP decisions: + +- **Variables:** the pattern items and their length, bounded by the longest input. +- **Constraints:** sufficient support, minimum length, required items, and a pattern language. +- **Search:** left-to-right item choices, deciding at each prefix whether to close or extend. + +The constructor expresses those constraints directly: + +```cpp +pattern = OpenIntVarList(*this,database.domain(),database.max_length()); +rel(*this,pattern.length(),IRT_GQ,opt.min_length()); +PatternMining::frequent(*this,pattern,database,opt.support()); +if (opt.language() != PatternMining::NONE) + extensional(*this,pattern,PatternMining::language(opt.language(),database)); +REG alphabet(IntArgs(database.alphabet)); +for (int item : opt.required()) + extensional(*this,pattern,*alphabet + REG(item) + *alphabet); +branch(*this,pattern,INT_VAR_NONE(),INT_VAL_MIN()); +``` + +`frequent` is private example support, not a new Gecode library constraint. +Length, membership and regular constraints apply to the **pattern**. They do not +constrain which input positions match it. This follows the distinction between +pattern, cover, embedding and output constraints in Negrevergne and Guns, +[Constraint-based sequence mining using constraint programming](https://arxiv.org/abs/1501.01178), +CPAIOR 2015. All frequent patterns, a longest pattern, closed patterns (no proper +supersequence with the same support), maximal frequent patterns (no proper +frequent supersequence), and top-k by support are different output queries. This +example implements the first two. + +## Why use an open list? + +The pattern's actual length is unknown. An `OpenIntVarList` constructs its +positions as needed, avoiding an end marker, unused suffix variables, and padding +transitions in additional pattern languages. Constraints follow growth; when no +frequent extension remains, the list closes. `open-route` is the smaller +introduction to construction, cloning and search. + +The private frequency propagator uses prefix projection: after assigning an item, +it retains the input suffixes that can extend the current pattern. One earliest +matching cursor per supporting record suffices for ordinary subsequences. It +filters locally infrequent items from constructed positions and bounds further +growth by the remaining supporting suffix lengths. Immutable, rank-compressed +data are shared between spaces; each space owns its cursors. Sparse integer IDs +are preserved in output. + +This adapts Kemmar et al., [PREFIX-PROJECTION Global Constraint for Sequential Pattern Mining](https://loudni.users.greyc.fr/Papers/cp15final.pdf), -CP 2015, DOI [10.1007/978-3-319-23219-5_17](https://doi.org/10.1007/978-3-319-23219-5_17). +CP 2015, DOI [10.1007/978-3-319-23219-5_17](https://doi.org/10.1007/978-3-319-23219-5_17), +which uses a fixed positional array and termination value. The open representation +also addresses a cost identified in Aoga, Guns and Schaus, +[An Efficient Algorithm for Mining Frequent Sequence with Constraint Programming](https://arxiv.org/abs/1604.01166), +ECML PKDD 2016, §4.2: filtering and restoring future array positions that the search +may never use. Their implementation filters only the next position and optimizes +suffix scans and state restoration. The example does not reproduce those +optimizations or establish a speedup; the comparisons below distinguish variable +representation from filtering strength. -The comparison asks how open-list DFA propagation behaves relative to a padded -array using DFAs and a padded array using the paper's Algorithm 2. It measures -complete enumeration of **nonempty patterns present in every input sequence**: -100% support, with each sequence counted once regardless of how many embeddings -it contains. Matching repeated symbols consumes distinct input positions. +The input scope is sequences of **individual items**, not sequences of itemsets. +Gap, span, timestamps and event attributes are outside the model. Earliest matching +alone would not suffice with embedding restrictions: in `AXBAB`, an adjacent `AB` +exists at the end although matching the first `A` cannot find it adjacently. -## Models +## Use the example -| Variant | Representation | Subsequence filtering | -| --- | --- | --- | -| `open-dfa` | `OpenIntVarList`, following the example | One open regular constraint per input | -| `padded-dfa` | Fixed `IntVarArray`, zero termination | One ordinary regular constraint per input; zeroes only at the end | -| `paper-projection` | Fixed `IntVarArray`, zero termination | Reimplementation of Algorithm 2, specialized to 100% support | - -The projection model maintains one earliest-match cursor per input and intersects -the items available in their remaining suffixes. It removes unavailable items -from every remaining pattern position. Empty suffixes still support the current -prefix and allow termination. The database is immutable and shared; the current -projection is copied with each space. Parent spaces and recomputation supply the -projection history instead of an explicit stack inside the propagator. There is -no general minimum-support or gap constraint added to Gecode. - -All variants initialize item domains from the actual database alphabet, following -the paper's Section 4.1. The example's A..Z domains give the same open DFA model -after initial propagation. All variants use ascending, left-to-right item -decisions and single-threaded DFS. -The open brancher interleaves closure and growth; the fixed branchers select zero -before another item. Propagation can nevertheless produce different trees. The -ordinary and open regular implementations also differ, so an open/padded timing -ratio does not isolate variable allocation cost alone. Nodes and propagation -calls measure different work across these implementations. - -## Relationship to the paper - -The paper's Section 5 enumerates all patterns, uses the longest input as its -positional bound, varies support thresholds, and reports CPU seconds on an Intel -Xeon X5670 with 24 GB RAM and a one-hour limit. This runner defaults to that -length-bound convention. `--bound shortest` gives all variants the tighter bound -used by the common-pattern example; it preserves solutions at 100% support. - -Built-in cases include Table 1's exact four-sequence database, the example's -database, repeated items, disjoint alphabets, increasing input counts, increasing -input lengths, and increasing common-pattern lengths. Scaling databases are -seeded, planted-pattern workloads. They are **not** the paper's `data-200K` -generator or its other evaluation datasets. Restrictions include the example's -motif and Section 5(d)'s exact RE10, RE14 and RE2 expressions. - -This is an algorithm and representation comparison, **not a reproduction of -Tables 3–4 or the published timing curves**. The paper's project link, -, redirected to Google -sign-in when checked on 2026-10-13. The authors' implementation and dataset -bundle could not be retrieved. `paper-projection` must not be labelled as their -binary. BAB longest-pattern search is excluded because the paper enumerates -all patterns. Runtime ratios against its historical seconds would be misleading. - -Reproducing the complete published experiment would require the original data -and implementation, arbitrary support thresholds in the compared model, and -integer-item input beyond this example's A..Z alphabet. Alphabet truncation, -sampling sequences, or using 100% support would change that experiment. Custom -A..Z databases can be compared here without changing the example's modelling API. +With no arguments, the example enumerates `AC` and `ABC` from `ABCBC,BABC,ABDC`, +requiring all records and the language `A.*C`. The paper's Table 1, with minimum +support two out of four records and no language restriction, is: + +```sh +build/common-pattern-benchmark/bin/common-pattern \ + -sequences ABCBC,BABC,AB,BCD -support 50 -language none -search dfs +``` + +It enumerates nine patterns, including `AC` with support 2/4. Use `-search bab` +for a longest pattern, `-min-length 3` for a length restriction, and `-required A,C` +to require both items. Support is a percentage in `(0,100]` with up to six decimal +places; the threshold is the exact ceiling of that fraction of the record count. + +`-language` accepts `none`, `motif`, `re10`, `re14`, or `re2`. The last three are +Section 5(d)'s expressions, retained as comparison presets. Explicit `-language` +overrides `-motif`; the default language uses `-motif` (enabled by default). Letters mean item IDs `A=1` through +`Z=26`. Named expressions on integer data require that same mapping; the parser +does not infer or remap dataset labels. The motif's interior and RE2's middle +position accept any item in the input alphabet. + +| Language | Accepted pattern | +| --- | --- | +| `none` | Any nonempty sequence over the input alphabet | +| `motif` | `A.*C` | +| `re10` | `A*B(B\|C)D*EF*(G\|H)I*` | +| `re14` | `A*(Q\|BS*(B\|C))D*E(I\|S)*(F\|H)G*R` | +| `re2` | `(S\|T).(R\|K)` | + +Here juxtaposition means concatenation, `|` means alternative, `*` means zero or +more repetitions, and `.` means one item from the actual input alphabet. + +For larger databases use `-file` and select a format: + +- `-format letters`: one nonempty A..Z string per line. +- `-format integers`: one sequence of positive integer IDs per line, separated by spaces. +- `-format spmf`: singleton itemsets separated by `-1`, with `-2` ending each sequence. + For example, `1 -1 2 -1 3 -1 -2` represents ABC. SPMF metadata/comment lines + beginning with `@`, `#`, or `%` are skipped. Multi-item itemsets are rejected; + silently flattening them would change the mining problem. + +Empty lines are skipped. Every retained row has its own support identity. Required +items use comma-separated letters in letter mode and integer IDs otherwise: + +```sh +build/common-pattern-benchmark/bin/common-pattern \ + -file /absolute/path/database.txt -format spmf \ + -support 1 -min-length 3 -required 1001,2002 -language none -search dfs +``` ## Build -Run these commands from the repository root. The benchmark is compiled separately -against the normal Gecode libraries; no CMake targets or test infrastructure are -added. The commands work with the shared-library build on macOS and Linux. +Run from the repository root. The companion is compiled against the normal Gecode +libraries; it adds no CMake targets. Regression tests use the existing Gecode test +harness in `test/int/open-var-list.cpp`. ```sh cmake -S . -B build/common-pattern-benchmark -G Ninja \ @@ -87,74 +149,133 @@ c++ -std=c++17 -O3 -DNDEBUG \ -o build/common-pattern-benchmark/bin/common-pattern-compare ``` -Use the same compiler and optimized build for all variants. Keep the executable -in `BUILD/bin/` and its Gecode libraries in `BUILD/`; the runner fingerprints -that layout's libraries to reject resume after a changed build. Rebuild the -companion after editing its source. `--build-label` records compiler and flags; -it does not check that the supplied label describes the build accurately. +Use the same compiler and compatible build settings, including macOS deployment +targets, for the libraries and companion. Keep the executable in `BUILD/bin/` +and libraries in `BUILD/`; that layout is fingerprinted for resume. Rebuild the +companion after changing its source or private header. The build label records +compiler and flags but does not verify them automatically. -## Collect and analyze +## Compare equivalent mining queries + +| Variant | Pattern representation | Filtering | +| --- | --- | --- | +| `open-projection` | `OpenIntVarList` | Local item support and remaining-suffix length bound, including initial filtering | +| `padded-projection` | Fixed array, zero termination | Same extra pruning, applied to all preallocated positions | +| `paper-projection` | Fixed array, zero termination | Algorithms 1–2 reimplementation, without added initial scheduling or suffix-length pruning | +| `open-dfa`, `padded-dfa` | Open list or padded array | Per-input subsequence DFAs; require all-input support | + +The first two variants help assess the representation using the same extra pruning. +Their regular constraints still propagate differently because the open constraint +sees constructed positions and the ordinary constraint sees the entire array. +The paper variant distinguishes the effect of additional pruning. Nodes and +propagation calls represent different amounts of work across implementations. +All variants use single-threaded DFS, ascending left-to-right item decisions, +and exhaustive enumeration; BAB is excluded from mining comparisons. + +The default smoke matrix covers six workloads at 100%, 50%, and 25% support, +with three projection variants and five repetitions: 54 correctness invocations +followed by 270 measured invocations, serially, each with a 30-second timeout. +These small inputs exercise loss of support, repeated items and disjoint records. ```sh uv run --script misc/common-pattern/benchmark.py run \ - --name release-max --binary build/common-pattern-benchmark/bin/common-pattern-compare \ - --build-label 'AppleClang 21; Release; -O3 -DNDEBUG' --dry-run + --name frequency --binary build/common-pattern-benchmark/bin/common-pattern-compare \ + --build-label 'your compiler; Release; -O3 -DNDEBUG' --dry-run uv run --script misc/common-pattern/benchmark.py run \ - --name release-max --binary build/common-pattern-benchmark/bin/common-pattern-compare \ - --build-label 'AppleClang 21; Release; -O3 -DNDEBUG' -uv run --script misc/common-pattern/benchmark.py analyze --name release-max + --name frequency --binary build/common-pattern-benchmark/bin/common-pattern-compare \ + --build-label 'your compiler; Release; -O3 -DNDEBUG' +uv run --script misc/common-pattern/benchmark.py analyze --name frequency ``` -The default scaling suite has 24 cases, three variants and five repetitions: -72 correctness invocations followed by 360 measured invocations, serially, with -a 30-second timeout per invocation. Use `--suite smoke --repetitions 2` for a -small check. `--limit N` bounds the number of new measured samples collected in -one call; correctness runs still precede measurement. Repeat the same command -to resume. Use a new name when changing the bound, seed, inputs, timeout, build, -or repetition plan. Only one process should write a named run at a time. - -Before timing, every variant prints its patterns for validation. The runner -rejects duplicate, infeasible or language-invalid patterns and requires identical -solution sets across all variants. It independently enumerates subsequences of -the shortest input when its length is at most 16, checking completeness as well. -Every built-in case meets that oracle bound. Larger custom inputs get feasibility -and cross-implementation checks; completeness is not independently established. - -Measured invocations count solutions without printing them. The target timer -includes model and DFA construction, DFS construction, complete enumeration and -solution disposal; it excludes input parsing, process startup and final engine -destruction. End-to-end wall seconds include these costs and input I/O. Validation -invocations warm filesystem/library caches but are excluded from timing. Variant -and repetition order is shuffled with the saved seed; there is no concurrent -measurement or CPU pinning. Very small timings are useful for exercising the -runner, not for deciding a performance ranking. - -The named directory under `build/common-pattern-results/` contains configuration, -generated inputs, validation evidence, individual sample JSON, and stdout/stderr. -Completed records are replaced atomically and remain unchanged on resume. Missing -or malformed records are unfinished and rerun; partial output for that unfinished -invocation is replaced. Errors, invalid output and timeouts are terminal records -retained on resume, with a nonzero collection exit status. A new run name retries -them without selecting away failures. Analysis does not execute the target and -reports completed, failed and unfinished samples, with median and range in -seconds. Timed-out work is excluded from successful timing summaries, never -assigned the timeout value as a runtime. Keep host conditions comparable when -resuming across sessions. - -For an existing database, provide one nonempty A..Z sequence per line: +`--suite scaling --support 100` adds database-count, input-length, pattern-length, +and the paper's regex workloads. Lower support on long inputs can produce very +large outputs; start with a bounded query. For a real database, use the same +formats as the example: ```sh uv run --script misc/common-pattern/benchmark.py run \ - --name custom --binary build/common-pattern-benchmark/bin/common-pattern-compare \ - --build-label 'your compiler and optimized flags' \ - --database /absolute/path/sequences.txt --language re10 + --name database --binary build/common-pattern-benchmark/bin/common-pattern-compare \ + --build-label 'your compiler; Release; -O3 -DNDEBUG' \ + --database /absolute/path/database.txt --format spmf \ + --support 5 2 1 --min-length 3 --required 1001 2002 --language none ``` -Raw timings and generated data stay in the ignored build tree. A comparison -report should name the database, support, restriction, length bound, build, -machine and timing boundary, and retain completion counts beside any timing ratio. +`--bound max` follows the paper's longest-record bound. `--bound shortest` and +DFA variants are valid only when the computed support count requires every record. +Select DFAs explicitly with `--support 100 --variants open-dfa padded-dfa +open-projection padded-projection paper-projection`. The default companion +invocation from the previous comparison remains valid. + +Before timing, the runner checks duplicate output, item/length/language constraints, +and actual record support. All variants must enumerate exactly the same set. +An independent oracle enumerates subsequences of the `n-k+1` shortest records: +every pattern supported by `k` out of `n` records occurs in at least one of those +records. The oracle runs when each chosen record has at most 16 items and their +combined subset budget is at most 200,000. Otherwise feasibility and agreement are +checked, with independent completeness explicitly unavailable. The smoke matrix +meets the oracle budget at every threshold. -## Bounded first comparison +Measured runs count solutions without printing. The target timer includes rank +compression, model construction, complete DFS and solution disposal; it excludes +file parsing, startup and final engine destruction. End-to-end wall time includes +those costs. Validation runs warm caches and are excluded from timing. Ordering +is shuffled with the saved seed. Small timings should not determine a performance +ranking. The example driver's runtime excludes database import; it is a separate +metric from the companion's model-plus-search timer. + +Named results live under `build/common-pattern-results/`, with configuration, +normalized integer input, validation evidence, raw samples and stdout/stderr. +One writer per run; collection resumes unchanged terminal records. `--limit N` +bounds new timed invocations, while correctness runs still precede measurement. +Changed inputs, queries, build, helper, runner, timeout or repetition plan require +another name. Missing/malformed records are rerun and their partial logs replaced. +Errors, invalid output and timeouts remain terminal evidence and cause a nonzero +collection exit. Analysis invokes no targets, retains older format-1 results, and +reports failures/unfinished work beside successful medians and ranges in seconds. + +The authors' project link +required Google sign-in when checked on 2026-10-13. These baselines are +reimplementations, not their executable. Real dataset versions and label mappings +still need checking before comparison with published pattern counts. Historical +CPU seconds on the paper's Xeon X5670 are not a runtime baseline for this machine. + +## Literature and comparison scope + +Backward citation tracing from CP2015 identifies projected pattern growth, +vertical occurrence lists, CP embedding models, and regular-language restrictions. +Projection is one way to calculate support, not the definition of the problem. +The following primary sources give useful alternative views: + +| Work | Relationship and relevance | +| --- | --- | +| Pei et al., [PrefixSpan](https://hanj.cs.illinois.edu/pdf/span01.pdf), ICDE 2001 | Cited by CP2015; prefix-projected pattern growth predates its CP global. The original also handles sequences of itemsets. | +| Zaki, [SPADE](https://www.cs.rpi.edu/~zaki/PaperDir/MLJ01.pdf), Machine Learning 2001 | Cited by CP2015; temporal joins of vertical occurrence lists provide a different support computation. | +| Negrevergne and Guns, [CP sequence mining](https://arxiv.org/abs/1501.01178), CPAIOR 2015 | Cited and compared by CP2015; distinguishes a global existence-of-embedding constraint from an explicit embedding formulation. Our DFA baseline is neither formulation. | +| Aoga, Guns and Schaus, [efficient CP sequence mining](https://arxiv.org/abs/1604.01166), ECML PKDD 2016 | Cites CP2015; improves projection, future-position filtering and restoration. Motivates measuring these costs separately. | +| Kemmar et al., [prefix projection and top-k](https://loudni.users.greyc.fr/Papers/Cons17final.pdf), Constraints 2017 | Extends the CP2015 line with a separate top-k query. Maximum length is not top-k by support. | +| Hosseininasab, van Hoeve and Ciré, [SPM with decision diagrams](https://arxiv.org/abs/1811.06086), AAAI 2019 | Cites later CP projection work; represents the database with an MDD and handles constraints on event attributes. It is not an open-versus-padded representation comparison. | +| Wang et al., [Seq2Pat](https://ojs.aaai.org/index.php/AAAI/article/view/21542), AAAI 2022 | Builds a declarative interface over the decision-diagram approach, with attribute constraints including gap, span, average and median. These constrain embeddings, unlike the example's pattern language. | + +The CPKB search confirmed CP2015's outgoing references and incoming citations from +ClosedPattern (CP 2016) and CoverSize (CP 2017). Those two globals concern unordered +itemsets; their closure and cover algorithms do not transfer directly to sequential +mining. Locally available references also led to the later sequential papers +above, which were read on the web. The local corpus did not contain an integrated +sequential successor; that is a corpus limit, not a claim that none exists. + +The resulting example keeps the query independent of support computation and +uses ordinary CP constraints for pattern restrictions. The comparison keeps the +paper's data and language presets available alongside integer/SPMF input, arbitrary +support thresholds, and independent enumeration checks. A comparison with another +miner must match item-versus-itemset semantics, support rounding, pattern and +embedding restrictions, and the output query before comparing counts or time. +There is no MDD, vertical-join or embedding-decomposition baseline here. + +## Historical DFA comparison at commit 4f929ea7c3 + +The following measurements predate the projection-based example and broader +support queries; their raw records remain readable and are not reinterpreted as +measurements of the current implementation. On 2026-10-13, the 24-case scaling suite completed with both length bounds: 720/720 measured samples succeeded, with 144/144 independent enumeration checks @@ -178,10 +299,3 @@ show a consistent timing advantage over padded DFA. Its useful modelling property remains the absence of padded decision positions; a runtime advantage is not established. These small planted workloads do not establish performance on the paper's large mining databases or at lower support thresholds. - -The matching shortest-bound run is `release-shortest-serial`. Resume, partial -collection, malformed-record recovery, changed-configuration rejection, timeout, -execution error, invalid output, and analysis of failures were exercised -separately. An additional 30 seeded small databases, each with and without the -motif, matched the independent oracle across all three variants and the actual -`common-pattern` executable. No repository tests or CMake test targets were added. diff --git a/misc/common-pattern/benchmark.py b/misc/common-pattern/benchmark.py index 4512812aa1..2809bb400f 100755 --- a/misc/common-pattern/benchmark.py +++ b/misc/common-pattern/benchmark.py @@ -3,13 +3,14 @@ # requires-python = ">=3.11" # dependencies = [] # /// -"""Compare open/padded DFA models with CP2015 prefix projection at 100% support. +"""Compare open and padded prefix projection for constrained frequent subsequences. One writer per named run. See README.md for the build and comparison limits. """ import argparse from collections import Counter +from decimal import Decimal, ROUND_CEILING import hashlib import json import math @@ -25,7 +26,8 @@ import time -VARIANTS = ("open-dfa", "padded-dfa", "paper-projection") +VARIANTS = ("open-projection", "padded-projection", "paper-projection") +ALL_VARIANTS = VARIANTS + ("open-dfa", "padded-dfa") LANGUAGES = { "none": r"[A-Z]+", "motif": r"A[A-Z]*C", @@ -59,58 +61,113 @@ def planted(rng: random.Random, pattern: str, count: int, return sequences +def read_database(path: Path, format: str) -> list[list[int]]: + sequences = [] + for line in path.read_text().splitlines(): + if not line or (format == "spmf" and line[0] in "#%@"): + continue + if format == "letters": + if not re.fullmatch("[A-Z]+", line): + raise ValueError("expected nonempty A..Z sequences") + sequence = [ord(a) - ord("A") + 1 for a in line] + else: + tokens = [int(token) for token in line.split()] + if format == "spmf": + if (not tokens or tokens[-1] != -2 or len(tokens) % 2 != 1 or + any(tokens[i] != -1 for i in range(1, len(tokens) - 1, 2))): + raise ValueError("SPMF sequences require singleton itemsets and -2 termination") + sequence = tokens[:-1:2] + else: + sequence = tokens + if not sequence or any(item < 1 or item > 2147483646 for item in sequence): + raise ValueError("expected positive Gecode integer items") + sequences.append(sequence) + if not sequences: + raise ValueError("empty database") + return sequences + + +def support_count(percent: str, records: int) -> int: + if not re.fullmatch(r"(?:[0-9]+(?:\.[0-9]{1,6})?|\.[0-9]{1,6})", percent): + raise ValueError("support needs a percentage with at most six decimals") + value = Decimal(percent) + if not 0 < value <= 100: + raise ValueError("support must be in (0,100]") + return int((records * value / 100).to_integral_value(rounding=ROUND_CEILING)) + + def cases(seed: int, suite: str, database: Path | None, - restriction: str) -> list[dict]: + restriction: str, format: str, supports: list[str], + min_length: int, required: list[int]) -> list[dict]: if database: - sequences = database.read_text().splitlines() - if not sequences or any(not re.fullmatch("[A-Z]+", s) for s in sequences): - raise ValueError("database must contain one nonempty A..Z sequence per line") - return [{"id": "input", "sequences": sequences, "language": restriction}] - rng = random.Random(seed) - workloads = [ - ("paper-table1", ["ABCBC", "BABC", "AB", "BCD"], ["none"]), - ("example", ["ABCBC", "BABC", "ABDC"], ["none", "motif"]), - ("repeated", ["AAAAAA", "AAAAAAAA", "AAAAAAAAAA"], ["none", "motif"]), - ("no-common", ["ABC", "DEF"], ["none"]), - ] - if suite == "scaling": - for count in (8, 32, 128): - workloads.append((f"database-{count}", - planted(rng, "ABCABC", count, 10), ["none", "motif"])) - for length in (8, 32, 128): - workloads.append((f"suffix-{length}", - ["ABCBC"] + planted(rng, "ABCBC", 7, length), - ["none", "motif"])) - for length in (4, 8, 12): - pattern = ("ABC" * 4)[:length] - workloads.append((f"pattern-{length}", - [pattern] + planted(rng, pattern, 7, 12), ["none"])) - workloads.extend([ - ("paper-re10", ["AABCDDEFFGII"] + - planted(rng, "AABCDDEFFGII", 7, 8), ["re10"]), - ("paper-re14", ["AABCDDEISHGGR"] + - planted(rng, "AABCDDEISHGGR", 7, 8), ["re14"]), - ("paper-re2", ["SAR"] + planted(rng, "SAR", 7, 16), ["re2"]), - ]) - return [{"id": f"{name}-{language}", "sequences": sequences, - "language": language} - for name, sequences, languages in workloads for language in languages] - - -def common_patterns(sequences: list[str], restriction: str) -> set[str] | None: - """Independent exhaustive oracle when the shortest input is small enough.""" - shortest = min(sequences, key=len) - if len(shortest) > 16: + base = [{"id": "input", "sequences": read_database(database, format), + "language": restriction}] + else: + rng = random.Random(seed) + workloads = [ + ("paper-table1", ["ABCBC", "BABC", "AB", "BCD"], ["none"]), + ("example", ["ABCBC", "BABC", "ABDC"], ["none", "motif"]), + ("repeated", ["AAAAAA", "AAAAAAAA", "AAAAAAAAAA"], ["none", "motif"]), + ("no-common", ["ABC", "DEF"], ["none"]), + ] + if suite == "scaling": + for count in (8, 32, 128): + workloads.append((f"database-{count}", planted(rng, "ABCABC", count, 10), + ["none", "motif"])) + for noise in (8, 32, 128): + workloads.append((f"input-noise-{noise}", + ["ABCBC"] + planted(rng, "ABCBC", 7, noise), ["none", "motif"])) + for length in (4, 8, 12): + pattern = ("ABC" * 4)[:length] + workloads.append((f"pattern-{length}", [pattern] + planted(rng, pattern, 7, 12), ["none"])) + workloads.extend([ + ("paper-re10", ["AABCDDEFFGII"] + planted(rng, "AABCDDEFFGII", 7, 8), ["re10"]), + ("paper-re14", ["AABCDDEISHGGR"] + planted(rng, "AABCDDEISHGGR", 7, 8), ["re14"]), + ("paper-re2", ["SAR"] + planted(rng, "SAR", 7, 16), ["re2"]), + ]) + base = [{"id": f"{name}-{language}", "language": language, + "sequences": [[ord(a) - ord("A") + 1 for a in s] for s in sequences]} + for name, sequences, languages in workloads for language in languages] + result = [{**case, "id": f"{case['id']}-support-{percent}", "support_percent": percent, + "min_support": support_count(percent, len(case["sequences"])), + "min_length": min_length, "required": required} + for case in base for percent in supports] + if len({case["id"] for case in result}) != len(result): + raise ValueError("duplicate support thresholds") + return result + + +def accepts(pattern: tuple[int, ...], case: dict) -> bool: + if len(pattern) < case["min_length"] or not set(case["required"]).issubset(pattern): + return False + language = case["language"] + if language == "none": + return True + if language == "motif": + return len(pattern) >= 2 and pattern[0] == 1 and pattern[-1] == 3 + if language == "re2": + return len(pattern) == 3 and pattern[0] in (19, 20) and pattern[-1] in (18, 11) + text = "".join(chr(64 + a) if 1 <= a <= 26 else "?" for a in pattern) + return re.fullmatch(LANGUAGES[language], text) is not None + + +def frequent_patterns(case: dict) -> set[tuple[int, ...]] | None: + """Every k-supported pattern occurs in at least one of the n-k+1 shortest records.""" + sequences = case["sequences"] + cover = sorted(sequences, key=len)[:len(sequences) - case["min_support"] + 1] + if any(len(s) > 16 for s in cover) or sum(2**len(s) for s in cover) > 200000: return None - candidates = {""} - for item in shortest: - candidates |= {prefix + item for prefix in candidates} - expression = re.compile(LANGUAGES[restriction]) - return {pattern for pattern in candidates if expression.fullmatch(pattern) - and all(is_subsequence(pattern, sequence) for sequence in sequences)} + candidates = set() + for sequence in cover: + local = {()} + for item in sequence: + local |= {prefix + (item,) for prefix in local} + candidates |= local + return {pattern for pattern in candidates if accepts(pattern, case) + and sum(is_subsequence(pattern, s) for s in sequences) >= case["min_support"]} -def is_subsequence(pattern: str, sequence: str) -> bool: +def is_subsequence(pattern: tuple[int, ...], sequence: list[int]) -> bool: items = iter(sequence) return all(item in items for item in pattern) @@ -161,19 +218,21 @@ def kill_process_group(process: subprocess.Popen) -> None: def check_patterns(result: dict, output: Path, case: dict, - expected: set[str] | None) -> dict: + expected: set[tuple[int, ...]] | None) -> dict: if result["status"] != "ok": return result - patterns = output.read_text().splitlines() + try: + patterns = [tuple(map(int, line.split())) for line in output.read_text().splitlines()] + except ValueError: + return {**result, "status": "invalid", "detail": "non-integer pattern output"} actual = set(patterns) - expression = re.compile(LANGUAGES[case["language"]]) if (len(patterns) != result["metrics"]["solutions"] or len(actual) != len(patterns) or - any(not expression.fullmatch(p) or - not all(is_subsequence(p, s) for s in case["sequences"]) + any(not accepts(p, case) or + sum(is_subsequence(p, s) for s in case["sequences"]) < case["min_support"] for p in patterns) or (expected is not None and actual != expected)): return {**result, "status": "invalid", "detail": "incorrect pattern enumeration"} - fingerprint = hashlib.sha256("\n".join(sorted(actual)).encode()).hexdigest() + fingerprint = hashlib.sha256(json.dumps(sorted(actual)).encode()).hexdigest() return {**result, "patterns_sha256": fingerprint, "oracle": "exhaustive" if expected is not None else "feasibility"} @@ -212,34 +271,44 @@ def valid_record(path: Path, identity: dict, validation: bool = False) -> dict | def command(binary: str, case: dict, variant: str, database: Path, output: str, bound: str) -> list[str]: - return [binary, variant, case["language"], str(database), output, bound] + required = ",".join(map(str, case["required"])) or "-" + return [binary, variant, case["language"], str(database), output, bound, + case["support_percent"], str(case["min_length"]), required, "integers"] def collect(args: argparse.Namespace, directory: Path) -> None: binary = args.binary.resolve(strict=True) - workloads = cases(args.seed, args.suite, args.database, args.language) + workloads = cases(args.seed, args.suite, args.database, args.language, args.format, + args.support, args.min_length, args.required) + variants = args.variants + if len(set(variants)) != len(variants): + raise ValueError("duplicate variants") + if any(case["min_support"] < len(case["sequences"]) for case in workloads) and ( + args.bound == "shortest" or any(v.endswith("dfa") for v in variants)): + raise ValueError("DFA models and shortest bound require all-input support") # Mutable shared libraries count as part of the target, not just the executable. libraries = sorted({p.resolve() for p in binary.parent.parent.glob("libgecode*") if p.suffix in (".so", ".dylib", ".a")}) if not libraries: raise ValueError("expected binary in BUILD/bin and Gecode libraries in BUILD") - config = {"format": 1, "binary": str(binary), "binary_sha256": digest(binary), + config = {"format": 2, "binary": str(binary), "binary_sha256": digest(binary), "libraries": {str(p): digest(p) for p in libraries}, "build_label": args.build_label, "runner_sha256": digest(Path(__file__)), "source_sha256": digest(Path(__file__).with_name("compare.cpp")), + "helper_sha256": digest(Path(__file__).resolve().parents[2] / "examples/common-pattern.hh"), "machine": {"system": platform.platform(), "node": platform.node(), "processor": platform.processor()}, "cases": workloads, "repetitions": args.repetitions, "seed": args.seed, "timeout_seconds": args.timeout, - "bound": args.bound, "variants": list(VARIANTS)} - print(f"{len(workloads)} cases; {len(workloads)*3} correctness runs; " - f"{len(workloads)*3*args.repetitions} measured runs; " + "bound": args.bound, "variants": variants} + print(f"{len(workloads)} cases; {len(workloads)*len(variants)} correctness runs; " + f"{len(workloads)*len(variants)*args.repetitions} measured runs; " f"{args.timeout}s timeout per invocation; bound={args.bound}") print("Serial, shuffled repetitions; model construction + exhaustive DFS; " "measured runs count solutions without printing them.") if args.dry_run: - print(" ".join(command(str(binary), workloads[0], VARIANTS[0], + print(" ".join(command(str(binary), workloads[0], variants[0], directory / "inputs" / (workloads[0]["id"] + ".txt"), "count", args.bound))) return @@ -254,10 +323,10 @@ def collect(args: argparse.Namespace, directory: Path) -> None: passed = set() for case in workloads: database = directory / "inputs" / (case["id"] + ".txt") - database.write_text("\n".join(case["sequences"]) + "\n") - oracle = common_patterns(case["sequences"], case["language"]) + database.write_text("\n".join(" ".join(map(str, s)) for s in case["sequences"]) + "\n") + oracle = frequent_patterns(case) checks = [] - for variant in VARIANTS: + for variant in variants: identity = {"case": case["id"], "variant": variant} path = directory / "validation" / f"{case['id']}-{variant}.json" record = valid_record(path, identity, validation=True) @@ -275,7 +344,7 @@ def collect(args: argparse.Namespace, directory: Path) -> None: else: print(f"{case['id']}: correctness failed or incomplete; timings skipped") schedule = [(case, variant, repeat) for repeat in range(args.repetitions) - for case in workloads for variant in VARIANTS] + for case in workloads for variant in variants] random.Random(args.seed).shuffle(schedule) executed = 0 failures = 0 @@ -313,7 +382,7 @@ def collect(args: argparse.Namespace, directory: Path) -> None: def analyze(directory: Path) -> None: config = json.loads((directory / "config.json").read_text()) print(f"Build: {config['build_label']}; bound: {config['bound']}; " - "support: 100%; all-pattern enumeration") + "per-case sequence support; all-pattern enumeration") print("Model+search seconds: median [min, max]; only validated successful samples.") print("End-to-end wall seconds include process startup and teardown.") print("case | variant | ok/expected | other | patterns | model+search s | wall s | nodes | propagations") @@ -352,7 +421,7 @@ def analyze(directory: Path) -> None: print(f"Measured sample status: {dict(totals)}") print(f"Correctness status: {dict(validation_counts)}; " f"cases with disagreeing pattern sets: {mismatched_cases}") - print("Paper-projection is an Algorithm 2 reimplementation at 100% support, " + print("Paper-projection is an Algorithm 2 reimplementation, " "not the authors' executable or a replication of their dataset timings.") @@ -364,10 +433,16 @@ def main() -> None: run.add_argument("--name", required=True) run.add_argument("--binary", type=Path, required=True) run.add_argument("--build-label", required=True, help="compiler, flags and build configuration") - run.add_argument("--suite", choices=("smoke", "scaling"), default="scaling") - run.add_argument("--database", type=Path, help="custom A..Z database, one sequence per line") + run.add_argument("--suite", choices=("smoke", "scaling"), default="smoke") + run.add_argument("--database", type=Path, help="custom database, one sequence per line") run.add_argument("--language", choices=tuple(LANGUAGES), default="none", help="restriction for a custom database") + run.add_argument("--format", choices=("letters", "integers", "spmf"), default="letters") + run.add_argument("--support", nargs="+", default=["100", "50", "25"], + help="minimum-support percentages (up to six decimals)") + run.add_argument("--min-length", type=int, default=1) + run.add_argument("--required", type=int, nargs="*", default=[], help="required positive item IDs") + run.add_argument("--variants", choices=ALL_VARIANTS, nargs="+", default=list(VARIANTS)) run.add_argument("--bound", choices=("max", "shortest"), default="max") run.add_argument("--repetitions", type=int, default=5) run.add_argument("--timeout", type=float, default=30) @@ -385,6 +460,9 @@ def main() -> None: if (args.repetitions < 1 or not math.isfinite(args.timeout) or args.timeout <= 0 or (args.limit is not None and args.limit < 0)): parser.error("repetitions and timeout must be positive; limit must be nonnegative") + if (args.min_length < 1 or args.min_length > 2147483646 or + any(item < 1 or item > 2147483646 for item in args.required)): + parser.error("length and required item IDs must be positive Gecode integers") collect(args, directory) else: analyze(directory) diff --git a/misc/common-pattern/compare.cpp b/misc/common-pattern/compare.cpp index 9d0caad95e..af8810487b 100644 --- a/misc/common-pattern/compare.cpp +++ b/misc/common-pattern/compare.cpp @@ -5,8 +5,7 @@ * Distributed under the MIT license; see LICENSE. */ -#include -#include +#include #include #include @@ -17,24 +16,27 @@ #include using namespace Gecode; +using namespace PatternMining; namespace { /// The representations compared on identical enumeration problems - enum class Model { OpenDFA, PaddedDFA, PaperProjection }; + enum class Model { + OpenDFA, PaddedDFA, OpenProjection, PaddedProjection, PaperProjection + }; /// Earliest-match subsequence DFA, optionally accepting trailing zeroes DFA - subsequences(const std::string& text, bool padded) { - const int n = static_cast(text.size()); - int next[26]; - std::fill(next,next+26,-1); + subsequences(const Database& database, int sequence, bool padded) { + const int start = (sequence == 0) ? 0 : database.ends[sequence-1]; + const int n = database.ends[sequence]-start; + std::vector next(database.alphabet.size(),-1); std::vector transitions; for (int i=n; i--; ) { - next[text[i]-'A'] = i+1; - for (int a=0; a<26; a++) + next[database.items[start+i]] = i+1; + for (int a=0; a= 0) - transitions.emplace_back(i,'A'+a,next[a]); + transitions.emplace_back(i,database.alphabet[a],next[a]); } if (padded) { for (int i=0; i<=n+1; i++) @@ -49,75 +51,46 @@ namespace { return DFA(0,transitions.data(),finals.data()); } - /// Pattern restrictions from the example and CP2015 Section 5(d) - REG - language(const std::string& name) { - if (name == "motif") - return REG('A') + *REG(IntArgs::create(26,'A',1)) + REG('C'); - if (name == "re10") - return *REG('A') + REG('B') + (REG('B') | REG('C')) + - *REG('D') + REG('E') + *REG('F') + (REG('G') | REG('H')) + - *REG('I'); - if (name == "re14") - return *REG('A') + (REG('Q') | (REG('B') + *REG('S') + - (REG('B') | REG('C')))) + *REG('D') + REG('E') + - *(REG('I') | REG('S')) + (REG('F') | REG('H')) + - *REG('G') + REG('R'); - // RE2: the middle position is any item in the alphabet. - return (REG('S') | REG('T')) + REG(IntArgs::create(26,'A',1)) + - (REG('R') | REG('K')); - } - /** - * \brief CP2015 Algorithm 2 specialized to all-input support + * \brief CP2015 Algorithm 2, with an optional extension-length bound * - * This is a reimplementation, not the authors' unavailable executable. - * Each input has one earliest-match cursor, advanced after each item. - * All sequences must support the prefix; the intersection of suffix items - * is therefore exactly GETFREQITEMS at 100% support. Only the current - * projection is retained in a space; Gecode cloning restores parent states. - * Fixed positions and zero termination retain the paper's representation. + * The paper baseline filters after contiguous prefix assignments. The + * padded-projection variant also filters initially and caps remaining + * nonzero positions, matching the shared open projection's extra pruning. + * Both retain the paper's fixed positions and zero termination. */ class PaperProjection : public NaryPropagator { protected: - /// Immutable concatenated database and exclusive sequence ends - IntSharedArray items, ends; - /// Next unmatched input position for each sequence - int* cursor; + Projection projection; /// Number of consumed contiguous pattern positions int consumed; + /// Match the open projection's initial filtering and suffix-length cap + bool bounded; public: - /// Post the initial projection PaperProjection(Space& home, ViewArray& x, - const IntSharedArray& data, const IntSharedArray& limits) + const Database& database, int support, bool cap) : NaryPropagator(home,x), - items(data), ends(limits), cursor(home.alloc(ends.size())), - consumed(0) { - for (int i=0; i(home,p), - items(p.items), ends(p.ends), cursor(home.alloc(ends.size())), - consumed(p.consumed) { - std::copy(p.cursor,p.cursor+ends.size(),cursor); - } + projection(home,p.projection), consumed(p.consumed), bounded(p.bounded) {} virtual Actor* copy(Space& home) { return new (home) PaperProjection(home,*this); } virtual PropCost cost(const Space&, const ModEventDelta&) const { - return PropCost::linear(PropCost::HI,items.size()+x.size()); + return PropCost::linear(PropCost::HI,projection.data.items.size()); } virtual size_t dispose(Space& home) { home.ignore(*this,AP_DISPOSE); - items.~IntSharedArray(); - ends.~IntSharedArray(); + projection.~Projection(); (void) NaryPropagator::dispose(home); return sizeof(*this); } @@ -125,44 +98,29 @@ namespace { virtual ExecStatus propagate(Space& home, const ModEventDelta&) { for (;;) { while ((consumed < x.size()) && x[consumed].assigned()) { - const int a = x[consumed].val(); - if (a == 0) { + const int item = x[consumed].val(); + if (item == 0) { for (int j=consumed+1; j& input, Model m, - const std::string& restriction, int bound) + Pattern(const Database& database, Model m, Language restriction, int bound, + int support, int minimum_length, const std::vector& required) : model(m) { - bool present[26] = {}; - for (const std::string& sequence : input) - for (char a : sequence) - present[a-'A'] = true; - int values[27]; - int n = 1; - values[0] = 0; - for (int a=0; a<26; a++) - if (present[a]) - values[n++] = 'A'+a; - if (model == Model::OpenDFA) { - open = OpenIntVarList(*this,IntSet(values+1,n-1),bound); - rel(*this,open.length(),IRT_GQ,1); - for (const std::string& sequence : input) - extensional(*this,open,subsequences(sequence,false)); - if (restriction != "none") - extensional(*this,open,language(restriction)); - branch(*this,open,INT_VAR_NONE(),INT_VAL_MIN()); + if (minimum_length > bound) { + fail(); return; } - padded = IntVarArray(*this,bound,IntSet(values,n)); - rel(*this,padded[0],IRT_NQ,0); - if (model == Model::PaddedDFA) { - for (const std::string& sequence : input) - extensional(*this,padded,subsequences(sequence,true)); + const bool growing = (model == Model::OpenDFA) || + (model == Model::OpenProjection); + if (growing) { + open = OpenIntVarList(*this,database.domain(),bound); + rel(*this,open.length(),IRT_GQ,minimum_length); + if (model == Model::OpenDFA) { + for (int i=0; i(sequence.size()); - IntSharedArray items(size), ends(static_cast(input.size())); - int k = 0, i = 0; - for (const std::string& sequence : input) { - for (char a : sequence) - items[k++] = a; - ends[i++] = k; + std::vector values(1,0); + values.insert(values.end(),database.alphabet.begin(),database.alphabet.end()); + padded = IntVarArray(*this,bound,IntSet(values.data(),values.size())); + for (int i=0; i x(*this,IntVarArgs(padded)); + (void) new (*this) PaperProjection(*this,x,database,support, + model == Model::PaddedProjection); } - ViewArray x(*this,IntVarArgs(padded)); - (void) new (*this) PaperProjection(*this,x,items,ends); } - if (restriction != "none") - extensional(*this,padded,language(restriction) + *REG(0)); - branch(*this,padded,INT_VAR_NONE(),INT_VAL_MIN()); + if (restriction != NONE) { + REG expression = language(restriction,database); + if (growing) + extensional(*this,open,expression); + else + extensional(*this,padded,expression + *REG(0)); + } + REG alphabet(IntArgs(database.alphabet.size(),database.alphabet.begin())); + for (int item : required) { + REG contains = *alphabet + REG(item) + *alphabet; + if (growing) + extensional(*this,open,contains); + else + extensional(*this,padded,contains + *REG(0)); + } + if (growing) + branch(*this,open,INT_VAR_NONE(),INT_VAL_MIN()); + else + branch(*this,padded,INT_VAR_NONE(),INT_VAL_MIN()); } Pattern(Pattern& s) : Space(s), model(s.model) { - if (model == Model::OpenDFA) + if ((model == Model::OpenDFA) || (model == Model::OpenProjection)) open.update(*this,s.open); else padded.update(*this,s.padded); @@ -235,81 +200,131 @@ namespace { virtual Space* copy(void) { return new Pattern(*this); } /// Emit actual items only, in the same format for all representations - void print(void) const { - if (model == Model::OpenDFA) { - for (int i=0; i(open[i].val()); - } else { - for (int i=0; (i(padded[i].val()); + void print(Format format) const { + const bool growing = (model == Model::OpenDFA) || + (model == Model::OpenProjection); + const int n = growing ? open.prefix_size() : padded.size(); + for (int i=0; i('A'+item-1); + else { + if (i > 0) + std::cout << ' '; + std::cout << item; + } } std::cout << '\n'; } }; + /// Strictly parse positive query integers without accepting trailing text + int + positive_integer(const std::string& text) { + const std::vector items = read_sequence(text,INTEGERS); + if (items.size() != 1) + throw std::invalid_argument("Expected one positive integer"); + return items[0]; + } + + std::vector + required_items(const std::string& text) { + std::vector required; + if (text == "-") + return required; + if (text.empty() || (text.back() == ',')) + throw std::invalid_argument("Expected comma-separated positive required items"); + std::istringstream stream(text); + std::string item; + while (std::getline(stream,item,',')) + required.push_back(positive_integer(item)); + return required; + } + } int main(int argc, char* argv[]) { - if (argc != 6) { - std::cerr << "Usage: compare open-dfa|padded-dfa|paper-projection " - << "none|motif|re10|re14|re2 FILE print|count max|shortest\n"; + if ((argc < 6) || (argc > 10)) { + std::cerr << "Usage: compare MODEL none|motif|re10|re14|re2 FILE " + << "print|count max|shortest [SUPPORT_PERCENT [MIN_LENGTH " + << "[REQUIRED_ITEMS [letters|integers|spmf]]]]\n" + << "Models: open-dfa, padded-dfa, open-projection, " + << "padded-projection, paper-projection\n"; return 1; } - const std::string variant(argv[1]), restriction(argv[2]), - output(argv[4]), length_bound(argv[5]); - if (((variant != "open-dfa") && (variant != "padded-dfa") && - (variant != "paper-projection")) || - ((restriction != "none") && (restriction != "motif") && - (restriction != "re10") && (restriction != "re14") && - (restriction != "re2")) || - ((output != "print") && (output != "count")) || - ((length_bound != "max") && (length_bound != "shortest"))) - return 1; - std::ifstream file(argv[3]); - std::vector input; - std::string sequence; - size_t total = 0; - while (std::getline(file,sequence)) { - if (sequence.empty() || (sequence.find_first_not_of( - "ABCDEFGHIJKLMNOPQRSTUVWXYZ") != std::string::npos)) { - std::cerr << "Expected one nonempty A..Z sequence per line\n"; - return 1; + try { + const std::string variant(argv[1]), restriction(argv[2]), + output(argv[4]), length_bound(argv[5]); + Model model; + if (variant == "open-dfa") model = Model::OpenDFA; + else if (variant == "padded-dfa") model = Model::PaddedDFA; + else if (variant == "open-projection") model = Model::OpenProjection; + else if (variant == "padded-projection") model = Model::PaddedProjection; + else if (variant == "paper-projection") model = Model::PaperProjection; + else throw std::invalid_argument("Unknown comparison model"); + Language query; + if (restriction == "none") query = NONE; + else if (restriction == "motif") query = MOTIF; + else if (restriction == "re10") query = RE10; + else if (restriction == "re14") query = RE14; + else if (restriction == "re2") query = RE2; + else throw std::invalid_argument("Unknown pattern language"); + if (((output != "print") && (output != "count")) || + ((length_bound != "max") && (length_bound != "shortest"))) + throw std::invalid_argument("Expected print|count and max|shortest"); + Format format = LETTERS; + if (argc > 9) { + const std::string name(argv[9]); + if (name == "integers") format = INTEGERS; + else if (name == "spmf") format = SPMF; + else if (name != "letters") + throw std::invalid_argument("Unknown database format"); } - total += sequence.size(); - if (total >= static_cast(Int::Limits::max)) - return 1; - input.push_back(sequence); - } - if (!file.eof() || input.empty()) + const std::string percent = (argc > 6) ? argv[6] : "100"; + (void) minimum_support(percent,1); + const int minimum_length = (argc > 7) ? positive_integer(argv[7]) : 1; + const std::vector required = required_items((argc > 8) ? argv[8] : "-"); + std::ifstream file(argv[3]); + const Sequences input = read_database(file,format); + + const auto start = std::chrono::steady_clock::now(); + const Database database(input); + const int support = minimum_support(percent,database.ends.size()); + if ((support != database.ends.size()) && + ((model == Model::OpenDFA) || (model == Model::PaddedDFA) || + (length_bound == "shortest"))) + throw std::invalid_argument("DFA models and shortest bound require all-input support"); + int bound = database.max_length(); + if (length_bound == "shortest") + for (const std::vector& sequence : input) + bound = std::min(bound,static_cast(sequence.size())); + Pattern* root = new Pattern(database,model,query,bound,support, + minimum_length,required); + Search::Options options; + options.threads = 1; + options.clone = false; + DFS engine(root,options); + unsigned long long solutions = 0; + while (Pattern* solution = engine.next()) { + solutions++; + if (output == "print") + solution->print(format); + delete solution; + } + const auto end = std::chrono::steady_clock::now(); + const Search::Statistics stats = engine.statistics(); + std::cerr << "{\"solutions\":" << solutions + << ",\"nodes\":" << stats.node + << ",\"failures\":" << stats.fail + << ",\"propagations\":" << stats.propagate + << ",\"model_search_seconds\":" + << std::chrono::duration(end-start).count() << "}\n"; + return 0; + } catch (const std::exception& error) { + std::cerr << error.what() << '\n'; return 1; - int bound = static_cast(input.front().size()); - for (const std::string& text : input) - bound = (length_bound == "max") ? - std::max(bound,static_cast(text.size())) : - std::min(bound,static_cast(text.size())); - const Model model = (variant == "open-dfa") ? Model::OpenDFA : - (variant == "padded-dfa") ? Model::PaddedDFA : Model::PaperProjection; - const auto start = std::chrono::steady_clock::now(); - Pattern* root = new Pattern(input,model,restriction,bound); - Search::Options options; - options.threads = 1; - options.clone = false; - DFS engine(root,options); - unsigned long long solutions = 0; - while (Pattern* solution = engine.next()) { - solutions++; - if (output == "print") - solution->print(); - delete solution; } - const auto end = std::chrono::steady_clock::now(); - const Search::Statistics stats = engine.statistics(); - std::cerr << "{\"solutions\":" << solutions - << ",\"nodes\":" << stats.node - << ",\"failures\":" << stats.fail - << ",\"propagations\":" << stats.propagate - << ",\"model_search_seconds\":" - << std::chrono::duration(end-start).count() << "}\n"; - return 0; } diff --git a/test/int/open-var-list.cpp b/test/int/open-var-list.cpp index 2f0d229184..65b70d4247 100644 --- a/test/int/open-var-list.cpp +++ b/test/int/open-var-list.cpp @@ -32,6 +32,7 @@ */ #include "test/int.hh" +#include "examples/common-pattern.hh" #include @@ -43,6 +44,7 @@ #endif #include +#include namespace Test { namespace Int { @@ -1041,6 +1043,212 @@ namespace Test { namespace Int { } }; + /// Search model for the private common-pattern projection + class PatternSpace : public Gecode::Space { + public: + Gecode::OpenIntVarList list; + + PatternSpace(const PatternMining::Database& data, int support) + : list(*this,data.domain(),data.max_length()) { + Gecode::rel(*this,list.length(),Gecode::IRT_GQ,1); + PatternMining::frequent(*this,list,data,support); + Gecode::branch(*this,list); + } + + PatternSpace(PatternSpace& s) : Gecode::Space(s) { + list.update(*this,s.list); + } + + virtual Gecode::Space* copy(void) { + return new PatternSpace(*this); + } + }; + + /// Compare complete solution sets with independently enumerated subsequences + class PatternEnumeration : public ::Test::Base { + public: + PatternEnumeration(void) + : ::Test::Base("Int::OpenList::Pattern::Enumeration", + TestTags::check()) {} + + virtual bool run(void) { + using namespace Gecode; + const PatternMining::Sequences inputs[] = { + {{17,1000000,17},{17,1000000,17},{1000000,17,42},{17,42}}, + {{1,1},{1,2},{2,1}} + }; + for (const PatternMining::Sequences& input : inputs) { + std::set> candidates; + for (const std::vector& row : input) + for (unsigned int mask=1; mask<(1U< pattern; + for (unsigned int i=0; i(input.size())}; + for (int threshold : thresholds) { + std::set> expected, found; + for (const std::vector& pattern : candidates) { + int support = 0; + for (const std::vector& row : input) { + auto next = row.begin(); + bool matches = true; + for (int item : pattern) { + next = std::find(next,row.end(),item); + if (next == row.end()) { + matches = false; + break; + } + ++next; + } + support += matches; + } + if (support >= threshold) + expected.insert(pattern); + } + PatternSpace root(data,threshold); + Search::Options options; + options.threads = 1; + options.c_d = 1000; + options.a_d = 1000; + DFS search(&root,options); + while (PatternSpace* solution = search.next()) { + std::unique_ptr owned(solution); + if (!solution->list.length().assigned() || + (solution->list.length().val() != + solution->list.prefix_size())) + return false; + std::vector pattern; + for (int i=0; ilist.prefix_size(); i++) { + if (!solution->list[i].assigned()) + return false; + pattern.push_back(solution->list[i].val()); + } + if (!found.insert(pattern).second) + return false; + } + if (found != expected) + return false; + } + } + return true; + } + }; + + /// Exercise projection state through growth, cloning, and late assignments + class PatternGrowth : public ::Test::Base { + public: + PatternGrowth(void) + : ::Test::Base("Int::OpenList::Pattern::Growth",TestTags::check()) {} + + virtual bool run(void) { + using namespace Gecode; + const PatternMining::Database data({{1,2,1},{1,2,2},{1,1,2}}); + PatternSpace source(data,2); + source.list.materialize(source,1); + rel(source,source.list[0],IRT_EQ,1); + if (source.status() == SS_FAILED) + return false; + std::unique_ptr clone + (static_cast(source.clone())); + clone->list.materialize(*clone,2); + rel(*clone,clone->list[1],IRT_EQ,1); + if ((clone->status() == SS_FAILED) || + !clone->list.length().assigned() || + (clone->list.length().val() != 2) || + (source.list.prefix_size() != 1) || + (source.list.length().min() != 1)) + return false; + source.list.materialize(source,2); + rel(source,source.list[1],IRT_EQ,2); + if ((source.status() == SS_FAILED) || + !source.list.length().assigned() || + (source.list.length().val() != 2) || + (clone->list[1].val() != 1)) + return false; + + // Assigning a later position must not advance the projected prefix. + PatternSpace later(data,2); + later.list.materialize(later,2); + rel(later,later.list[1],IRT_EQ,2); + if ((later.status() == SS_FAILED) || later.list[0].assigned()) + return false; + std::unique_ptr invalid + (static_cast(later.clone())); + rel(*invalid,invalid->list[0],IRT_EQ,2); + if (invalid->status() != SS_FAILED) + return false; + rel(later,later.list[0],IRT_EQ,1); + if (later.status() == SS_FAILED) + return false; + + // Both singleton prefixes are frequent, but no extension is frequent. + const PatternMining::Database terminal({{1,1},{1,2},{2,1}}); + for (int item=1; item<=2; item++) { + PatternSpace leaf(terminal,2); + leaf.list.materialize(leaf,1); + rel(leaf,leaf.list[0],IRT_EQ,item); + if ((leaf.status() == SS_FAILED) || + !leaf.list.length().assigned() || + (leaf.list.length().val() != 1)) + return false; + } + return true; + } + }; + + /// Input validation and exact rounding of percentage support + class PatternInput : public ::Test::Base { + public: + PatternInput(void) + : ::Test::Base("Int::OpenList::Pattern::Input",TestTags::check()) {} + + virtual bool run(void) { + using namespace PatternMining; + std::istringstream rows("# comment\n17 -1 1000000 -1 -2\r\n" + "17 -1 1000000 -1 -2\n"); + if (read_database(rows,SPMF) != Sequences({{17,1000000},{17,1000000}}) || + read_sequence("ABA",LETTERS) != std::vector({1,2,1}) || + read_sequence("17 1000000",INTEGERS) != + std::vector({17,1000000}) || + (minimum_support("33.333333",3) != 1) || + (minimum_support("33.333334",3) != 2) || + (minimum_support("100",2000000000) != 2000000000) || + (minimum_support("0.000001",2000000000) != 20)) + return false; + for (const char* text : {"1 2 -1 -2", "1 -2", "1 -1", + "1 -1 -2 2", "2147483648 -1 -2"}) { + bool rejected = false; + try { + (void) read_sequence(text,SPMF); + } catch (const std::invalid_argument&) { + rejected = true; + } + if (!rejected) + return false; + } + for (const char* text : {"0", "101", "0.0000001", + "184467440737095516160"}) { + bool rejected = false; + try { + (void) minimum_support(text,3); + } catch (const std::invalid_argument&) { + rejected = true; + } + if (!rejected) + return false; + } + return true; + } + }; + + PatternEnumeration pattern_enumeration; + PatternGrowth pattern_growth; + PatternInput pattern_input; + ValueCommit value_commit; ValueReplay value_replay; ImpossibleWindow impossible_window; From 7a2eeb6369abd4e51e8d54b16792d61b8690778d Mon Sep 17 00:00:00 2001 From: Mikael Zayenz Lagerkvist Date: Tue, 13 Oct 2026 11:42:15 +0200 Subject: [PATCH 23/34] Reduce projection work in common-pattern mining --- examples/common-pattern.cpp | 21 ++-- examples/common-pattern.hh | 174 +++++++++++++++++++------------ misc/common-pattern/README.md | 148 +++++++++++++++++++++++--- misc/common-pattern/benchmark.py | 36 +++++-- misc/common-pattern/compare.cpp | 28 ++--- test/int/open-var-list.cpp | 8 +- 6 files changed, 298 insertions(+), 117 deletions(-) diff --git a/examples/common-pattern.cpp b/examples/common-pattern.cpp index 8672817900..8683a40aa0 100644 --- a/examples/common-pattern.cpp +++ b/examples/common-pattern.cpp @@ -172,6 +172,7 @@ class CommonPatternOptions : public Options { class CommonPattern : public IntMaximizeScript { protected: OpenIntVarList pattern; + IntVar frequency; PatternMining::Database database; bool letters; public: @@ -181,12 +182,14 @@ class CommonPattern : public IntMaximizeScript { : IntMaximizeScript(opt), database(opt.database()), letters(opt.letters()) { pattern = OpenIntVarList(*this,database.domain(),database.max_length()); rel(*this,pattern.length(),IRT_GQ,opt.min_length()); - PatternMining::frequent(*this,pattern,database,opt.support()); + frequency = PatternMining::frequent(*this,pattern,database,opt.support()); if (opt.language() != PatternMining::NONE) extensional(*this,pattern,PatternMining::language(opt.language(),database)); - REG alphabet(IntArgs(database.alphabet)); - for (int item : opt.required()) - extensional(*this,pattern,*alphabet + REG(item) + *alphabet); + if (!opt.required().empty()) { + REG alphabet(IntArgs(database.alphabet)); + for (int item : opt.required()) + extensional(*this,pattern,*alphabet + REG(item) + *alphabet); + } branch(*this,pattern,INT_VAR_NONE(),INT_VAL_MIN()); } @@ -195,19 +198,18 @@ class CommonPattern : public IntMaximizeScript { CommonPattern(CommonPattern& s) : IntMaximizeScript(s), database(s.database), letters(s.letters) { pattern.update(*this,s.pattern); + frequency.update(*this,s.frequency); } virtual Space* copy(void) { return new CommonPattern(*this); } virtual void print(std::ostream& os) const { - std::vector items; os << "\t"; for (int i=0; i('A'+item-1); else @@ -216,10 +218,9 @@ class CommonPattern : public IntMaximizeScript { os << pattern[i]; } } - os << " (length " << pattern.length(); - if (static_cast(items.size()) == pattern.prefix_size()) - os << ", support " << database.support(items) << '/' << database.ends.size(); - os << ")" << std::endl; + os << " (length " << pattern.length() + << ", support " << frequency << '/' << database.ends.size() + << ")" << std::endl; } }; diff --git a/examples/common-pattern.hh b/examples/common-pattern.hh index 2c942af884..106db480ca 100644 --- a/examples/common-pattern.hh +++ b/examples/common-pattern.hh @@ -120,6 +120,8 @@ namespace PatternMining { class Database { public: IntSharedArray items, ends, alphabet; + /// Last occurrence of each distinct item per record, in decreasing order + IntSharedArray last_positions, last_ends; explicit Database(const Sequences& input) { if (input.empty()) @@ -141,13 +143,27 @@ namespace PatternMining { alphabet.init(static_cast(symbols.size())); std::copy(symbols.begin(),symbols.end(),alphabet.begin()); ends.init(static_cast(input.size())); + last_ends.init(static_cast(input.size())); + Region region; + int* seen = region.alloc(alphabet.size()); + std::fill(seen,seen+alphabet.size(),-1); + std::vector last; int k = 0, i = 0; for (const std::vector& sequence : input) { + const int start = k; for (int item : sequence) items[k++] = static_cast(std::lower_bound( symbols.begin(),symbols.end(),item)-symbols.begin()); - ends[i++] = k; + ends[i] = k; + for (int j=k; j-- > start; ) + if (seen[items[j]] != i) { + seen[items[j]] = i; + last.push_back(j); + } + last_ends[i++] = static_cast(last.size()); } + last_positions.init(static_cast(last.size())); + std::copy(last.begin(),last.end(),last_positions.begin()); } IntSet domain(void) const { return IntSet(alphabet.begin(),alphabet.size()); } @@ -176,64 +192,66 @@ namespace PatternMining { } }; - /// Current pseudo-projection, shared by the open and padded implementations + /// Supporting suffixes, shared by the open and padded implementations class Projection { + protected: + struct Suffix { + int sequence, begin; + }; + Suffix* suffixes; + int size; public: Database data; int threshold; - int* cursor; Projection(Space& home, const Database& database, int support) - : data(database), threshold(support), - cursor(home.alloc(data.ends.size())) { - for (int i=0; i(database.ends.size())), + size(database.ends.size()), data(database), threshold(support) { + for (int i=0; i(data.ends.size())) { - std::copy(p.cursor,p.cursor+data.ends.size(),cursor); + : suffixes(home.alloc(p.size)), size(p.size), + data(p.data), threshold(p.threshold) { + std::copy(p.suffixes,p.suffixes+size,suffixes); } - /// Advance supporting records past the earliest occurrence of an item + /// Keep only records supporting the extended prefix, at their earliest match bool advance(int item) { const int rank = static_cast(std::lower_bound( data.alphabet.begin(),data.alphabet.end(),item)-data.alphabet.begin()); if ((rank == data.alphabet.size()) || (data.alphabet[rank] != item)) return false; - int count = 0; - for (int i=0; i= threshold; + size = n; + return size >= threshold; } - /// Locally frequent items, counting each item once per supporting record + int support(void) const { return size; } + + /// Each item's last occurrence suffices to establish its suffix support IntSet frequent(Region& region, bool termination) const { const int d = data.alphabet.size(); int* count = region.alloc(d); - int* seen = region.alloc(d); std::fill(count,count+d,0); - std::fill(seen,seen+d,-1); - for (int i=0; i(d+1); @@ -248,12 +266,10 @@ namespace PatternMining { /// The threshold-th largest suffix length bounds every frequent extension int remaining(Region& region) const { - int* sizes = region.alloc(data.ends.size()); - int n = 0; - for (int i=0; i= 0) - sizes[n++] = data.ends[i]-cursor[i]; - std::nth_element(sizes,sizes+threshold-1,sizes+n,std::greater()); + int* sizes = region.alloc(size); + for (int i=0; i()); return sizes[threshold-1]; } }; @@ -268,15 +284,18 @@ namespace PatternMining { class OpenProjection : public Propagator { protected: OpenIntVarList list; - Int::IntView length; + Int::IntView length, frequency; Projection projection; + IntSet available; int consumed, subscribed; + /// Filtering depends on the assigned prefix, not on constructed positions + int cached_prefix, extension_bound; OpenProjection(Space& home, OpenIntVarList pattern, - const Database& database, int support) - : Propagator(home), list(pattern), length(pattern.length()), + const Database& database, int support, IntVar count) + : Propagator(home), list(pattern), length(pattern.length()), frequency(count), projection(home,database,support), consumed(0), - subscribed(pattern.prefix_size()) { + subscribed(pattern.prefix_size()), cached_prefix(-1), extension_bound(0) { home.notice(*this,AP_DISPOSE); list.subscribe(home,*this); length.subscribe(home,*this,Int::PC_INT_BND); @@ -286,10 +305,12 @@ namespace PatternMining { } OpenProjection(Space& home, OpenProjection& p) - : Propagator(home,p), projection(home,p.projection), - consumed(p.consumed), subscribed(p.subscribed) { + : Propagator(home,p), projection(home,p.projection), available(p.available), + consumed(p.consumed), subscribed(p.subscribed), + cached_prefix(p.cached_prefix), extension_bound(p.extension_bound) { list.update(home,p.list); length.update(home,p.length); + frequency.update(home,p.frequency); } public: @@ -319,14 +340,30 @@ namespace PatternMining { return ES_FAILED; consumed++; } - Region region; - GECODE_ME_CHECK(length.lq(home,consumed+projection.remaining(region))); - if ((consumed == size) && (length.max() == size)) + GECODE_ME_CHECK(frequency.lq(home,projection.support())); + if ((consumed == size) && (length.max() == size)) { + GECODE_ME_CHECK(frequency.eq(home,projection.support())); return home.ES_SUBSUMED(*this); - const IntSet available = projection.frequent(region,false); + } + if (cached_prefix != consumed) { + Region region; + extension_bound = projection.remaining(region); + GECODE_ME_CHECK(length.lq(home,consumed+extension_bound)); + if ((consumed == size) && (length.max() == size)) { + GECODE_ME_CHECK(frequency.eq(home,projection.support())); + return home.ES_SUBSUMED(*this); + } + available = projection.frequent(region,false); + cached_prefix = consumed; + } else { + GECODE_ME_CHECK(length.lq(home,consumed+extension_bound)); + } if (available.size() == 0) { GECODE_ME_CHECK(length.lq(home,consumed)); - return (consumed == size) ? home.ES_SUBSUMED(*this) : ES_FAILED; + if (consumed != size) + return ES_FAILED; + GECODE_ME_CHECK(frequency.eq(home,projection.support())); + return home.ES_SUBSUMED(*this); } for (int i=consumed; i database.ends.size())) { - home.fail(); - return; - } - (void) new (home) OpenProjection(home,pattern,database,support); + const Database& database, int support, IntVar count) { + (void) new (home) OpenProjection(home,pattern,database,support,count); } }; - /// Require at least support records to contain the pattern as a subsequence - inline void + /// Enforce minimum support and return its exact count when the pattern is complete + inline IntVar frequent(Home home, OpenIntVarList pattern, const Database& database, int support) { - OpenProjection::post(home,pattern,database,support); + if (home.failed()) + return IntVar(); + if ((support < 1) || (support > database.ends.size())) { + home.fail(); + return IntVar(); + } + IntVar count(home,support,database.ends.size()); + OpenProjection::post(home,pattern,database,support,count); + return count; } /// Pattern languages from the example and CP2015 Section 5(d) inline REG language(Language name, const Database& database) { - REG alphabet(IntArgs(database.alphabet.size(),database.alphabet.begin())); - if (name == MOTIF) - return REG(1) + *alphabet + REG(3); if (name == RE10) return *REG(1) + REG(2) + (REG(2) | REG(3)) + *REG(4) + REG(5) + *REG(6) + (REG(7) | REG(8)) + *REG(9); @@ -383,6 +420,9 @@ namespace PatternMining { return *REG(1) + (REG(17) | (REG(2) + *REG(19) + (REG(2) | REG(3)))) + *REG(4) + REG(5) + *(REG(9) | REG(19)) + (REG(6) | REG(8)) + *REG(7) + REG(18); + REG alphabet(IntArgs(database.alphabet.size(),database.alphabet.begin())); + if (name == MOTIF) + return REG(1) + *alphabet + REG(3); return (REG(19) | REG(20)) + alphabet + (REG(18) | REG(11)); } diff --git a/misc/common-pattern/README.md b/misc/common-pattern/README.md index 939ddd579d..fd2acc633b 100644 --- a/misc/common-pattern/README.md +++ b/misc/common-pattern/README.md @@ -24,16 +24,20 @@ The constructor expresses those constraints directly: ```cpp pattern = OpenIntVarList(*this,database.domain(),database.max_length()); rel(*this,pattern.length(),IRT_GQ,opt.min_length()); -PatternMining::frequent(*this,pattern,database,opt.support()); +frequency = PatternMining::frequent(*this,pattern,database,opt.support()); if (opt.language() != PatternMining::NONE) extensional(*this,pattern,PatternMining::language(opt.language(),database)); -REG alphabet(IntArgs(database.alphabet)); -for (int item : opt.required()) - extensional(*this,pattern,*alphabet + REG(item) + *alphabet); +if (!opt.required().empty()) { + REG alphabet(IntArgs(database.alphabet)); + for (int item : opt.required()) + extensional(*this,pattern,*alphabet + REG(item) + *alphabet); +} branch(*this,pattern,INT_VAR_NONE(),INT_VAL_MIN()); ``` -`frequent` is private example support, not a new Gecode library constraint. +`frequent` is private example support, not a new Gecode library constraint. Its +returned `IntVar` gives the exact record count when the pattern is complete; the +example prints that count without searching the database again for every solution. Length, membership and regular constraints apply to the **pattern**. They do not constrain which input positions match it. This follows the distinction between pattern, cover, embedding and output constraints in Negrevergne and Guns, @@ -56,8 +60,11 @@ it retains the input suffixes that can extend the current pattern. One earliest matching cursor per supporting record suffices for ordinary subsequences. It filters locally infrequent items from constructed positions and bounds further growth by the remaining supporting suffix lengths. Immutable, rank-compressed -data are shared between spaces; each space owns its cursors. Sparse integer IDs -are preserved in output. +data are shared between spaces; each space owns a compact array of its supporting +suffixes. Cloning copies only live entries. A last-occurrence index counts each +item once per suffix without scanning repeated occurrences. The open propagator +reuses its frequent-item set and length bound when growth has not changed the +assigned prefix. Sparse integer IDs are preserved in output. This adapts Kemmar et al., [PREFIX-PROJECTION Global Constraint for Sequential Pattern Mining](https://loudni.users.greyc.fr/Papers/cp15final.pdf), @@ -67,8 +74,9 @@ also addresses a cost identified in Aoga, Guns and Schaus, [An Efficient Algorithm for Mining Frequent Sequence with Constraint Programming](https://arxiv.org/abs/1604.01166), ECML PKDD 2016, §4.2: filtering and restoring future array positions that the search may never use. Their implementation filters only the next position and optimizes -suffix scans and state restoration. The example does not reproduce those -optimizations or establish a speedup; the comparisons below distinguish variable +suffix scans and state restoration. The shared helper uses their last-occurrence idea for frequency counting, while +restoration uses Gecode cloning. It does not implement their incremental counting +or reversible-vector algorithm. The comparisons below distinguish variable representation from filtering strength. The input scope is sequences of **individual items**, not sequences of itemsets. @@ -161,10 +169,14 @@ compiler and flags but does not verify them automatically. | --- | --- | --- | | `open-projection` | `OpenIntVarList` | Local item support and remaining-suffix length bound, including initial filtering | | `padded-projection` | Fixed array, zero termination | Same extra pruning, applied to all preallocated positions | -| `paper-projection` | Fixed array, zero termination | Algorithms 1–2 reimplementation, without added initial scheduling or suffix-length pruning | +| `paper-projection` | Fixed array, zero termination | Algorithm 2 filtering rules with initial pruning, without suffix-length pruning | | `open-dfa`, `padded-dfa` | Open list or padded array | Per-input subsequence DFAs; require all-input support | -The first two variants help assess the representation using the same extra pruning. +All three projection variants use the same compact suffixes and last-occurrence +index. All filter initially: omitting that step caused thousands of avoidable +failures on globally infrequent first items and made the old paper baseline +misleadingly slow. The first two variants help assess the representation using the +same extra pruning. Their regular constraints still propagate differently because the open constraint sees constructed positions and the ordinary constraint sees the entire array. The paper variant distinguishes the effect of additional pruning. Nodes and @@ -206,14 +218,20 @@ Select DFAs explicitly with `--support 100 --variants open-dfa padded-dfa open-projection padded-projection paper-projection`. The default companion invocation from the previous comparison remains valid. -Before timing, the runner checks duplicate output, item/length/language constraints, -and actual record support. All variants must enumerate exactly the same set. +Before timing, the runner checks duplicate output and item/length/language constraints. +It compares exact output with an independent oracle when available; otherwise it +checks actual record support. All variants must enumerate exactly the same set. An independent oracle enumerates subsequences of the `n-k+1` shortest records: every pattern supported by `k` out of `n` records occurs in at least one of those records. The oracle runs when each chosen record has at most 16 items and their combined subset budget is at most 200,000. Otherwise feasibility and agreement are checked, with independent completeness explicitly unavailable. The smoke matrix -meets the oracle budget at every threshold. +meets the oracle budget at every threshold. For a larger custom query, `--reference` +accepts the exact output of an independent miner normalized to one positive-integer +pattern per line. It requires one database and one support threshold. Reference +validation compares the entire set and is labelled separately from exhaustive +subset enumeration. The caller must match the database, support rounding, length +and other constraints; the runner checks the reference file's content on resume. Measured runs count solutions without printing. The target timer includes rank compression, model construction, complete DFS and solution disposal; it excludes @@ -235,9 +253,105 @@ reports failures/unfinished work beside successful medians and ranges in seconds The authors' project link required Google sign-in when checked on 2026-10-13. These baselines are -reimplementations, not their executable. Real dataset versions and label mappings -still need checking before comparison with published pattern counts. Historical -CPU seconds on the paper's Xeon X5670 are not a runtime baseline for this machine. +reimplementations, not their executable. Public SPMF datasets now provide the real-data comparison below. Their bytes and +label mappings are not verified against the authors' copies. Historical CPU seconds +on the paper's Xeon X5670 are not a runtime baseline for this machine. + +## Real-data performance and independent comparison + +The [SPMF dataset collection](https://www.philippe-fournier-viger.com/spmf/index.php?link=datasets.php) +provides Bible and Leviathan copies whose record counts, alphabets and length +statistics match Table 2. The current public FIFA file has a different mean length, +so it is excluded from comparison with the paper. No dataset or external executable +is bundled with Gecode. + +On 2026-10-13, full Bible mining at 1% support produced the paper's 23,340 patterns. +An independent [SPMF PrefixSpan](https://www.philippe-fournier-viger.com/spmf/PrefixSpan.php) +run agreed on the complete pattern set, not only its size. Filtering that output by +its exact support counts also supplies the references at 5% (774 patterns) and 10% +(174 patterns). This provides an independent completeness check beyond the small +subset oracle's budget. + +The before/after runs use AppleClang 21, `-O3 -DNDEBUG`, macOS 26.6.2 / arm64, +serial single-threaded searches, three shuffled repetitions, and the maximum-input +length bound. Times below are median model construction plus complete enumeration +in seconds, counting solutions without printing. Input parsing is excluded. + +| Bible query | Patterns | Open before | Open now | Padded now | Paper-style now | +| --- | ---: | ---: | ---: | ---: | ---: | +| Support 10% | 174 | 0.313 | 0.199 | 0.197 | 0.178 | +| Support 5% | 774 | 0.814 | 0.495 | 0.497 | 0.462 | +| Support 1% | 23,340 | 8.359 | 4.120 | 4.411 | 4.314 | +| Support 1%, length ≥3, contains IDs 10 and 356 | 8,449 | — | 17.132 | 7.153 | — | + +The padded model before these changes took 8.268 seconds at 1% support, so shared +projection changes improve both representations. The actual example also printed +all 23,340 patterns with exact PrefixSpan support counts in 4.391 seconds +end-to-end in one correctness run, timed through process completion before +reference validation. Its output no longer triggers one full database scan per +pattern. These frequent patterns have lengths 1–11 although the safe input-length +bound is 100; the open model creates actual positions as the pattern grows. + +Required-item constraints favour the padded model here: its future positions let +regular constraints detect impossible completions earlier. The open regular +constraint checks an extendable prefix, so it explores more prefixes before +proving that a required item cannot occur. These are the same output query, not +different mining semantics. That propagation tradeoff remains. + +A controlled repetitive workload makes the representation cost visible: 64 records +contain 600–1,230 copies of one item. At 100% support, exactly 600 patterns exist. +The reference is the independently derived set of lengths 1 through 600. Median +model-plus-search times in **milliseconds** were: + +| Length bound | Open projection | Padded projection | Paper-style projection | +| --- | ---: | ---: | ---: | +| Longest input, 1,230 | 2.747 | 15.492 | 17.291 | +| Shortest input, 600 | 2.790 | 6.796 | 6.679 | + +Even with the tighter valid bound, the open model avoids handling unused suffix +positions for shorter patterns. This is a controlled case, not evidence that open +lists win on every database. Before the shared optimizations, the longest-bound +open and padded variants took 14.070 and 26.202 milliseconds respectively. + +The open and improved fixed-array models are close on unrestricted Bible mining. +These results do not establish a general open-list speed advantage. The example's +strength is representing actual pattern positions and composing ordinary CP +constraints without a termination convention. The original DFA timings answer a +different algorithm question and should not be used to judge projection-based +open lists. + +A repeatable independent-reference comparison is: + +```sh +curl -L -A 'Mozilla/5.0' \ + https://www.philippe-fournier-viger.com/spmf/publicdatasets/BIBLE.txt -o BIBLE.txt +# Download spmf.jar from the SPMF release page. +java -jar spmf.jar run PrefixSpan BIBLE.txt bible-patterns.spmf 1% 1 100 false +python3 - <<'PYTHON' > bible-patterns.txt +from pathlib import Path +for line in Path('bible-patterns.spmf').read_text().splitlines(): + if line.startswith('@'): + continue + tokens = line.split('#SUP:')[0].split() + assert len(tokens) % 2 == 0 and all(t == '-1' for t in tokens[1::2]) + print(' '.join(tokens[::2])) +PYTHON +uv run --script misc/common-pattern/benchmark.py run \ + --name bible --binary build/common-pattern-benchmark/bin/common-pattern-compare \ + --build-label 'your compiler; Release; -O3 -DNDEBUG' \ + --database BIBLE.txt --format spmf --support 1 --reference bible-patterns.txt +uv run --script misc/common-pattern/benchmark.py analyze --name bible +``` + +Reference generation is outside the target timer. SPMF's reported algorithm time +and the native model-plus-search time have different boundaries, so these runs +establish query agreement rather than an equal-cost timing comparison with Java. +Raw configurations, outputs and samples remain in `bible-before`, +`bible-original-1`, `bible-final-1`, `bible-final-5`, `bible-final-10`, +`bible-final-required`, `repetitive-original`, `repetitive-final`, and +`repetitive-final-shortest` under `build/common-pattern-results/`. The +shared last-occurrence index uses additional immutable storage; both open and +padded models share it across clones. ## Literature and comparison scope diff --git a/misc/common-pattern/benchmark.py b/misc/common-pattern/benchmark.py index 2809bb400f..982af4b8ab 100755 --- a/misc/common-pattern/benchmark.py +++ b/misc/common-pattern/benchmark.py @@ -167,6 +167,15 @@ def frequent_patterns(case: dict) -> set[tuple[int, ...]] | None: and sum(is_subsequence(pattern, s) for s in sequences) >= case["min_support"]} +def read_patterns(path: Path) -> set[tuple[int, ...]]: + """Read an independent miner's output normalized to one integer pattern per line.""" + patterns = [tuple(map(int, line.split())) for line in path.read_text().splitlines()] + if (len(set(patterns)) != len(patterns) or any(not p or + any(item < 1 or item > 2147483646 for item in p) for p in patterns)): + raise ValueError("expected distinct nonempty positive integer patterns") + return set(patterns) + + def is_subsequence(pattern: tuple[int, ...], sequence: list[int]) -> bool: items = iter(sequence) return all(item in items for item in pattern) @@ -218,7 +227,8 @@ def kill_process_group(process: subprocess.Popen) -> None: def check_patterns(result: dict, output: Path, case: dict, - expected: set[tuple[int, ...]] | None) -> dict: + expected: set[tuple[int, ...]] | None, + oracle: str = "exhaustive") -> dict: if result["status"] != "ok": return result try: @@ -228,13 +238,14 @@ def check_patterns(result: dict, output: Path, case: dict, actual = set(patterns) if (len(patterns) != result["metrics"]["solutions"] or len(actual) != len(patterns) or - any(not accepts(p, case) or - sum(is_subsequence(p, s) for s in case["sequences"]) < case["min_support"] - for p in patterns) or (expected is not None and actual != expected)): + any(not accepts(p, case) for p in patterns) or + (actual != expected if expected is not None else + any(sum(is_subsequence(p, s) for s in case["sequences"]) < case["min_support"] + for p in patterns))): return {**result, "status": "invalid", "detail": "incorrect pattern enumeration"} fingerprint = hashlib.sha256(json.dumps(sorted(actual)).encode()).hexdigest() return {**result, "patterns_sha256": fingerprint, - "oracle": "exhaustive" if expected is not None else "feasibility"} + "oracle": oracle if expected is not None else "feasibility"} def valid_record(path: Path, identity: dict, validation: bool = False) -> dict | None: @@ -261,7 +272,7 @@ def valid_record(path: Path, identity: dict, validation: bool = False) -> dict | raise ValueError("invalid saved metrics") if validation and (not re.fullmatch("[0-9a-f]{64}", record.get("patterns_sha256", "")) or - record.get("oracle") not in ("exhaustive", "feasibility")): + record.get("oracle") not in ("exhaustive", "reference", "feasibility")): raise ValueError("missing correctness evidence") return record except (ValueError, TypeError, KeyError) as error: @@ -281,6 +292,9 @@ def collect(args: argparse.Namespace, directory: Path) -> None: workloads = cases(args.seed, args.suite, args.database, args.language, args.format, args.support, args.min_length, args.required) variants = args.variants + if args.reference and (not args.database or len(workloads) != 1): + raise ValueError("reference output requires one custom database query") + reference = read_patterns(args.reference) if args.reference else None if len(set(variants)) != len(variants): raise ValueError("duplicate variants") if any(case["min_support"] < len(case["sequences"]) for case in workloads) and ( @@ -302,6 +316,9 @@ def collect(args: argparse.Namespace, directory: Path) -> None: "cases": workloads, "repetitions": args.repetitions, "seed": args.seed, "timeout_seconds": args.timeout, "bound": args.bound, "variants": variants} + if args.reference: + config["reference"] = {"path": str(args.reference.resolve()), + "sha256": digest(args.reference)} print(f"{len(workloads)} cases; {len(workloads)*len(variants)} correctness runs; " f"{len(workloads)*len(variants)*args.repetitions} measured runs; " f"{args.timeout}s timeout per invocation; bound={args.bound}") @@ -324,7 +341,7 @@ def collect(args: argparse.Namespace, directory: Path) -> None: for case in workloads: database = directory / "inputs" / (case["id"] + ".txt") database.write_text("\n".join(" ".join(map(str, s)) for s in case["sequences"]) + "\n") - oracle = frequent_patterns(case) + oracle = reference if reference is not None else frequent_patterns(case) checks = [] for variant in variants: identity = {"case": case["id"], "variant": variant} @@ -334,7 +351,8 @@ def collect(args: argparse.Namespace, directory: Path) -> None: cmd = command(str(binary), case, variant, database, "print", args.bound) record = execute(cmd, path.with_suffix(".stdout"), path.with_suffix(".stderr"), args.timeout) - record = check_patterns(record, path.with_suffix(".stdout"), case, oracle) + record = check_patterns(record, path.with_suffix(".stdout"), case, oracle, + "reference" if reference is not None else "exhaustive") record.update(identity) save_json(path, record) checks.append(record) @@ -435,6 +453,8 @@ def main() -> None: run.add_argument("--build-label", required=True, help="compiler, flags and build configuration") run.add_argument("--suite", choices=("smoke", "scaling"), default="smoke") run.add_argument("--database", type=Path, help="custom database, one sequence per line") + run.add_argument("--reference", type=Path, + help="exact independent output for one custom query; integer patterns, one per line") run.add_argument("--language", choices=tuple(LANGUAGES), default="none", help="restriction for a custom database") run.add_argument("--format", choices=("letters", "integers", "spmf"), default="letters") diff --git a/misc/common-pattern/compare.cpp b/misc/common-pattern/compare.cpp index af8810487b..09a1c5daf4 100644 --- a/misc/common-pattern/compare.cpp +++ b/misc/common-pattern/compare.cpp @@ -54,9 +54,9 @@ namespace { /** * \brief CP2015 Algorithm 2, with an optional extension-length bound * - * The paper baseline filters after contiguous prefix assignments. The - * padded-projection variant also filters initially and caps remaining - * nonzero positions, matching the shared open projection's extra pruning. + * The paper baseline filters after contiguous prefix assignments. + * All variants filter initially. The padded-projection variant also caps + * remaining nonzero positions, matching the open projection's length bound. * Both retain the paper's fixed positions and zero termination. */ class PaperProjection : public NaryPropagator { @@ -64,7 +64,7 @@ namespace { Projection projection; /// Number of consumed contiguous pattern positions int consumed; - /// Match the open projection's initial filtering and suffix-length cap + /// Match the open projection's suffix-length cap bool bounded; public: PaperProjection(Space& home, ViewArray& x, @@ -72,8 +72,8 @@ namespace { : NaryPropagator(home,x), projection(home,database,support), consumed(0), bounded(cap) { home.notice(*this,AP_DISPOSE); - if (bounded) - Int::IntView::schedule(home,*this,Int::ME_INT_VAL); + // Filter infrequent items at the root in every projection baseline. + Int::IntView::schedule(home,*this,Int::ME_INT_VAL); } PaperProjection(Space& home, PaperProjection& p) @@ -176,13 +176,15 @@ namespace { else extensional(*this,padded,expression + *REG(0)); } - REG alphabet(IntArgs(database.alphabet.size(),database.alphabet.begin())); - for (int item : required) { - REG contains = *alphabet + REG(item) + *alphabet; - if (growing) - extensional(*this,open,contains); - else - extensional(*this,padded,contains + *REG(0)); + if (!required.empty()) { + REG alphabet(IntArgs(database.alphabet.size(),database.alphabet.begin())); + for (int item : required) { + REG contains = *alphabet + REG(item) + *alphabet; + if (growing) + extensional(*this,open,contains); + else + extensional(*this,padded,contains + *REG(0)); + } } if (growing) branch(*this,open,INT_VAR_NONE(),INT_VAL_MIN()); diff --git a/test/int/open-var-list.cpp b/test/int/open-var-list.cpp index 65b70d4247..ffd29888a4 100644 --- a/test/int/open-var-list.cpp +++ b/test/int/open-var-list.cpp @@ -1047,16 +1047,18 @@ namespace Test { namespace Int { class PatternSpace : public Gecode::Space { public: Gecode::OpenIntVarList list; + Gecode::IntVar frequency; PatternSpace(const PatternMining::Database& data, int support) : list(*this,data.domain(),data.max_length()) { Gecode::rel(*this,list.length(),Gecode::IRT_GQ,1); - PatternMining::frequent(*this,list,data,support); + frequency = PatternMining::frequent(*this,list,data,support); Gecode::branch(*this,list); } PatternSpace(PatternSpace& s) : Gecode::Space(s) { list.update(*this,s.list); + frequency.update(*this,s.frequency); } virtual Gecode::Space* copy(void) { @@ -1127,7 +1129,9 @@ namespace Test { namespace Int { return false; pattern.push_back(solution->list[i].val()); } - if (!found.insert(pattern).second) + if (!solution->frequency.assigned() || + (solution->frequency.val() != data.support(pattern)) || + !found.insert(pattern).second) return false; } if (found != expected) From af937ffb7e1a7ed196b2f2d002a176869a5dd736 Mon Sep 17 00:00:00 2001 From: Mikael Zayenz Lagerkvist Date: Tue, 13 Oct 2026 21:23:08 +0200 Subject: [PATCH 24/34] Rename open-list prefix query to known_length --- examples/common-pattern.cpp | 2 +- examples/common-pattern.hh | 4 +-- examples/open-route.cpp | 2 +- gecode/int.hh | 8 ++--- gecode/int/extensional-open-regular.cpp | 8 ++--- gecode/int/open-var-list.cpp | 36 ++++++++++---------- gecode/int/open-var-list.hpp | 4 +-- misc/common-pattern/README.md | 4 +++ misc/common-pattern/compare.cpp | 2 +- test/int/extensional.cpp | 14 ++++---- test/int/open-var-list.cpp | 44 ++++++++++++------------- 11 files changed, 66 insertions(+), 62 deletions(-) diff --git a/examples/common-pattern.cpp b/examples/common-pattern.cpp index 8683a40aa0..8c302364e5 100644 --- a/examples/common-pattern.cpp +++ b/examples/common-pattern.cpp @@ -205,7 +205,7 @@ class CommonPattern : public IntMaximizeScript { virtual void print(std::ostream& os) const { os << "\t"; - for (int i=0; i 0) os << " -> "; os << route[i]; diff --git a/gecode/int.hh b/gecode/int.hh index 164895484d..eb74eb9297 100755 --- a/gecode/int.hh +++ b/gecode/int.hh @@ -2429,7 +2429,7 @@ namespace Gecode { * * Variables can be appended until the list is closed. The length * variable denotes the eventual list length. Propagation materializes - * positions required by its minimum. The prefix_size() query counts the + * positions required by its minimum. The known_length() query counts the * positions already constructed. Indexed access is limited to this prefix; * get() creates positions and requires enough eventual length to include * the requested position. @@ -2512,8 +2512,8 @@ namespace Gecode { int max=Int::Limits::max); /// Update during cloning void update(Space& home, OpenVarList& s); - /// Return the number of materialized positions - int prefix_size(void) const; + /// Return the number of constructed positions (their values may be unassigned) + int known_length(void) const; /// Return variable at position \a i (\a i must be a valid position) Var operator [](int i) const; /// Return the eventual-length variable @@ -6162,7 +6162,7 @@ namespace Gecode { * * Selectors consider all materialized positions accepted by the filter. * Once these variables are assigned, the brancher first tries to close at - * prefix_size(), then requires at least one more position and resumes + * known_length(), then requires at least one more position and resumes * value selection. Filters and callbacks receive the position in the list. * With no finite application bound, exploring these lengths can be very * expensive. diff --git a/gecode/int/extensional-open-regular.cpp b/gecode/int/extensional-open-regular.cpp index d3349b9792..9456c2792b 100644 --- a/gecode/int/extensional-open-regular.cpp +++ b/gecode/int/extensional-open-regular.cpp @@ -53,7 +53,7 @@ namespace Gecode { namespace Int { namespace Extensional { length(list0.length()), dfa(dfa0), start(static_cast(home).alloc(dfa.n_states())), - offset(0), subscribed(list0.prefix_size()) { + offset(0), subscribed(list0.known_length()) { home.notice(*this,AP_DISPOSE); for (int i=0; i(n+1) * @@ -167,7 +167,7 @@ namespace Gecode { namespace Int { namespace Extensional { virtual ExecStatus propagate(Space& home, const ModEventDelta&) { - const int size = list.prefix_size(); + const int size = list.known_length(); assert(size <= length.max()); for (int i=subscribed; i list, DFA dfa) { - for (int i=0; i 0) && seen.one()) return home.ES_SUBSUMED(*this); - const int size = list.prefix_size(); + const int size = list.known_length(); for (int i=posted; i x(r,list.prefix_size()); + ViewArray x(r,list.known_length()); for (int i=0; i list.prefix_size(); + return list.length().max() > list.known_length(); } virtual const Choice* choice(Space& home) { - for (int i=start; i(*this,2,Pos(p),vsc->val(home,x,p)) : value_choice(*this,p,x); } - return new PosValChoice(*this,2,Pos(-1),list.prefix_size()); + return new PosValChoice(*this,2,Pos(-1),list.known_length()); } virtual const Choice* @@ -625,7 +625,7 @@ namespace Gecode { namespace Int { const int p = static_cast(c).pos().pos; if (p >= 0) { // Recomputation can replay choices before propagation grows the prefix. - if (p >= list.prefix_size()) { + if (p >= list.known_length()) { list.materialize(home,p+1); if (home.failed()) return ES_FAILED; @@ -652,7 +652,7 @@ namespace Gecode { namespace Int { (home,IntView(list.length()), static_cast&>(c).val()) : nullptr; // No-good extraction can run in an ancestor with a shorter prefix. - if (p >= list.prefix_size()) + if (p >= list.known_length()) return nullptr; View x(list[p]); return vsc @@ -766,11 +766,11 @@ namespace Gecode { namespace Int { (selectors[n].select() != VarBranch::SEL_NONE)) n++; typedef typename View::VarType Var; - typename ArrayTraits>::ArgsType x(list.prefix_size()); + typename ArrayTraits>::ArgsType x(list.known_length()); for (int i=0; i list.prefix_size()); + check_open_selector(selectors[i],list.length().max() > list.known_length()); selectors[i].expand(home,x); } const IntValBranch::Select values = diff --git a/gecode/int/open-var-list.hpp b/gecode/int/open-var-list.hpp index f46c56c8c2..b3f14fd47b 100644 --- a/gecode/int/open-var-list.hpp +++ b/gecode/int/open-var-list.hpp @@ -169,7 +169,7 @@ namespace Gecode { namespace Int { virtual PropCost cost(const Space&, const ModEventDelta&) const { - const int n = length.min()-list.prefix_size(); + const int n = length.min()-list.known_length(); return (n <= 1) ? PropCost::unary(PropCost::LO) : PropCost::linear(PropCost::LO,n); } @@ -240,7 +240,7 @@ namespace Gecode { template int - OpenVarList::prefix_size(void) const { + OpenVarList::known_length(void) const { return static_cast(object())->n; } diff --git a/misc/common-pattern/README.md b/misc/common-pattern/README.md index fd2acc633b..bb12170540 100644 --- a/misc/common-pattern/README.md +++ b/misc/common-pattern/README.md @@ -55,6 +55,10 @@ transitions in additional pattern languages. Constraints follow growth; when no frequent extension remains, the list closes. `open-route` is the smaller introduction to construction, cloning and search. +`known_length()` counts the positions already constructed, including positions +whose values are still unassigned. `length()` is the variable for the eventual +list length. + The private frequency propagator uses prefix projection: after assigning an item, it retains the input suffixes that can extend the current pattern. One earliest matching cursor per supporting record suffices for ordinary subsequences. It diff --git a/misc/common-pattern/compare.cpp b/misc/common-pattern/compare.cpp index 09a1c5daf4..b52e8e69d3 100644 --- a/misc/common-pattern/compare.cpp +++ b/misc/common-pattern/compare.cpp @@ -205,7 +205,7 @@ namespace { void print(Format format) const { const bool growing = (model == Model::OpenDFA) || (model == Model::OpenProjection); - const int n = growing ? open.prefix_size() : padded.size(); + const int n = growing ? open.known_length() : padded.size(); for (int i=0; ilist.length(),IRT_GQ,5); const bool clone_ok = (clone->status() != SS_FAILED) && - (clone->list.prefix_size() == 5) && + (clone->list.known_length() == 5) && clone->list[4].assigned() && (clone->list[4].val() == 4); delete clone; - if (!clone_ok || (source.list.prefix_size() != 3)) + if (!clone_ok || (source.list.known_length() != 3)) return false; OpenListSpace direct; IntVar x = direct.list.get(direct,3); - return (direct.list.prefix_size() == 4) && + return (direct.list.known_length() == 4) && (direct.list.length().min() == 4) && x.assigned() && (x.val() == 3) && (direct.status() != SS_FAILED); @@ -979,7 +979,7 @@ namespace Test { namespace Int { rel(s,s.list.length(),IRT_GQ,2); if (s.status() == SS_FAILED) return false; - return (s.list.prefix_size() == 2) && + return (s.list.known_length() == 2) && s.list[0].assigned() && (s.list[0].val() == 0) && s.list[1].assigned() && @@ -1063,13 +1063,13 @@ namespace Test { namespace Int { clone->list.close(*clone); const bool clone_ok = (clone->status() != SS_FAILED) && - (clone->list.prefix_size() == 2); + (clone->list.known_length() == 2); delete clone; source.list.close(source); const bool source_failed = source.status() == SS_FAILED; return clone_ok && source_failed && - (source.list.prefix_size() == 1); + (source.list.known_length() == 1); } }; diff --git a/test/int/open-var-list.cpp b/test/int/open-var-list.cpp index ffd29888a4..d4c2df03a8 100644 --- a/test/int/open-var-list.cpp +++ b/test/int/open-var-list.cpp @@ -91,7 +91,7 @@ namespace Test { namespace Int { int solutions = 0; while (BranchSpace* solution = engine.next()) { - const int size = solution->list.prefix_size(); + const int size = solution->list.known_length(); bool valid = solution->list.length().assigned() && (solution->list.length().val() == size); @@ -155,7 +155,7 @@ namespace Test { namespace Int { int first = -1; while (BranchOrderSpace* solution = engine.next()) { if (solutions == 0) - first = solution->list.prefix_size(); + first = solution->list.known_length(); solutions++; delete solution; } @@ -222,8 +222,8 @@ namespace Test { namespace Int { int solutions = 0; while (SelectorSpace* solution = engine.next()) { bool valid = solution->list.length().assigned() && - (solution->list.length().val() == solution->list.prefix_size()); - for (int i=0; ilist.prefix_size(); i++) + (solution->list.length().val() == solution->list.known_length()); + for (int i=0; ilist.known_length(); i++) valid &= solution->list[i].assigned() && (solution->list[i].val() >= i) && (solution->list[i].val() <= i+1); @@ -258,7 +258,7 @@ namespace Test { namespace Int { bool found[16] = {}; const auto record = [&found](SelectorSpace* solution) { int code = 1; - for (int i=0; ilist.prefix_size(); i++) + for (int i=0; ilist.known_length(); i++) code = 2*code + solution->list[i].val()-i; found[code] = true; delete solution; @@ -404,9 +404,9 @@ namespace Test { namespace Int { int solutions = 0; while (BoolSpace* solution = engine.next()) { bool valid = solution->list.length().assigned() && - (solution->list.length().val() == solution->list.prefix_size()); + (solution->list.length().val() == solution->list.known_length()); int ones = 0; - for (int i=0; ilist.prefix_size(); i++) { + for (int i=0; ilist.known_length(); i++) { valid &= solution->list[i].assigned(); ones += solution->list[i].val(); } @@ -486,14 +486,14 @@ namespace Test { namespace Int { bool valid = (clone->status() != SS_FAILED) && (source.status() != SS_FAILED); #ifdef GECODE_HAS_SET_VARS - valid &= (source.sets.prefix_size() == 1) && - (clone->sets.prefix_size() == 3) && + valid &= (source.sets.known_length() == 1) && + (clone->sets.known_length() == 3) && (clone->sets.length().val() == 3) && clone->sets[2].assigned() && (clone->sets[2].glbMin() == 2); #endif #ifdef GECODE_HAS_FLOAT_VARS - valid &= (source.floats.prefix_size() == 1) && - (clone->floats.prefix_size() == 3) && + valid &= (source.floats.known_length() == 1) && + (clone->floats.known_length() == 3) && (clone->floats.length().val() == 3) && clone->floats[2].assigned() && (clone->floats[2].min() == 2); #endif @@ -595,8 +595,8 @@ namespace Test { namespace Int { bool valid = solution->list.length().assigned() && (solution->list.length().val() == - solution->list.prefix_size()); - for (int i=0; ilist.prefix_size(); i++) + solution->list.known_length()); + for (int i=0; ilist.known_length(); i++) valid &= solution->list[i].assigned() && (solution->list[i].val() == i); delete solution; @@ -769,7 +769,7 @@ namespace Test { namespace Int { clone->minimum.assigned() && (clone->minimum.val() == 0) && clone->maximum.assigned() && (clone->maximum.val() == 2); delete clone; - return valid && (source.list.prefix_size() == 1); + return valid && (source.list.known_length() == 1); } }; @@ -921,7 +921,7 @@ namespace Test { namespace Int { if (close) source.list.close(source); if ((source.status() == SS_FAILED) || - (source.list.prefix_size() != 3)) + (source.list.known_length() != 3)) return false; } return true; @@ -966,7 +966,7 @@ namespace Test { namespace Int { CallbackSpace* clone = static_cast(source.clone()); rel(*clone,clone->list.length(),IRT_GQ,2); clone->commit(*choice,alternative); - valid &= !clone->failed() && (clone->list.prefix_size() == 1) && + valid &= !clone->failed() && (clone->list.known_length() == 1) && clone->list[0].assigned() && (clone->list[0].val() == static_cast(alternative)); valid &= clone->status() == SS_FAILED; @@ -1003,14 +1003,14 @@ namespace Test { namespace Int { (static_cast(source.clone())); source.commit(*first,0); if ((source.status() != SS_BRANCH) || - (source.list.prefix_size() != 2)) + (source.list.known_length() != 2)) return false; std::unique_ptr second(source.choice()); // Recomputation commits the path without propagating between choices. replay->commit(*first,0); replay->commit(*second,0); return (replay->status() != SS_FAILED) && - (replay->list.prefix_size() == 2) && + (replay->list.known_length() == 2) && replay->list[0].assigned() && (replay->list[0].val() == 0) && replay->list[1].assigned() && (replay->list[1].val() == 0); } @@ -1036,7 +1036,7 @@ namespace Test { namespace Int { const bool failed = source.status() == SS_FAILED; if (failed != (size == 2)) return false; - if (!failed && (source.list.prefix_size() != size)) + if (!failed && (source.list.known_length() != size)) return false; } return true; @@ -1121,10 +1121,10 @@ namespace Test { namespace Int { std::unique_ptr owned(solution); if (!solution->list.length().assigned() || (solution->list.length().val() != - solution->list.prefix_size())) + solution->list.known_length())) return false; std::vector pattern; - for (int i=0; ilist.prefix_size(); i++) { + for (int i=0; ilist.known_length(); i++) { if (!solution->list[i].assigned()) return false; pattern.push_back(solution->list[i].val()); @@ -1163,7 +1163,7 @@ namespace Test { namespace Int { if ((clone->status() == SS_FAILED) || !clone->list.length().assigned() || (clone->list.length().val() != 2) || - (source.list.prefix_size() != 1) || + (source.list.known_length() != 1) || (source.list.length().min() != 1)) return false; source.list.materialize(source,2); From 4f2b565373a79c082096d59185f19f3ad32d5f3f Mon Sep 17 00:00:00 2001 From: Mikael Zayenz Lagerkvist Date: Tue, 13 Oct 2026 21:23:08 +0200 Subject: [PATCH 25/34] Apply coding style guidance to pattern benchmark --- misc/common-pattern/benchmark.py | 565 ++++++++++++++++++++++--------- 1 file changed, 403 insertions(+), 162 deletions(-) diff --git a/misc/common-pattern/benchmark.py b/misc/common-pattern/benchmark.py index 982af4b8ab..b2bb49fe40 100755 --- a/misc/common-pattern/benchmark.py +++ b/misc/common-pattern/benchmark.py @@ -9,13 +9,10 @@ """ import argparse -from collections import Counter -from decimal import Decimal, ROUND_CEILING import hashlib import json import math import os -from pathlib import Path import platform import random import re @@ -24,7 +21,9 @@ import subprocess import sys import time - +from collections import Counter +from decimal import ROUND_CEILING, Decimal +from pathlib import Path VARIANTS = ("open-projection", "padded-projection", "paper-projection") ALL_VARIANTS = VARIANTS + ("open-dfa", "padded-dfa") @@ -35,8 +34,7 @@ "re14": r"A*(Q|BS*(B|C))D*E(I|S)*(F|H)G*R", "re2": r"(S|T)[A-Z](R|K)", } -METRICS = ("solutions", "nodes", "failures", "propagations", - "model_search_seconds") +METRICS = ("solutions", "nodes", "failures", "propagations", "model_search_seconds") def digest(path: Path) -> str: @@ -49,8 +47,7 @@ def save_json(path: Path, value: object) -> None: temporary.replace(path) -def planted(rng: random.Random, pattern: str, count: int, - noise: int) -> list[str]: +def planted(rng: random.Random, pattern: str, count: int, noise: int) -> list[str]: """Keep the pattern's order while inserting independently sampled items.""" sequences = [] for _ in range(count): @@ -73,9 +70,15 @@ def read_database(path: Path, format: str) -> list[list[int]]: else: tokens = [int(token) for token in line.split()] if format == "spmf": - if (not tokens or tokens[-1] != -2 or len(tokens) % 2 != 1 or - any(tokens[i] != -1 for i in range(1, len(tokens) - 1, 2))): - raise ValueError("SPMF sequences require singleton itemsets and -2 termination") + if ( + not tokens + or tokens[-1] != -2 + or len(tokens) % 2 != 1 + or any(tokens[i] != -1 for i in range(1, len(tokens) - 1, 2)) + ): + raise ValueError( + "SPMF sequences require singleton itemsets and -2 termination" + ) sequence = tokens[:-1:2] else: sequence = tokens @@ -96,12 +99,24 @@ def support_count(percent: str, records: int) -> int: return int((records * value / 100).to_integral_value(rounding=ROUND_CEILING)) -def cases(seed: int, suite: str, database: Path | None, - restriction: str, format: str, supports: list[str], - min_length: int, required: list[int]) -> list[dict]: +def cases( + seed: int, + suite: str, + database: Path | None, + restriction: str, + format: str, + supports: list[str], + min_length: int, + required: list[int], +) -> list[dict]: if database: - base = [{"id": "input", "sequences": read_database(database, format), - "language": restriction}] + base = [ + { + "id": "input", + "sequences": read_database(database, format), + "language": restriction, + } + ] else: rng = random.Random(seed) workloads = [ @@ -112,26 +127,66 @@ def cases(seed: int, suite: str, database: Path | None, ] if suite == "scaling": for count in (8, 32, 128): - workloads.append((f"database-{count}", planted(rng, "ABCABC", count, 10), - ["none", "motif"])) + workloads.append( + ( + f"database-{count}", + planted(rng, "ABCABC", count, 10), + ["none", "motif"], + ) + ) for noise in (8, 32, 128): - workloads.append((f"input-noise-{noise}", - ["ABCBC"] + planted(rng, "ABCBC", 7, noise), ["none", "motif"])) + workloads.append( + ( + f"input-noise-{noise}", + ["ABCBC"] + planted(rng, "ABCBC", 7, noise), + ["none", "motif"], + ) + ) for length in (4, 8, 12): pattern = ("ABC" * 4)[:length] - workloads.append((f"pattern-{length}", [pattern] + planted(rng, pattern, 7, 12), ["none"])) - workloads.extend([ - ("paper-re10", ["AABCDDEFFGII"] + planted(rng, "AABCDDEFFGII", 7, 8), ["re10"]), - ("paper-re14", ["AABCDDEISHGGR"] + planted(rng, "AABCDDEISHGGR", 7, 8), ["re14"]), - ("paper-re2", ["SAR"] + planted(rng, "SAR", 7, 16), ["re2"]), - ]) - base = [{"id": f"{name}-{language}", "language": language, - "sequences": [[ord(a) - ord("A") + 1 for a in s] for s in sequences]} - for name, sequences, languages in workloads for language in languages] - result = [{**case, "id": f"{case['id']}-support-{percent}", "support_percent": percent, - "min_support": support_count(percent, len(case["sequences"])), - "min_length": min_length, "required": required} - for case in base for percent in supports] + workloads.append( + ( + f"pattern-{length}", + [pattern] + planted(rng, pattern, 7, 12), + ["none"], + ) + ) + workloads.extend( + [ + ( + "paper-re10", + ["AABCDDEFFGII"] + planted(rng, "AABCDDEFFGII", 7, 8), + ["re10"], + ), + ( + "paper-re14", + ["AABCDDEISHGGR"] + planted(rng, "AABCDDEISHGGR", 7, 8), + ["re14"], + ), + ("paper-re2", ["SAR"] + planted(rng, "SAR", 7, 16), ["re2"]), + ] + ) + base = [ + { + "id": f"{name}-{language}", + "language": language, + "sequences": [[ord(a) - ord("A") + 1 for a in s] for s in sequences], + } + for name, sequences, languages in workloads + for language in languages + ] + result = [ + { + **case, + "id": f"{case['id']}-support-{percent}", + "support_percent": percent, + "min_support": support_count(percent, len(case["sequences"])), + "min_length": min_length, + "required": required, + } + for case in base + for percent in supports + ] if len({case["id"] for case in result}) != len(result): raise ValueError("duplicate support thresholds") return result @@ -153,25 +208,30 @@ def accepts(pattern: tuple[int, ...], case: dict) -> bool: def frequent_patterns(case: dict) -> set[tuple[int, ...]] | None: """Every k-supported pattern occurs in at least one of the n-k+1 shortest records.""" - sequences = case["sequences"] - cover = sorted(sequences, key=len)[:len(sequences) - case["min_support"] + 1] - if any(len(s) > 16 for s in cover) or sum(2**len(s) for s in cover) > 200000: + sequences: list[list[int]] = case["sequences"] + cover = sorted(sequences, key=len)[: len(sequences) - case["min_support"] + 1] + if any(len(s) > 16 for s in cover) or sum(2 ** len(s) for s in cover) > 200000: return None - candidates = set() + candidates: set[tuple[int, ...]] = set() for sequence in cover: - local = {()} + local: set[tuple[int, ...]] = {()} for item in sequence: local |= {prefix + (item,) for prefix in local} candidates |= local - return {pattern for pattern in candidates if accepts(pattern, case) - and sum(is_subsequence(pattern, s) for s in sequences) >= case["min_support"]} + return { + pattern + for pattern in candidates + if accepts(pattern, case) + and sum(is_subsequence(pattern, s) for s in sequences) >= case["min_support"] + } def read_patterns(path: Path) -> set[tuple[int, ...]]: """Read an independent miner's output normalized to one integer pattern per line.""" patterns = [tuple(map(int, line.split())) for line in path.read_text().splitlines()] - if (len(set(patterns)) != len(patterns) or any(not p or - any(item < 1 or item > 2147483646 for item in p) for p in patterns)): + if len(set(patterns)) != len(patterns) or any( + not p or any(item < 1 or item > 2147483646 for item in p) for p in patterns + ): raise ValueError("expected distinct nonempty positive integer patterns") return set(patterns) @@ -181,17 +241,20 @@ def is_subsequence(pattern: tuple[int, ...], sequence: list[int]) -> bool: return all(item in items for item in pattern) -def execute(command: list[str], stdout: Path, stderr: Path, - timeout: float) -> dict: +def execute(command: list[str], stdout: Path, stderr: Path, timeout: float) -> dict: """Capture one invocation, including startup, and reap its process group.""" start = time.perf_counter() with stdout.open("w") as out, stderr.open("w") as err: try: - process = subprocess.Popen(command, stdout=out, stderr=err, - start_new_session=True) + process = subprocess.Popen( + command, stdout=out, stderr=err, start_new_session=True + ) except OSError as error: - return {"status": "error", "detail": str(error), - "wall_seconds": time.perf_counter() - start} + return { + "status": "error", + "detail": str(error), + "wall_seconds": time.perf_counter() - start, + } try: returncode = process.wait(timeout=timeout) except subprocess.TimeoutExpired: @@ -209,9 +272,12 @@ def execute(command: list[str], stdout: Path, stderr: Path, raise ValueError("unexpected target metrics") for key in METRICS: value = metrics[key] - if (type(value) not in (int, float) or value < 0 or - not math.isfinite(value) or - (key != "model_search_seconds" and type(value) is not int)): + if ( + type(value) not in (int, float) + or value < 0 + or not math.isfinite(value) + or (key != "model_search_seconds" and type(value) is not int) + ): raise ValueError(f"invalid {key}") except (ValueError, TypeError) as error: return {"status": "invalid", "detail": str(error), "wall_seconds": elapsed} @@ -226,26 +292,47 @@ def kill_process_group(process: subprocess.Popen) -> None: process.wait() -def check_patterns(result: dict, output: Path, case: dict, - expected: set[tuple[int, ...]] | None, - oracle: str = "exhaustive") -> dict: +def check_patterns( + result: dict, + output: Path, + case: dict, + expected: set[tuple[int, ...]] | None, + oracle: str = "exhaustive", +) -> dict: if result["status"] != "ok": return result try: - patterns = [tuple(map(int, line.split())) for line in output.read_text().splitlines()] + patterns = [ + tuple(map(int, line.split())) for line in output.read_text().splitlines() + ] except ValueError: return {**result, "status": "invalid", "detail": "non-integer pattern output"} actual = set(patterns) - if (len(patterns) != result["metrics"]["solutions"] or - len(actual) != len(patterns) or - any(not accepts(p, case) for p in patterns) or - (actual != expected if expected is not None else - any(sum(is_subsequence(p, s) for s in case["sequences"]) < case["min_support"] - for p in patterns))): - return {**result, "status": "invalid", "detail": "incorrect pattern enumeration"} + if ( + len(patterns) != result["metrics"]["solutions"] + or len(actual) != len(patterns) + or any(not accepts(p, case) for p in patterns) + or ( + actual != expected + if expected is not None + else any( + sum(is_subsequence(p, s) for s in case["sequences"]) + < case["min_support"] + for p in patterns + ) + ) + ): + return { + **result, + "status": "invalid", + "detail": "incorrect pattern enumeration", + } fingerprint = hashlib.sha256(json.dumps(sorted(actual)).encode()).hexdigest() - return {**result, "patterns_sha256": fingerprint, - "oracle": oracle if expected is not None else "feasibility"} + return { + **result, + "patterns_sha256": fingerprint, + "oracle": oracle if expected is not None else "feasibility", + } def valid_record(path: Path, identity: dict, validation: bool = False) -> dict | None: @@ -254,25 +341,35 @@ def valid_record(path: Path, identity: dict, validation: bool = False) -> dict | try: record = json.loads(path.read_text()) if not isinstance(record, dict): - raise ValueError("record must be an object") + raise TypeError("record must be an object") if any(record.get(key) != value for key, value in identity.items()): raise ValueError("record identity mismatch") if record.get("status") not in ("ok", "timeout", "error", "invalid"): raise ValueError("missing terminal status") elapsed = record["wall_seconds"] - if type(elapsed) not in (int, float) or not math.isfinite(elapsed) or elapsed < 0: + if ( + type(elapsed) not in (int, float) + or not math.isfinite(elapsed) + or elapsed < 0 + ): raise ValueError("invalid wall time") if record["status"] == "ok": metrics = record["metrics"] if not isinstance(metrics, dict) or set(metrics) != set(METRICS): raise ValueError("missing metrics") for key, value in metrics.items(): - if (type(value) not in (int, float) or not math.isfinite(value) or - value < 0 or (key != "model_search_seconds" and type(value) is not int)): + if ( + type(value) not in (int, float) + or not math.isfinite(value) + or value < 0 + or (key != "model_search_seconds" and type(value) is not int) + ): raise ValueError("invalid saved metrics") - if validation and (not re.fullmatch("[0-9a-f]{64}", - record.get("patterns_sha256", "")) or - record.get("oracle") not in ("exhaustive", "reference", "feasibility")): + if validation and ( + not re.fullmatch("[0-9a-f]{64}", record.get("patterns_sha256", "")) + or record.get("oracle") + not in ("exhaustive", "reference", "feasibility") + ): raise ValueError("missing correctness evidence") return record except (ValueError, TypeError, KeyError) as error: @@ -280,17 +377,36 @@ def valid_record(path: Path, identity: dict, validation: bool = False) -> dict | return None -def command(binary: str, case: dict, variant: str, database: Path, - output: str, bound: str) -> list[str]: +def command( + binary: str, case: dict, variant: str, database: Path, output: str, bound: str +) -> list[str]: required = ",".join(map(str, case["required"])) or "-" - return [binary, variant, case["language"], str(database), output, bound, - case["support_percent"], str(case["min_length"]), required, "integers"] + return [ + binary, + variant, + case["language"], + str(database), + output, + bound, + case["support_percent"], + str(case["min_length"]), + required, + "integers", + ] def collect(args: argparse.Namespace, directory: Path) -> None: binary = args.binary.resolve(strict=True) - workloads = cases(args.seed, args.suite, args.database, args.language, args.format, - args.support, args.min_length, args.required) + workloads = cases( + args.seed, + args.suite, + args.database, + args.language, + args.format, + args.support, + args.min_length, + args.required, + ) variants = args.variants if args.reference and (not args.database or len(workloads) != 1): raise ValueError("reference output requires one custom database query") @@ -298,36 +414,69 @@ def collect(args: argparse.Namespace, directory: Path) -> None: if len(set(variants)) != len(variants): raise ValueError("duplicate variants") if any(case["min_support"] < len(case["sequences"]) for case in workloads) and ( - args.bound == "shortest" or any(v.endswith("dfa") for v in variants)): + args.bound == "shortest" or any(v.endswith("dfa") for v in variants) + ): raise ValueError("DFA models and shortest bound require all-input support") # Mutable shared libraries count as part of the target, not just the executable. - libraries = sorted({p.resolve() for p in binary.parent.parent.glob("libgecode*") - if p.suffix in (".so", ".dylib", ".a")}) + libraries = sorted( + { + p.resolve() + for p in binary.parent.parent.glob("libgecode*") + if p.suffix in (".so", ".dylib", ".a") + } + ) if not libraries: raise ValueError("expected binary in BUILD/bin and Gecode libraries in BUILD") - config = {"format": 2, "binary": str(binary), "binary_sha256": digest(binary), - "libraries": {str(p): digest(p) for p in libraries}, - "build_label": args.build_label, - "runner_sha256": digest(Path(__file__)), - "source_sha256": digest(Path(__file__).with_name("compare.cpp")), - "helper_sha256": digest(Path(__file__).resolve().parents[2] / "examples/common-pattern.hh"), - "machine": {"system": platform.platform(), "node": platform.node(), - "processor": platform.processor()}, - "cases": workloads, "repetitions": args.repetitions, - "seed": args.seed, "timeout_seconds": args.timeout, - "bound": args.bound, "variants": variants} + config = { + "format": 2, + "binary": str(binary), + "binary_sha256": digest(binary), + "libraries": {str(p): digest(p) for p in libraries}, + "build_label": args.build_label, + "runner_sha256": digest(Path(__file__)), + "source_sha256": digest(Path(__file__).with_name("compare.cpp")), + "helper_sha256": digest( + Path(__file__).resolve().parents[2] / "examples/common-pattern.hh" + ), + "machine": { + "system": platform.platform(), + "node": platform.node(), + "processor": platform.processor(), + }, + "cases": workloads, + "repetitions": args.repetitions, + "seed": args.seed, + "timeout_seconds": args.timeout, + "bound": args.bound, + "variants": variants, + } if args.reference: - config["reference"] = {"path": str(args.reference.resolve()), - "sha256": digest(args.reference)} - print(f"{len(workloads)} cases; {len(workloads)*len(variants)} correctness runs; " - f"{len(workloads)*len(variants)*args.repetitions} measured runs; " - f"{args.timeout}s timeout per invocation; bound={args.bound}") - print("Serial, shuffled repetitions; model construction + exhaustive DFS; " - "measured runs count solutions without printing them.") + config["reference"] = { + "path": str(args.reference.resolve()), + "sha256": digest(args.reference), + } + print( + f"{len(workloads)} cases; {len(workloads) * len(variants)} correctness runs; " + f"{len(workloads) * len(variants) * args.repetitions} measured runs; " + f"{args.timeout}s timeout per invocation; bound={args.bound}" + ) + print( + "Serial, shuffled repetitions; model construction + exhaustive DFS; " + "measured runs count solutions without printing them." + ) if args.dry_run: - print(" ".join(command(str(binary), workloads[0], variants[0], - directory / "inputs" / (workloads[0]["id"] + ".txt"), - "count", args.bound))) + print( + " ".join( + command( + str(binary), + workloads[0], + variants[0], + directory / "inputs" / (workloads[0]["id"] + ".txt"), + "count", + args.bound, + ) + ) + ) return if directory.exists(): if json.loads((directory / "config.json").read_text()) != config: @@ -340,7 +489,9 @@ def collect(args: argparse.Namespace, directory: Path) -> None: passed = set() for case in workloads: database = directory / "inputs" / (case["id"] + ".txt") - database.write_text("\n".join(" ".join(map(str, s)) for s in case["sequences"]) + "\n") + database.write_text( + "\n".join(" ".join(map(str, s)) for s in case["sequences"]) + "\n" + ) oracle = reference if reference is not None else frequent_patterns(case) checks = [] for variant in variants: @@ -349,20 +500,35 @@ def collect(args: argparse.Namespace, directory: Path) -> None: record = valid_record(path, identity, validation=True) if record is None: cmd = command(str(binary), case, variant, database, "print", args.bound) - record = execute(cmd, path.with_suffix(".stdout"), - path.with_suffix(".stderr"), args.timeout) - record = check_patterns(record, path.with_suffix(".stdout"), case, oracle, - "reference" if reference is not None else "exhaustive") + record = execute( + cmd, + path.with_suffix(".stdout"), + path.with_suffix(".stderr"), + args.timeout, + ) + record = check_patterns( + record, + path.with_suffix(".stdout"), + case, + oracle, + "reference" if reference is not None else "exhaustive", + ) record.update(identity) save_json(path, record) checks.append(record) - if (all(r["status"] == "ok" for r in checks) and - len({r["patterns_sha256"] for r in checks}) == 1): + if ( + all(r["status"] == "ok" for r in checks) + and len({r["patterns_sha256"] for r in checks}) == 1 + ): passed.add(case["id"]) else: print(f"{case['id']}: correctness failed or incomplete; timings skipped") - schedule = [(case, variant, repeat) for repeat in range(args.repetitions) - for case in workloads for variant in variants] + schedule = [ + (case, variant, repeat) + for repeat in range(args.repetitions) + for case in workloads + for variant in variants + ] random.Random(args.seed).shuffle(schedule) executed = 0 failures = 0 @@ -379,13 +545,16 @@ def collect(args: argparse.Namespace, directory: Path) -> None: break database = directory / "inputs" / (case["id"] + ".txt") cmd = command(str(binary), case, variant, database, "count", args.bound) - record = execute(cmd, path.with_suffix(".stdout"), - path.with_suffix(".stderr"), args.timeout) - checked = json.loads((directory / "validation" / - f"{case['id']}-{variant}.json").read_text()) + record = execute( + cmd, path.with_suffix(".stdout"), path.with_suffix(".stderr"), args.timeout + ) + checked = json.loads( + (directory / "validation" / f"{case['id']}-{variant}.json").read_text() + ) if record["status"] == "ok" and ( - record["metrics"]["solutions"] != checked["metrics"]["solutions"] or - path.with_suffix(".stdout").read_text()): + record["metrics"]["solutions"] != checked["metrics"]["solutions"] + or path.with_suffix(".stdout").read_text() + ): record.update(status="invalid", detail="count run differs from validation") record.update(identity) save_json(path, record) @@ -394,82 +563,143 @@ def collect(args: argparse.Namespace, directory: Path) -> None: print(f"{case['id']} / {variant} / {repeat}: {record['status']}") print(f"Collected {executed} new measured samples in {directory}") if len(passed) != len(workloads) or failures: - raise ValueError("comparison has failed or timed-out work; inspect saved records") + raise ValueError( + "comparison has failed or timed-out work; inspect saved records" + ) def analyze(directory: Path) -> None: config = json.loads((directory / "config.json").read_text()) - print(f"Build: {config['build_label']}; bound: {config['bound']}; " - "per-case sequence support; all-pattern enumeration") + print( + f"Build: {config['build_label']}; bound: {config['bound']}; " + "per-case sequence support; all-pattern enumeration" + ) print("Model+search seconds: median [min, max]; only validated successful samples.") print("End-to-end wall seconds include process startup and teardown.") - print("case | variant | ok/expected | other | patterns | model+search s | wall s | nodes | propagations") + print( + "case | variant | ok/expected | other | patterns | model+search s | wall s | nodes | propagations" + ) totals = Counter() validation_counts = Counter() mismatched_cases = 0 for case in config["cases"]: - checks = [valid_record(directory / "validation" / f"{case['id']}-{v}.json", - {"case": case["id"], "variant": v}, validation=True) - for v in config["variants"]] - comparable = (all(r is not None and r["status"] == "ok" for r in checks) and - len({r["patterns_sha256"] for r in checks}) == 1) + checks = [ + valid_record( + directory / "validation" / f"{case['id']}-{v}.json", + {"case": case["id"], "variant": v}, + validation=True, + ) + for v in config["variants"] + ] + comparable = ( + all(r is not None and r["status"] == "ok" for r in checks) + and len({r["patterns_sha256"] for r in checks if r is not None}) == 1 + ) validation_counts.update(r["status"] if r else "unfinished" for r in checks) - if all(r is not None and r["status"] == "ok" for r in checks) and not comparable: + if ( + all(r is not None and r["status"] == "ok" for r in checks) + and not comparable + ): mismatched_cases += 1 for variant in config["variants"]: - records = [valid_record( - directory / "samples" / f"{case['id']}-{variant}-{repeat}.json", - {"case": case["id"], "variant": variant, "repeat": repeat}) - for repeat in range(config["repetitions"])] + records = [ + valid_record( + directory / "samples" / f"{case['id']}-{variant}-{repeat}.json", + {"case": case["id"], "variant": variant, "repeat": repeat}, + ) + for repeat in range(config["repetitions"]) + ] counts = Counter(r["status"] if r else "unfinished" for r in records) totals.update(counts) - successful = [r for r in records if r and r["status"] == "ok"] if comparable else [] - other = ",".join(f"{key}:{value}" for key, value in counts.items() if key != "ok") or "-" + successful = ( + [r for r in records if r and r["status"] == "ok"] if comparable else [] + ) + other = ( + ",".join( + f"{key}:{value}" for key, value in counts.items() if key != "ok" + ) + or "-" + ) if not successful: - print(f"{case['id']} | {variant} | 0/{config['repetitions']} | {other} " - "| unavailable (correctness or collection incomplete)") + print( + f"{case['id']} | {variant} | 0/{config['repetitions']} | {other} " + "| unavailable (correctness or collection incomplete)" + ) continue seconds = [r["metrics"]["model_search_seconds"] for r in successful] wall = statistics.median(r["wall_seconds"] for r in successful) metrics = successful[0]["metrics"] - print(f"{case['id']} | {variant} | {len(successful)}/{config['repetitions']} | " - f"{other} | {metrics['solutions']} | {statistics.median(seconds):.6f} " - f"[{min(seconds):.6f}, {max(seconds):.6f}] | {wall:.6f} | " - f"{metrics['nodes']} | {metrics['propagations']}") + print( + f"{case['id']} | {variant} | {len(successful)}/{config['repetitions']} | " + f"{other} | {metrics['solutions']} | {statistics.median(seconds):.6f} " + f"[{min(seconds):.6f}, {max(seconds):.6f}] | {wall:.6f} | " + f"{metrics['nodes']} | {metrics['propagations']}" + ) print(f"Measured sample status: {dict(totals)}") - print(f"Correctness status: {dict(validation_counts)}; " - f"cases with disagreeing pattern sets: {mismatched_cases}") - print("Paper-projection is an Algorithm 2 reimplementation, " - "not the authors' executable or a replication of their dataset timings.") + print( + f"Correctness status: {dict(validation_counts)}; " + f"cases with disagreeing pattern sets: {mismatched_cases}" + ) + print( + "Paper-projection is an Algorithm 2 reimplementation, " + "not the authors' executable or a replication of their dataset timings." + ) def main() -> None: parser = argparse.ArgumentParser(description=__doc__) - parser.add_argument("--results-root", type=Path, default=Path("build/common-pattern-results")) + parser.add_argument( + "--results-root", type=Path, default=Path("build/common-pattern-results") + ) subparsers = parser.add_subparsers(dest="action", required=True) run = subparsers.add_parser("run", help="collect or resume a named comparison") run.add_argument("--name", required=True) run.add_argument("--binary", type=Path, required=True) - run.add_argument("--build-label", required=True, help="compiler, flags and build configuration") + run.add_argument( + "--build-label", required=True, help="compiler, flags and build configuration" + ) run.add_argument("--suite", choices=("smoke", "scaling"), default="smoke") - run.add_argument("--database", type=Path, help="custom database, one sequence per line") - run.add_argument("--reference", type=Path, - help="exact independent output for one custom query; integer patterns, one per line") - run.add_argument("--language", choices=tuple(LANGUAGES), default="none", - help="restriction for a custom database") - run.add_argument("--format", choices=("letters", "integers", "spmf"), default="letters") - run.add_argument("--support", nargs="+", default=["100", "50", "25"], - help="minimum-support percentages (up to six decimals)") + run.add_argument( + "--database", type=Path, help="custom database, one sequence per line" + ) + run.add_argument( + "--reference", + type=Path, + help="exact independent output for one custom query; integer patterns, one per line", + ) + run.add_argument( + "--language", + choices=tuple(LANGUAGES), + default="none", + help="restriction for a custom database", + ) + run.add_argument( + "--format", choices=("letters", "integers", "spmf"), default="letters" + ) + run.add_argument( + "--support", + nargs="+", + default=["100", "50", "25"], + help="minimum-support percentages (up to six decimals)", + ) run.add_argument("--min-length", type=int, default=1) - run.add_argument("--required", type=int, nargs="*", default=[], help="required positive item IDs") - run.add_argument("--variants", choices=ALL_VARIANTS, nargs="+", default=list(VARIANTS)) + run.add_argument( + "--required", type=int, nargs="*", default=[], help="required positive item IDs" + ) + run.add_argument( + "--variants", choices=ALL_VARIANTS, nargs="+", default=list(VARIANTS) + ) run.add_argument("--bound", choices=("max", "shortest"), default="max") run.add_argument("--repetitions", type=int, default=5) run.add_argument("--timeout", type=float, default=30) run.add_argument("--seed", type=int, default=20261013) - run.add_argument("--limit", type=int, help="collect at most this many new timed samples") + run.add_argument( + "--limit", type=int, help="collect at most this many new timed samples" + ) run.add_argument("--dry-run", action="store_true") - report = subparsers.add_parser("analyze", help="summarize saved measurements without running targets") + report = subparsers.add_parser( + "analyze", help="summarize saved measurements without running targets" + ) report.add_argument("--name", required=True) args = parser.parse_args() if not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9_.-]*", args.name): @@ -477,12 +707,23 @@ def main() -> None: directory = args.results_root.resolve() / args.name try: if args.action == "run": - if (args.repetitions < 1 or not math.isfinite(args.timeout) or args.timeout <= 0 or - (args.limit is not None and args.limit < 0)): - parser.error("repetitions and timeout must be positive; limit must be nonnegative") - if (args.min_length < 1 or args.min_length > 2147483646 or - any(item < 1 or item > 2147483646 for item in args.required)): - parser.error("length and required item IDs must be positive Gecode integers") + if ( + args.repetitions < 1 + or not math.isfinite(args.timeout) + or args.timeout <= 0 + or (args.limit is not None and args.limit < 0) + ): + parser.error( + "repetitions and timeout must be positive; limit must be nonnegative" + ) + if ( + args.min_length < 1 + or args.min_length > 2147483646 + or any(item < 1 or item > 2147483646 for item in args.required) + ): + parser.error( + "length and required item IDs must be positive Gecode integers" + ) collect(args, directory) else: analyze(directory) From f958ad0c7413180c8baaaa7c2fc49d2abb643577 Mon Sep 17 00:00:00 2001 From: Mikael Zayenz Lagerkvist Date: Wed, 14 Oct 2026 06:50:11 +0200 Subject: [PATCH 26/34] Add BAB 15-puzzle example with open and fixed models Construct boards through an OpenIntVarList path transition and compare with a bounded array model using the same slide and goal rules. Minimize moves with BAB, and expose independent scramble, seed, and move-limit options. Keep the default move limit at twelve for a short demonstration. Register the example in CMake and Autoconf, including its generated include dependencies, and document state-versus-move length accounting. Validated both models in Debug and ASan/UBSan builds with the defaults, an explicit scramble/limit/seed case, a solved start, and an insufficient move bound. Replayed every printed path to verify legal slides and the goal board. Independent Astra review passed. --- Makefile.dep | 93 ++++++++++ Makefile.in | 2 +- examples/CMakeLists.txt | 1 + examples/fifteen-puzzle.cpp | 356 ++++++++++++++++++++++++++++++++++++ 4 files changed, 451 insertions(+), 1 deletion(-) create mode 100644 examples/fifteen-puzzle.cpp diff --git a/Makefile.dep b/Makefile.dep index 75ddc9b2ac..28b96985e0 100644 --- a/Makefile.dep +++ b/Makefile.dep @@ -15344,6 +15344,99 @@ examples/common-pattern$(OBJSUFFIX) examples/common-pattern$(SBJSUFFIX): \ ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp \ ./examples/common-pattern.hh +examples/fifteen-puzzle$(OBJSUFFIX) examples/fifteen-puzzle$(SBJSUFFIX): \ + ./gecode/driver.hh ./gecode/driver/options.hpp ./gecode/driver/script.hpp \ + ./gecode/float.hh ./gecode/float/array-traits.hpp ./gecode/float/array.hpp \ + ./gecode/float/branch.hpp ./gecode/float/branch/action.hpp ./gecode/float/branch/afc.hpp \ + ./gecode/float/branch/assign.hpp ./gecode/float/branch/chb.hpp ./gecode/float/branch/traits.hpp \ + ./gecode/float/branch/val.hpp ./gecode/float/branch/var.hpp ./gecode/float/channel.hpp \ + ./gecode/float/exception.hpp ./gecode/float/limits.hpp ./gecode/float/nextafter.hpp \ + ./gecode/float/num.hpp ./gecode/float/rounding.hpp ./gecode/float/trace.hpp \ + ./gecode/float/trace/delta.hpp ./gecode/float/trace/trace-view.hpp ./gecode/float/trace/traits.hpp \ + ./gecode/float/val.hpp ./gecode/float/var-imp.hpp ./gecode/float/var-imp/delta.hpp \ + ./gecode/float/var-imp/float.hpp ./gecode/float/var/float.hpp ./gecode/float/var/print.hpp \ + ./gecode/float/view.hpp ./gecode/float/view/float.hpp ./gecode/float/view/minus.hpp \ + ./gecode/float/view/offset.hpp ./gecode/float/view/print.hpp ./gecode/float/view/rel-test.hpp \ + ./gecode/float/view/scale.hpp ./gecode/gist.hh ./gecode/gist/gist.hpp \ + ./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \ + ./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \ + ./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \ + ./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \ + ./gecode/int/div.hh ./gecode/int/div.hpp ./gecode/int/exception.hpp \ + ./gecode/int/extensional.hpp ./gecode/int/extensional/dfa.hpp ./gecode/int/extensional/tuple-set.hpp \ + ./gecode/int/int-set-1.hpp ./gecode/int/int-set-2.hpp ./gecode/int/ipl.hpp \ + ./gecode/int/irt.hpp ./gecode/int/limits.hpp ./gecode/int/min-distance.hpp \ + ./gecode/int/open-var-list.hpp ./gecode/int/propagator.hpp ./gecode/int/reify.hpp \ + ./gecode/int/trace.hpp ./gecode/int/trace/bool-delta.hpp ./gecode/int/trace/bool-trace-view.hpp \ + ./gecode/int/trace/int-delta.hpp ./gecode/int/trace/int-trace-view.hpp ./gecode/int/trace/traits.hpp \ + ./gecode/int/var-imp.hpp ./gecode/int/var-imp/bool.hpp ./gecode/int/var-imp/delta.hpp \ + ./gecode/int/var-imp/int.hpp ./gecode/int/var/bool.hpp ./gecode/int/var/int.hpp \ + ./gecode/int/var/print.hpp ./gecode/int/view.hpp ./gecode/int/view/bool-test.hpp \ + ./gecode/int/view/bool.hpp ./gecode/int/view/cached.hpp ./gecode/int/view/constint.hpp \ + ./gecode/int/view/int.hpp ./gecode/int/view/iter.hpp ./gecode/int/view/minus.hpp \ + ./gecode/int/view/neg-bool.hpp ./gecode/int/view/offset.hpp ./gecode/int/view/print.hpp \ + ./gecode/int/view/rel-test.hpp ./gecode/int/view/scale.hpp ./gecode/int/view/zero.hpp \ + ./gecode/iter.hh ./gecode/iter/ranges-add.hpp ./gecode/iter/ranges-append.hpp \ + ./gecode/iter/ranges-array.hpp ./gecode/iter/ranges-cache.hpp ./gecode/iter/ranges-compl.hpp \ + ./gecode/iter/ranges-diff.hpp ./gecode/iter/ranges-empty.hpp ./gecode/iter/ranges-inter.hpp \ + ./gecode/iter/ranges-list.hpp ./gecode/iter/ranges-map.hpp ./gecode/iter/ranges-minmax.hpp \ + ./gecode/iter/ranges-minus.hpp ./gecode/iter/ranges-negative.hpp ./gecode/iter/ranges-offset.hpp \ + ./gecode/iter/ranges-operations.hpp ./gecode/iter/ranges-positive.hpp ./gecode/iter/ranges-rangelist.hpp \ + ./gecode/iter/ranges-scale.hpp ./gecode/iter/ranges-singleton-append.hpp ./gecode/iter/ranges-singleton.hpp \ + ./gecode/iter/ranges-size.hpp ./gecode/iter/ranges-union.hpp ./gecode/iter/ranges-values.hpp \ + ./gecode/iter/values-array.hpp ./gecode/iter/values-bitset.hpp ./gecode/iter/values-bitsetoffset.hpp \ + ./gecode/iter/values-inter.hpp ./gecode/iter/values-list.hpp ./gecode/iter/values-map.hpp \ + ./gecode/iter/values-minus.hpp ./gecode/iter/values-negative.hpp ./gecode/iter/values-offset.hpp \ + ./gecode/iter/values-positive.hpp ./gecode/iter/values-ranges.hpp ./gecode/iter/values-singleton.hpp \ + ./gecode/iter/values-union.hpp ./gecode/iter/values-unique.hpp ./gecode/kernel.hh \ + ./gecode/kernel/archive.hpp ./gecode/kernel/branch/action.hpp ./gecode/kernel/branch/afc.hpp \ + ./gecode/kernel/branch/chb.hpp ./gecode/kernel/branch/filter.hpp ./gecode/kernel/branch/merit.hpp \ + ./gecode/kernel/branch/print.hpp ./gecode/kernel/branch/tiebreak.hpp ./gecode/kernel/branch/traits.hpp \ + ./gecode/kernel/branch/val-commit.hpp ./gecode/kernel/branch/val-sel-commit.hpp ./gecode/kernel/branch/val-sel.hpp \ + ./gecode/kernel/branch/val.hpp ./gecode/kernel/branch/var.hpp ./gecode/kernel/branch/view-sel.hpp \ + ./gecode/kernel/branch/view-val.hpp ./gecode/kernel/branch/view.hpp ./gecode/kernel/core.hpp \ + ./gecode/kernel/data/array.hpp ./gecode/kernel/data/rnd.hpp ./gecode/kernel/data/shared-array.hpp \ + ./gecode/kernel/data/shared-data.hpp ./gecode/kernel/exception.hpp ./gecode/kernel/gpi.hpp \ + ./gecode/kernel/macros.hpp ./gecode/kernel/memory/allocators.hpp ./gecode/kernel/memory/config.hpp \ + ./gecode/kernel/memory/manager.hpp ./gecode/kernel/memory/region.hpp ./gecode/kernel/modevent.hpp \ + ./gecode/kernel/propagator/advisor.hpp ./gecode/kernel/propagator/pattern.hpp ./gecode/kernel/propagator/subscribed.hpp \ + ./gecode/kernel/propagator/wait.hpp ./gecode/kernel/range-list.hpp ./gecode/kernel/shared-object.hpp \ + ./gecode/kernel/shared-space-data.hpp ./gecode/kernel/trace/filter.hpp ./gecode/kernel/trace/general.hpp \ + ./gecode/kernel/trace/print.hpp ./gecode/kernel/trace/recorder.hpp ./gecode/kernel/trace/tracer.hpp \ + ./gecode/kernel/trace/traits.hpp ./gecode/kernel/var-imp.hpp ./gecode/kernel/var-type.hpp \ + ./gecode/kernel/var.hpp ./gecode/kernel/view.hpp ./gecode/minimodel.hh \ + ./gecode/minimodel/aliases.hpp ./gecode/minimodel/bool-expr.hpp ./gecode/minimodel/channel.hpp \ + ./gecode/minimodel/exception.hpp ./gecode/minimodel/float-expr.hpp ./gecode/minimodel/float-rel.hpp \ + ./gecode/minimodel/int-expr.hpp ./gecode/minimodel/int-rel.hpp ./gecode/minimodel/ipl.hpp \ + ./gecode/minimodel/ldsb.hpp ./gecode/minimodel/matrix.hpp ./gecode/minimodel/optimize.hpp \ + ./gecode/minimodel/reg.hpp ./gecode/minimodel/set-expr.hpp ./gecode/minimodel/set-rel.hpp \ + ./gecode/search.hh ./gecode/search/bab.hpp ./gecode/search/base.hpp \ + ./gecode/search/build.hpp ./gecode/search/cutoff.hpp ./gecode/search/dfs.hpp \ + ./gecode/search/engine.hpp ./gecode/search/exception.hpp ./gecode/search/lds.hpp \ + ./gecode/search/options.hpp ./gecode/search/pbs.hpp ./gecode/search/rbs.hpp \ + ./gecode/search/sebs.hpp ./gecode/search/seq/dead.hh ./gecode/search/statistics.hpp \ + ./gecode/search/stop.hpp ./gecode/search/support.hh ./gecode/search/trace-recorder.hpp \ + ./gecode/search/tracer.hpp ./gecode/search/traits.hpp ./gecode/search/worker-control.hh \ + ./gecode/set.hh ./gecode/set/array-traits.hpp ./gecode/set/array.hpp \ + ./gecode/set/branch.hpp ./gecode/set/branch/action.hpp ./gecode/set/branch/afc.hpp \ + ./gecode/set/branch/assign.hpp ./gecode/set/branch/chb.hpp ./gecode/set/branch/traits.hpp \ + ./gecode/set/branch/val.hpp ./gecode/set/branch/var.hpp ./gecode/set/exception.hpp \ + ./gecode/set/int.hpp ./gecode/set/limits.hpp ./gecode/set/trace.hpp \ + ./gecode/set/trace/delta.hpp ./gecode/set/trace/trace-view.hpp ./gecode/set/trace/traits.hpp \ + ./gecode/set/var-imp.hpp ./gecode/set/var-imp/delta.hpp ./gecode/set/var-imp/integerset.hpp \ + ./gecode/set/var-imp/iter.hpp ./gecode/set/var-imp/set.hpp ./gecode/set/var/print.hpp \ + ./gecode/set/var/set.hpp ./gecode/set/view.hpp ./gecode/set/view/cached.hpp \ + ./gecode/set/view/complement.hpp ./gecode/set/view/const.hpp ./gecode/set/view/print.hpp \ + ./gecode/set/view/set.hpp ./gecode/set/view/singleton.hpp ./gecode/support.hh \ + ./gecode/support/allocator.hpp ./gecode/support/auto-link.hpp ./gecode/support/bitset-base.hpp \ + ./gecode/support/bitset-offset.hpp ./gecode/support/bitset.hpp ./gecode/support/block-allocator.hpp \ + ./gecode/support/cast.hpp ./gecode/support/config.hpp ./gecode/support/dynamic-array.hpp \ + ./gecode/support/dynamic-queue.hpp ./gecode/support/dynamic-stack.hpp ./gecode/support/exception.hpp \ + ./gecode/support/failpoint.hpp ./gecode/support/hash.hpp ./gecode/support/heap.hpp \ + ./gecode/support/hw-rnd.hpp ./gecode/support/int-type.hpp ./gecode/support/macros.hpp \ + ./gecode/support/marked-pointer.hpp ./gecode/support/random.hpp ./gecode/support/ref-count.hpp \ + ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \ + ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp examples/open-route$(OBJSUFFIX) examples/open-route$(SBJSUFFIX): \ ./gecode/driver.hh ./gecode/driver/options.hpp ./gecode/driver/script.hpp \ ./gecode/float.hh ./gecode/float/array-traits.hpp ./gecode/float/array.hpp \ diff --git a/Makefile.in b/Makefile.in index 335ac99671..50a0830ab5 100755 --- a/Makefile.in +++ b/Makefile.in @@ -909,7 +909,7 @@ INTEXAMPLESRC0 = \ word-square crossword open-shop car-sequencing sat \ bin-packing knights tsp perfect-square schurs-lemma \ dominating-queens colored-matrix multi-bin-packing \ - qcp job-shop open-route common-pattern + qcp job-shop open-route common-pattern fifteen-puzzle INTEXAMPLEHDR = $(INTEXAMPLEHDR0:%=examples/%.hpp) diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt index aa85f6a937..6282beaeb8 100755 --- a/examples/CMakeLists.txt +++ b/examples/CMakeLists.txt @@ -23,6 +23,7 @@ set(GECODE_EXAMPLE_SOURCES donald.cpp efpa.cpp eq20.cpp + fifteen-puzzle.cpp golden-spiral.cpp golf.cpp golomb-ruler.cpp diff --git a/examples/fifteen-puzzle.cpp b/examples/fifteen-puzzle.cpp new file mode 100644 index 0000000000..925d7b9931 --- /dev/null +++ b/examples/fifteen-puzzle.cpp @@ -0,0 +1,356 @@ +/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */ +/* + * Main author: + * Mikael Zayenz Lagerkvist + * + * Copyright: + * Mikael Zayenz Lagerkvist, 2026 + * + * This file is part of Gecode, the generic constraint + * development environment: + * http://www.gecode.dev + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + */ + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +using namespace Gecode; +using Board = std::array; + +/// Options for the initial scramble and bounded solution path. +class PuzzleOptions : public Options { + Driver::UnsignedIntOption _scramble; + Driver::UnsignedIntOption _limit; +public: + enum { MODEL_OPEN, MODEL_FIXED }; + PuzzleOptions(void) + : Options("FifteenPuzzle"), + _scramble("scramble","number of random slides from the goal",12), + _limit("limit","maximum number of solution moves",12) { + add(_scramble); + add(_limit); + model(MODEL_OPEN); + model(MODEL_OPEN,"open","construct states as the path grows"); + model(MODEL_FIXED,"fixed","construct all bounded states initially"); + solutions(0); + seed(1); + } + unsigned int + scramble(void) const { + return _scramble.value(); + } + int + limit(void) const { + Int::Limits::check(16*(static_cast(_limit.value())+1), + "FifteenPuzzle::limit"); + return static_cast(_limit.value()); + } +}; + +static Board +goal(void) { + return {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,0}; +} + +static std::vector +neighbors(int blank) { + std::vector result; + if (blank >= 4) + result.push_back(blank-4); + if (blank % 4 != 0) + result.push_back(blank-1); + if (blank % 4 != 3) + result.push_back(blank+1); + if (blank < 12) + result.push_back(blank+4); + return result; +} + +static Board +initial_board(const PuzzleOptions& opt) { + Board board = goal(); + Rnd random(opt.seed()); + int blank = 15; + int previous = -1; + for (unsigned int i=0; i choices = neighbors(blank); + choices.erase(std::remove(choices.begin(),choices.end(),previous), + choices.end()); + int next = choices[random(static_cast(choices.size()))]; + std::swap(board[blank],board[next]); + previous = blank; + blank = next; + } + return board; +} + +static int +manhattan(const Board& board) { + int distance = 0; + for (int i=0; i<16; i++) { + if (board[i] != 0) { + const int target = board[i]-1; + distance += std::abs(i/4-target/4) + std::abs(i%4-target%4); + } + } + return distance; +} + +static Board +values(const IntVarArgs& tiles) { + Board result; + for (int i=0; i<16; i++) + result[i] = tiles[i].val(); + return result; +} + +static void +print_board(std::ostream& os, const Board& board) { + for (int i=0; i<16; i++) { + os << std::setw(3) << board[i]; + if (i % 4 == 3) + os << '\n'; + } +} + +static void +post_start(Home home, const IntVarArgs& tiles, IntVar blank, + const Board& initial) { + for (int i=0; i<16; i++) + rel(home,tiles[i] == initial[i]); + const int zero = static_cast( + std::find(initial.begin(),initial.end(),0)-initial.begin()); + rel(home,blank == zero); +} + +// Both representations use these rules between successive states. +static void +post_slide(Home home, + const IntVarArgs& before, IntVar old_blank, + const IntVarArgs& after, IntVar new_blank) { + static const TupleSet adjacent = [] { + TupleSet table(2); + for (int i=0; i<16; i++) { + for (int j : neighbors(i)) + table.add(IntArgs({i,j})); + } + table.finalize(); + return table; + }(); + extensional(home,IntVarArgs({old_blank,new_blank}),adjacent); + rel(home,element(after,old_blank) == element(before,new_blank)); + rel(home,element(after,new_blank) == 0); + for (int i=0; i<16; i++) { + rel(home,((old_blank != i) && (new_blank != i)) >> + (before[i] == after[i])); + } +} + +static void +post_goal(Home home, const IntVarArgs& tiles, IntVar length, + int states) { + const Board target = goal(); + BoolExpr solved(tiles[0] == target[0]); + for (int i=1; i<16; i++) + solved = solved && (tiles[i] == target[i]); + rel(home,(length >= states) >> ((length == states) == solved)); +} + +/** + * \brief %Example: solve the 15-puzzle with an open list of states + * + * Start from a solvable board obtained by randomly sliding from the goal. + * Each path position is the blank position in one board; the tile list holds + * sixteen variables per board. The transition on the path constructs and + * constrains the next board when that position is materialized. + * + * The goal closes the path. Length counts states including the start, so + * branch and bound minimizes moves by minimizing length minus one. + * The independent move limit bounds search and need not equal the scramble. + * Defaults use twelve slides, seed one, and a twelve-move limit. Select + * -model fixed to compare with an array representation; -scramble, -seed, + * and -limit control the instance and search bound independently. + * + * \ingroup Example + */ +class OpenPuzzle : public Script { + OpenIntVarList tiles; + OpenIntVarList path; +public: + OpenPuzzle(const PuzzleOptions& opt) + : Script(opt), + tiles(*this,IntSet(0,15),16*(opt.limit()+1)), + path(*this,IntSet(0,15), + [](Space& home, OpenIntVarList x, int i) { + static_cast(home).transition(x,i); + },opt.limit()+1) { + const Board initial = initial_board(opt); + rel(*this,tiles.length() == 16*path.length()); + tiles.materialize(*this,16); + IntVar start = path.get(*this,0); + post_start(*this,state(0),start,initial); + post_goal(*this,state(0),path.length(),1); + rel(*this,path.length() >= manhattan(initial)+1); + branch(*this,path,INT_VAR_NONE(),INT_VAL_MIN()); + } + + void + transition(OpenIntVarList x, int i) { + // The constructor posts the starting board unconditionally. + if (i == 0) + return; + tiles.materialize(*this,16*(i+1)); + if (failed()) + return; + post_slide(*this,state(i-1),x[i-1],state(i),x[i]); + post_goal(*this,state(i),x.length(),i+1); + } + + OpenPuzzle(OpenPuzzle& s) : Script(s) { + tiles.update(*this,s.tiles); + path.update(*this,s.path); + } + Space* + copy(void) override { + return new OpenPuzzle(*this); + } + IntVarArgs + state(int i) const { + IntVarArgs result(16); + for (int j=0; j<16; j++) + result[j] = tiles[16*i+j]; + return result; + } + void + constrain(const Space& solution) override { + const OpenPuzzle& best = static_cast(solution); + rel(*this,path.length() < best.path.length().val()); + } + void + print(std::ostream& os) const override { + os << "Moves: " << path.length().val()-1 << "\nBlank positions:"; + for (int i=0; i= manhattan(initial)+1); + branch(*this,path,INT_VAR_NONE(),INT_VAL_MIN(), + [](const Space& home, IntVar, int i) { + const FixedPuzzle& s = static_cast(home); + const int g = s.depth(); + return values(s.state(g)) != goal() && i == g+1; + }); + } + + FixedPuzzle(FixedPuzzle& s) : Script(s) { + tiles.update(*this,s.tiles); + path.update(*this,s.path); + length.update(*this,s.length); + } + Space* + copy(void) override { + return new FixedPuzzle(*this); + } + IntVarArgs + state(int i) const { + IntVarArgs result(16); + for (int j=0; j<16; j++) + result[j] = tiles[16*i+j]; + return result; + } + int + depth(void) const { + int i = 0; + while (i+1 < path.size() && path[i+1].assigned()) + i++; + return i; + } + void + constrain(const Space& solution) override { + const FixedPuzzle& best = static_cast(solution); + rel(*this,length < best.length.val()); + } + void + print(std::ostream& os) const override { + os << "Moves: " << length.val()-1 << "\nBlank positions:"; + for (int i=0; i(opt); + else + Script::run(opt); + return 0; +} + +// STATISTICS: example-any From e70dfbc44535effaeddf335877ea90810ca46a2f Mon Sep 17 00:00:00 2001 From: Mikael Zayenz Lagerkvist Date: Wed, 14 Oct 2026 08:05:12 +0200 Subject: [PATCH 27/34] Defer open puzzle goal checks until board assignment Wait for the current board to become assigned before closing or extending the path. Keep callback captures limited to the state index and retrieve the model from the supplied space. Remove the initial Manhattan lower bound on length to avoid constructing future boards at the root. Both models pass small explicit, solved-start, and insufficient-limit cases in Debug and ASan/UBSan builds. Printed paths were replayed, and a root diagnostic confirms two constructed boards for scramble20/limit32, seed3. Independent focused review passes. The open default now exceeds a 30-second Debug cutoff because delayed goal detection removes early backward goal propagation. Its usability needs a separate coordinated follow-up; no extra pruning rule is included in this model correction. --- examples/fifteen-puzzle.cpp | 18 +++++++++++++++--- 1 file changed, 15 insertions(+), 3 deletions(-) diff --git a/examples/fifteen-puzzle.cpp b/examples/fifteen-puzzle.cpp index 925d7b9931..9643ffe52f 100644 --- a/examples/fifteen-puzzle.cpp +++ b/examples/fifteen-puzzle.cpp @@ -191,6 +191,8 @@ post_goal(Home home, const IntVarArgs& tiles, IntVar length, * Each path position is the blank position in one board; the tile list holds * sixteen variables per board. The transition on the path constructs and * constrains the next board when that position is materialized. + * Goal detection waits until that board is assigned, so it does not require + * constructing future boards to decide whether the path should continue. * * The goal closes the path. Length counts states including the start, so * branch and bound minimizes moves by minimizing length minus one. @@ -217,11 +219,21 @@ class OpenPuzzle : public Script { tiles.materialize(*this,16); IntVar start = path.get(*this,0); post_start(*this,state(0),start,initial); - post_goal(*this,state(0),path.length(),1); - rel(*this,path.length() >= manhattan(initial)+1); + wait_goal(0); branch(*this,path,INT_VAR_NONE(),INT_VAL_MIN()); } + void + wait_goal(int i) { + wait(*this,state(i),[i](Space& home) { + OpenPuzzle& s = static_cast(home); + if (values(s.state(i)) == goal()) + rel(home,s.path.length(),IRT_EQ,i+1); + else + rel(home,s.path.length(),IRT_GR,i+1); + }); + } + void transition(OpenIntVarList x, int i) { // The constructor posts the starting board unconditionally. @@ -231,7 +243,7 @@ class OpenPuzzle : public Script { if (failed()) return; post_slide(*this,state(i-1),x[i-1],state(i),x[i]); - post_goal(*this,state(i),x.length(),i+1); + wait_goal(i); } OpenPuzzle(OpenPuzzle& s) : Script(s) { From 5de016013b6710dfc46d41c649f486c73965c329 Mon Sep 17 00:00:00 2001 From: Mikael Zayenz Lagerkvist Date: Wed, 14 Oct 2026 08:56:58 +0200 Subject: [PATCH 28/34] Prune open puzzle states using the remaining move budget Reject assigned boards whose Manhattan distance cannot fit the current path upper bound. Recheck this condition after incumbent cuts, taking care not to read a board before propagation assigns it. Force the goal when a constructed board reaches the final permitted state. Keep path growth lazy: these checks do not increase its minimum length or construct future boards. The fixed model and shared slide rules stay unchanged. Focused Debug and ASan/UBSan runs pass for defaults, explicit options, a solved start and an insufficient move limit. Printed paths were replayed. The default open model completes in 39 nodes, and the root probe still constructs two boards for scramble20/limit32/seed3. Independent Astra recheck passes. --- examples/fifteen-puzzle.cpp | 46 ++++++++++++++++++++++++++++++++++++- 1 file changed, 45 insertions(+), 1 deletion(-) diff --git a/examples/fifteen-puzzle.cpp b/examples/fifteen-puzzle.cpp index 9643ffe52f..46853f7325 100644 --- a/examples/fifteen-puzzle.cpp +++ b/examples/fifteen-puzzle.cpp @@ -193,6 +193,8 @@ post_goal(Home home, const IntVarArgs& tiles, IntVar length, * constrains the next board when that position is materialized. * Goal detection waits until that board is assigned, so it does not require * constructing future boards to decide whether the path should continue. + * Manhattan distance rejects assigned boards that cannot reach the goal + * within the remaining move bound, without increasing the list's minimum. * * The goal closes the path. Length counts states including the start, so * branch and bound minimizes moves by minimizing length minus one. @@ -223,11 +225,35 @@ class OpenPuzzle : public Script { branch(*this,path,INT_VAR_NONE(),INT_VAL_MIN()); } + bool + check_bound(int i, const Board& board) { + if (i+manhattan(board) <= path.length().max()-1) + return true; + fail(); + return false; + } + + void + force_goal(int i) { + const Board target = goal(); + const IntVarArgs board = state(i); + for (int j=0; j<16; j++) + rel(*this,board[j],IRT_EQ,target[j]); + } + void wait_goal(int i) { + if (path.length().max() == i+1) { + force_goal(i); + if (failed()) + return; + } wait(*this,state(i),[i](Space& home) { OpenPuzzle& s = static_cast(home); - if (values(s.state(i)) == goal()) + const Board board = values(s.state(i)); + if (!s.check_bound(i,board)) + return; + if (board == goal()) rel(home,s.path.length(),IRT_EQ,i+1); else rel(home,s.path.length(),IRT_GR,i+1); @@ -261,10 +287,28 @@ class OpenPuzzle : public Script { result[j] = tiles[16*i+j]; return result; } + int + depth(void) const { + int i = 0; + while (i+1 < path.known_length() && path[i+1].assigned()) + i++; + return i; + } void constrain(const Space& solution) override { const OpenPuzzle& best = static_cast(solution); rel(*this,path.length() < best.path.length().val()); + if (failed()) + return; + // BAB can constrain after a commit, before the board becomes assigned. + int current = depth(); + while (current > 0 && !state(current).assigned()) + current--; + if (!check_bound(current,values(state(current)))) + return; + const int last = path.length().max()-1; + if (16*(last+1) <= tiles.known_length()) + force_goal(last); } void print(std::ostream& os) const override { From 114643a224ec8878363045b519bfd4a9b1c4863b Mon Sep 17 00:00:00 2001 From: Mikael Zayenz Lagerkvist Date: Wed, 14 Oct 2026 13:13:01 +0200 Subject: [PATCH 29/34] Use NoGPI for open-list factories and transitions --- changelog.in | 4 ++ gecode/int.hh | 18 +++++++- gecode/int/open-var-list.hpp | 2 + test/int/open-var-list.cpp | 87 ++++++++++++++++++++++++++++++++++++ 4 files changed, 110 insertions(+), 1 deletion(-) diff --git a/changelog.in b/changelog.in index b0e782aedd..b9d2f399ca 100755 --- a/changelog.in +++ b/changelog.in @@ -87,6 +87,10 @@ brancher on the length first selects the length before list values. The common-pattern example demonstrates constrained frequent subsequence mining without padding, with support thresholds and integer database input; open-route provides a smaller introduction. +Open-list factories and transitions run inside Space::NoGPI scopes by +default, including transitions called by direct append. Callback-local +Space::UseGPI scopes enable global information for selected postings; +nested list construction starts its own NoGPI scope. [ENTRY] Module: kernel diff --git a/gecode/int.hh b/gecode/int.hh index eb74eb9297..5133a933cc 100755 --- a/gecode/int.hh +++ b/gecode/int.hh @@ -2490,6 +2490,16 @@ namespace Gecode { * and safe for concurrent calls. Captured data must be owned or shared * and must not be space-local. Returned variables must belong to \a home * and be initialized. + * + * Materialization calls the factory inside a Space::NoGPI scope. + * New propagators keep their information in the space and have zero + * AFC, so AFC-based branching does not count them. Identifiers and + * groups remain available. Group changes are local to the space; clones + * copy the current group. A callback-local + * Space::UseGPI scope enables global information and ordinary AFC for + * selected postings. Nested materialization starts a new NoGPI scope. + * Each scope restores the previous setting when it ends, including + * exception unwinding. */ typedef std::function Factory; /** @@ -2499,6 +2509,12 @@ namespace Gecode { * deterministic and safe for concurrent calls. Captured data must be * owned or shared and must not be space-local; \a home and \a x refer * to the current space. + * + * Calls from materialize() and direct append() run inside a + * Space::NoGPI scope with the same AFC and group behavior as Factory. + * A callback-local Space::UseGPI scope enables global information for + * selected postings. Nested materialize() or append() calls enter their + * own NoGPI scope and restore the callback's setting when they return. */ typedef std::function x, int i)> Transition; @@ -2522,7 +2538,7 @@ namespace Gecode { * \brief Append variable \a x * * Constrains the eventual length to include the new position and calls - * the transition function, if supplied. + * the transition function, if supplied, inside a Space::NoGPI scope. * * Throws an exception of type Int::ArgumentSame if \a x is an * unassigned variable already in the list. diff --git a/gecode/int/open-var-list.hpp b/gecode/int/open-var-list.hpp index b3f14fd47b..7ca0e64510 100644 --- a/gecode/int/open-var-list.hpp +++ b/gecode/int/open-var-list.hpp @@ -284,6 +284,7 @@ namespace Gecode { const Transition& transition = s->functions().transition; if (transition) { GECODE_VALID_FUNCTION(transition); + Space::NoGPI no_gpi(home); transition(home,*this,next-1); } } @@ -291,6 +292,7 @@ namespace Gecode { template void OpenVarList::materialize(Space& home, int n) { + Space::NoGPI no_gpi(home); if (home.failed()) return; Int::Limits::nonnegative(n,"OpenVarList::materialize"); diff --git a/test/int/open-var-list.cpp b/test/int/open-var-list.cpp index d4c2df03a8..269cd046f5 100644 --- a/test/int/open-var-list.cpp +++ b/test/int/open-var-list.cpp @@ -928,6 +928,92 @@ namespace Test { namespace Int { } }; + /// Callback posting scopes, selected AFC, and nested list growth + class NoGPI : public ::Test::Base { + protected: + static void + post(Gecode::Space& home, Gecode::PropagatorGroup group) { + Gecode::IntVar x(home,0,10), y(home,0,10); + Gecode::rel(home(group),x,Gecode::IRT_LE,y); + } + + static int + count(const Gecode::Space& home, Gecode::PropagatorGroup group, + double afc) { + int n = 0; + for (Gecode::Propagators ps(home,group); ps(); ++ps) { + if (ps.propagator().afc() != afc) + return -1; + n++; + } + return n; + } + + public: + NoGPI(void) + : ::Test::Base("Int::OpenList::NoGPI",TestTags::check()) {} + + virtual bool + run(void) { + using namespace Gecode; + CallbackSpace home([](int) { return IntSet(0,1); }, + [](Space&, OpenIntVarList, int) {}); + PropagatorGroup factory, transition, selected, ordinary, suppressed; + OpenVarList list(home, + [factory,selected](Space& home, int) { + post(home,factory); + { + Space::UseGPI use_gpi(home); + post(home,selected); + } + return IntVar(home,0,10); + }, + [transition,selected](Space& home, OpenVarList list, int i) { + post(home,transition); + if (i == 3) + throw 1; + { + Space::UseGPI use_gpi(home); + post(home,selected); + if (i == 0) + list.materialize(home,2); + post(home,selected); + } + post(home,transition); + },4); + + list.materialize(home,1); + post(home,ordinary); + if ((list.known_length() != 2) || + (count(home,factory,0.0) != 2) || + (count(home,transition,0.0) != 4) || + (count(home,selected,1.0) != 6)) + return false; + { + Space::NoGPI no_gpi(home); + { + Space::UseGPI use_gpi(home); + list.append(home,IntVar(home,0,10)); + post(home,ordinary); + } + post(home,suppressed); + } + bool threw = false; + try { + list.append(home,IntVar(home,0,10)); + } catch (int) { + threw = true; + } + post(home,ordinary); + return threw && (count(home,factory,0.0) == 2) && + (count(home,transition,0.0) == 7) && + (count(home,selected,1.0) == 8) && + (count(home,ordinary,1.0) == 3) && + (count(home,suppressed,0.0) == 1) && + (home.status() != SS_FAILED); + } + }; + class FailedGet : public ::Test::Base { public: FailedGet(void) @@ -1259,6 +1345,7 @@ namespace Test { namespace Int { Dispose disposal; CallbackLength callback_length; + NoGPI no_gpi; FailedGet failed_get; Branch branch; From 8207ea72a20d3f3ddaea570e638c117d5ba0b723 Mon Sep 17 00:00:00 2001 From: Mikael Zayenz Lagerkvist Date: Wed, 14 Oct 2026 14:08:21 +0200 Subject: [PATCH 30/34] Document NoGPI scopes on open-list materialization methods --- gecode/int.hh | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/gecode/int.hh b/gecode/int.hh index 5133a933cc..de652eddbf 100755 --- a/gecode/int.hh +++ b/gecode/int.hh @@ -2550,13 +2550,18 @@ namespace Gecode { * The eventual length is constrained to be at least \a n. Positions * required by its minimum are materialized, including any increase * imposed by the transition function. + * + * Factory and transition calls run inside Space::NoGPI scopes by + * default. A callback-local Space::UseGPI scope enables global + * information for selected postings (see Factory). */ void materialize(Space& home, int n); /** * \brief Require and return the variable at position \a i * * Constrains the eventual length to be at least \a i+1 and materializes - * positions through \a i. + * positions through \a i, using the Space::NoGPI scopes documented + * for materialize(). * * Returns an uninitialized variable if \a home is failed or * materialization fails. Throws Int::OutOfLimits for a negative index, @@ -2575,7 +2580,8 @@ namespace Gecode { * \brief Close the list at its materialized length * * First materializes any positions required by the minimum eventual - * length, then assigns the eventual length to the number of positions. + * length, using the Space::NoGPI scopes documented for materialize(), + * then assigns the eventual length to the number of positions. * The contained variables can remain unassigned. */ void close(Space& home); From a0ab98605db7c91026884415dfc950971438ed7d Mon Sep 17 00:00:00 2001 From: Mikael Zayenz Lagerkvist Date: Thu, 15 Oct 2026 16:17:59 +0200 Subject: [PATCH 31/34] Simplify goal constraints in the open 15-puzzle model --- examples/fifteen-puzzle.cpp | 71 ++++--------------------------------- 1 file changed, 7 insertions(+), 64 deletions(-) diff --git a/examples/fifteen-puzzle.cpp b/examples/fifteen-puzzle.cpp index 46853f7325..af0868bf19 100644 --- a/examples/fifteen-puzzle.cpp +++ b/examples/fifteen-puzzle.cpp @@ -191,10 +191,9 @@ post_goal(Home home, const IntVarArgs& tiles, IntVar length, * Each path position is the blank position in one board; the tile list holds * sixteen variables per board. The transition on the path constructs and * constrains the next board when that position is materialized. - * Goal detection waits until that board is assigned, so it does not require - * constructing future boards to decide whether the path should continue. - * Manhattan distance rejects assigned boards that cannot reach the goal - * within the remaining move bound, without increasing the list's minimum. + * Each new board uses the same slide and goal constraints as the fixed + * representation. Propagation determines how much of the path is constructed; + * the initial Manhattan distance gives a lower bound on its length. * * The goal closes the path. Length counts states including the start, so * branch and bound minimizes moves by minimizing length minus one. @@ -218,58 +217,20 @@ class OpenPuzzle : public Script { },opt.limit()+1) { const Board initial = initial_board(opt); rel(*this,tiles.length() == 16*path.length()); - tiles.materialize(*this,16); IntVar start = path.get(*this,0); post_start(*this,state(0),start,initial); - wait_goal(0); + rel(*this,path.length() >= manhattan(initial)+1); branch(*this,path,INT_VAR_NONE(),INT_VAL_MIN()); } - bool - check_bound(int i, const Board& board) { - if (i+manhattan(board) <= path.length().max()-1) - return true; - fail(); - return false; - } - - void - force_goal(int i) { - const Board target = goal(); - const IntVarArgs board = state(i); - for (int j=0; j<16; j++) - rel(*this,board[j],IRT_EQ,target[j]); - } - - void - wait_goal(int i) { - if (path.length().max() == i+1) { - force_goal(i); - if (failed()) - return; - } - wait(*this,state(i),[i](Space& home) { - OpenPuzzle& s = static_cast(home); - const Board board = values(s.state(i)); - if (!s.check_bound(i,board)) - return; - if (board == goal()) - rel(home,s.path.length(),IRT_EQ,i+1); - else - rel(home,s.path.length(),IRT_GR,i+1); - }); - } - void transition(OpenIntVarList x, int i) { - // The constructor posts the starting board unconditionally. - if (i == 0) - return; tiles.materialize(*this,16*(i+1)); if (failed()) return; - post_slide(*this,state(i-1),x[i-1],state(i),x[i]); - wait_goal(i); + if (i > 0) + post_slide(*this,state(i-1),x[i-1],state(i),x[i]); + post_goal(*this,state(i),path.length(),i+1); } OpenPuzzle(OpenPuzzle& s) : Script(s) { @@ -287,28 +248,10 @@ class OpenPuzzle : public Script { result[j] = tiles[16*i+j]; return result; } - int - depth(void) const { - int i = 0; - while (i+1 < path.known_length() && path[i+1].assigned()) - i++; - return i; - } void constrain(const Space& solution) override { const OpenPuzzle& best = static_cast(solution); rel(*this,path.length() < best.path.length().val()); - if (failed()) - return; - // BAB can constrain after a commit, before the board becomes assigned. - int current = depth(); - while (current > 0 && !state(current).assigned()) - current--; - if (!check_bound(current,values(state(current)))) - return; - const int last = path.length().max()-1; - if (16*(last+1) <= tiles.known_length()) - force_goal(last); } void print(std::ostream& os) const override { From 1736f19a4d568b9f23696ce1362bc7b670e84d8a Mon Sep 17 00:00:00 2001 From: Mikael Zayenz Lagerkvist Date: Thu, 15 Oct 2026 16:31:34 +0200 Subject: [PATCH 32/34] Use IntArgs for puzzle neighbors --- examples/fifteen-puzzle.cpp | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/examples/fifteen-puzzle.cpp b/examples/fifteen-puzzle.cpp index af0868bf19..915a0beebf 100644 --- a/examples/fifteen-puzzle.cpp +++ b/examples/fifteen-puzzle.cpp @@ -40,7 +40,6 @@ #include #include #include -#include using namespace Gecode; using Board = std::array; @@ -80,17 +79,17 @@ goal(void) { return {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,0}; } -static std::vector +static IntArgs neighbors(int blank) { - std::vector result; + IntArgs result; if (blank >= 4) - result.push_back(blank-4); + result << blank-4; if (blank % 4 != 0) - result.push_back(blank-1); + result << blank-1; if (blank % 4 != 3) - result.push_back(blank+1); + result << blank+1; if (blank < 12) - result.push_back(blank+4); + result << blank+4; return result; } @@ -101,9 +100,10 @@ initial_board(const PuzzleOptions& opt) { int blank = 15; int previous = -1; for (unsigned int i=0; i choices = neighbors(blank); - choices.erase(std::remove(choices.begin(),choices.end(),previous), - choices.end()); + IntArgs choices; + for (int neighbor : neighbors(blank)) + if (neighbor != previous) + choices << neighbor; int next = choices[random(static_cast(choices.size()))]; std::swap(board[blank],board[next]); previous = blank; From 413db902a487c75910640f531cdc06fa51767c81 Mon Sep 17 00:00:00 2001 From: Mikael Zayenz Lagerkvist Date: Thu, 15 Oct 2026 16:47:00 +0200 Subject: [PATCH 33/34] Split puzzle goal implications with a shared BoolVar --- examples/fifteen-puzzle.cpp | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/examples/fifteen-puzzle.cpp b/examples/fifteen-puzzle.cpp index 915a0beebf..615b7b5020 100644 --- a/examples/fifteen-puzzle.cpp +++ b/examples/fifteen-puzzle.cpp @@ -178,10 +178,12 @@ static void post_goal(Home home, const IntVarArgs& tiles, IntVar length, int states) { const Board target = goal(); - BoolExpr solved(tiles[0] == target[0]); + BoolExpr matches(tiles[0] == target[0]); for (int i=1; i<16; i++) - solved = solved && (tiles[i] == target[i]); - rel(home,(length >= states) >> ((length == states) == solved)); + matches = matches && (tiles[i] == target[i]); + BoolVar solved = expr(home,matches); + rel(home,(length == states) >> solved); + rel(home,solved >> (length <= states)); } /** From 0d80c51e0b72ddda7241866e2535fbefc7ea9a78 Mon Sep 17 00:00:00 2001 From: Mikael Zayenz Lagerkvist Date: Thu, 15 Oct 2026 17:03:37 +0200 Subject: [PATCH 34/34] Offer Manhattan move ordering in the puzzle example --- examples/fifteen-puzzle.cpp | 44 +++++++++++++++++++++++++++++++++++-- 1 file changed, 42 insertions(+), 2 deletions(-) diff --git a/examples/fifteen-puzzle.cpp b/examples/fifteen-puzzle.cpp index 615b7b5020..fac1060391 100644 --- a/examples/fifteen-puzzle.cpp +++ b/examples/fifteen-puzzle.cpp @@ -40,6 +40,7 @@ #include #include #include +#include using namespace Gecode; using Board = std::array; @@ -50,6 +51,7 @@ class PuzzleOptions : public Options { Driver::UnsignedIntOption _limit; public: enum { MODEL_OPEN, MODEL_FIXED }; + enum { BRANCH_MIN, BRANCH_MANHATTAN }; PuzzleOptions(void) : Options("FifteenPuzzle"), _scramble("scramble","number of random slides from the goal",12), @@ -59,6 +61,10 @@ class PuzzleOptions : public Options { model(MODEL_OPEN); model(MODEL_OPEN,"open","construct states as the path grows"); model(MODEL_FIXED,"fixed","construct all bounded states initially"); + branching(BRANCH_MIN); + branching(BRANCH_MIN,"min","try the lowest blank position first"); + branching(BRANCH_MANHATTAN,"manhattan", + "try the slide with least Manhattan distance first"); solutions(0); seed(1); } @@ -132,6 +138,25 @@ values(const IntVarArgs& tiles) { return result; } +// The assigned preceding board changes only at the blank and the moved tile. +static int +manhattan_value(const IntVarArgs& before, int blank, IntVar next) { + int best = next.min(); + int best_change = std::numeric_limits::max(); + for (IntVarValues candidates(next); candidates(); ++candidates) { + const int position = candidates.val(); + const int target = before[position].val()-1; + const int change = + std::abs(blank/4-target/4) + std::abs(blank%4-target%4) - + std::abs(position/4-target/4) - std::abs(position%4-target%4); + if (change < best_change) { + best = position; + best_change = change; + } + } + return best; +} + static void print_board(std::ostream& os, const Board& board) { for (int i=0; i<16; i++) { @@ -203,6 +228,9 @@ post_goal(Home home, const IntVarArgs& tiles, IntVar length, * Defaults use twelve slides, seed one, and a twelve-move limit. Select * -model fixed to compare with an array representation; -scramble, -seed, * and -limit control the instance and search bound independently. + * -branching min (default) tries blank positions in numerical order; + * -branching manhattan tries the slide with the lowest resulting Manhattan + * distance, breaking ties by the lowest position. * * \ingroup Example */ @@ -222,7 +250,13 @@ class OpenPuzzle : public Script { IntVar start = path.get(*this,0); post_start(*this,state(0),start,initial); rel(*this,path.length() >= manhattan(initial)+1); - branch(*this,path,INT_VAR_NONE(),INT_VAL_MIN()); + IntValBranch vals = INT_VAL_MIN(); + if (opt.branching() == PuzzleOptions::BRANCH_MANHATTAN) + vals = INT_VAL([](const Space& home, IntVar next, int i) { + const OpenPuzzle& s = static_cast(home); + return manhattan_value(s.state(i-1),s.path[i-1].val(),next); + }); + branch(*this,path,INT_VAR_NONE(),vals); } void @@ -291,7 +325,13 @@ class FixedPuzzle : public Script { post_goal(*this,state(i),length,i+1); } rel(*this,length >= manhattan(initial)+1); - branch(*this,path,INT_VAR_NONE(),INT_VAL_MIN(), + IntValBranch vals = INT_VAL_MIN(); + if (opt.branching() == PuzzleOptions::BRANCH_MANHATTAN) + vals = INT_VAL([](const Space& home, IntVar next, int i) { + const FixedPuzzle& s = static_cast(home); + return manhattan_value(s.state(i-1),s.path[i-1].val(),next); + }); + branch(*this,path,INT_VAR_NONE(),vals, [](const Space& home, IntVar, int i) { const FixedPuzzle& s = static_cast(home); const int g = s.depth();