From accad1a0c377169d4c94a4ad377b5813aee0c819 Mon Sep 17 00:00:00 2001
From: Mikael Zayenz Lagerkvist <lagerkvist@gecode.dev>
Date: Sat, 3 Oct 2026 12:20:45 +0200
Subject: [PATCH 01/13] Add quadratic inter-distance bounds propagation

---
 Makefile.in                   |   6 +-
 changelog.in                  |  10 +
 cmake/GecodeSources.cmake     |   2 +
 gecode/int.hh                 |  25 ++
 gecode/int/inter-distance.cpp | 500 ++++++++++++++++++++++++++++++++++
 gecode/int/inter-distance.hh  |  87 ++++++
 test/int/inter-distance.cpp   | 277 +++++++++++++++++++
 7 files changed, 904 insertions(+), 3 deletions(-)
 create mode 100644 gecode/int/inter-distance.cpp
 create mode 100644 gecode/int/inter-distance.hh
 create mode 100644 test/int/inter-distance.cpp

diff --git a/Makefile.in b/Makefile.in
index 26d8c94e77..8e5d2c625d 100755
--- a/Makefile.in
+++ b/Makefile.in
@@ -337,7 +337,7 @@ INTSRC0 = \
 	bin-packing/conflict-graph.cpp \
 	order.cpp order/propagate.cpp \
 	unary.cpp cumulative.cpp cumulatives.cpp \
-	circuit.cpp no-overlap.cpp nvalues.cpp \
+	circuit.cpp no-overlap.cpp inter-distance.cpp nvalues.cpp \
 	member.cpp min-distance.cpp branch/action.cpp branch/chb.cpp \
 	arithmetic/mult.cpp  \
 	branch/view-sel.cpp branch/val-sel-commit.cpp \
@@ -428,7 +428,7 @@ INTHDR0 = \
 	circuit.hh circuit/base.hpp circuit/val.hpp circuit/dom.hpp \
 	no-overlap.hh no-overlap/dim.hpp no-overlap/box.hpp \
 	no-overlap/base.hpp no-overlap/man.hpp no-overlap/opt.hpp \
-	nvalues.hh nvalues/range-event.hpp \
+	inter-distance.hh nvalues.hh nvalues/range-event.hpp \
 	nvalues/sym-bit-matrix.hpp nvalues/graph.hpp \
 	nvalues/bool-base.hpp nvalues/bool-eq.hpp \
 	nvalues/bool-lq.hpp nvalues/bool-gq.hpp \
@@ -1122,7 +1122,7 @@ INTTESTSRC00 = \
 	rel linear gcc sorted unshare exec sequence \
 	mm-arithmetic mm-bool mm-lin mm-count mm-rel \
 	bin-packing order unary cumulative cumulatives circuit \
-	no-overlap precede nvalues member min-distance
+	no-overlap precede inter-distance nvalues member min-distance
 INTTESTSRC0 = test/int.cpp $(INTTESTSRC00:%=test/int/%.cpp)
 INTTESTOBJ = $(INTTESTSRC0:%.cpp=%$(OBJSUFFIX))
 
diff --git a/changelog.in b/changelog.in
index 219972aeb1..39cf03f875 100755
--- a/changelog.in
+++ b/changelog.in
@@ -162,6 +162,16 @@ The propagation algorithms follow:
 M. Z. Lagerkvist, Propagation Algorithms for the Minimum-Distance Constraint
 over Selected Points, ModRef 2026.
 
+[ENTRY]
+Module: int
+What:   new
+Rank:   major
+Thanks: Claude-Guy Quimper
+[DESCRIPTION]
+Add the inter-distance constraint with quadratic bounds filtering, adopting
+Claude-Guy Quimper's 2006 submission and the algorithm of Quimper,
+Lopez-Ortiz, and Pesant (AAAI 2006).
+
 [RELEASE]
 Version: 6.4.0
 Date: 2026-07-15
diff --git a/cmake/GecodeSources.cmake b/cmake/GecodeSources.cmake
index 09b4365587..58a415eb36 100644
--- a/cmake/GecodeSources.cmake
+++ b/cmake/GecodeSources.cmake
@@ -88,6 +88,7 @@ set(GECODE_INT_SOURCES
   gecode/int/extensional/tuple-set.cpp
   gecode/int/gcc.cpp
   gecode/int/int-set.cpp
+  gecode/int/inter-distance.cpp
   gecode/int/ldsb.cpp
   gecode/int/ldsb/sym-imp.cpp
   gecode/int/ldsb/sym-obj.cpp
@@ -415,6 +416,7 @@ set(GECODE_TEST_SOURCES
   test/int/exec.cpp
   test/int/extensional.cpp
   test/int/gcc.cpp
+  test/int/inter-distance.cpp
   test/int/linear.cpp
   test/int/member.cpp
   test/int/min-distance.cpp
diff --git a/gecode/int.hh b/gecode/int.hh
index 7d0e765955..382ac4ef43 100755
--- a/gecode/int.hh
+++ b/gecode/int.hh
@@ -1748,6 +1748,31 @@ namespace Gecode {
   //@}
 
 
+  /**
+   * \defgroup TaskModelIntInterDistance Inter-distance constraint
+   * \ingroup TaskModelInt
+   */
+  //@{
+  /** \brief Post bounds-consistent propagator for \f$|x_i-x_j|\geq p\f$ for all \f$0\leq i\neq j<|x|\f$
+   *
+   * Uses the quadratic algorithm of Quimper, Lopez-Ortiz, and Pesant
+   * (AAAI 2006). Supports bounds(Z) consistency (all values of \a ipl).
+   * Domains with holes are treated as intervals between their bounds.
+   * Each filtering pass uses quadratic time and temporary space.
+   *
+   * A zero distance, or fewer than two variables, imposes no restriction.
+   * A distance of one is propagated as a bounds-consistent distinct constraint.
+   *
+   * Throws Int::OutOfLimits if \a p is negative or exceeds Int::Limits::max.
+   * Throws Int::ArgumentSame if \a p is positive and \a x contains the same
+   * unassigned variable multiply.
+   */
+  GECODE_INT_EXPORT void
+  inter_distance(Home home, const IntVarArgs& x, int p,
+                 IntPropLevel ipl=IPL_DEF);
+  //@}
+
+
   /**
    * \defgroup TaskModelIntDistinct Distinct constraints
    * \ingroup TaskModelInt
diff --git a/gecode/int/inter-distance.cpp b/gecode/int/inter-distance.cpp
new file mode 100644
index 0000000000..da4a022a60
--- /dev/null
+++ b/gecode/int/inter-distance.cpp
@@ -0,0 +1,500 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Claude-Guy Quimper
+ *
+ *  Contributing authors:
+ *     Mikael Zayenz Lagerkvist <lagerkvist@gecode.dev>
+ *
+ *  Copyright:
+ *     Claude-Guy Quimper, 2006
+ *     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 <gecode/int/inter-distance.hh>
+#include <gecode/int/distinct.hh>
+
+#include <algorithm>
+#include <limits>
+
+namespace Gecode { namespace Int { namespace InterDistance {
+
+  namespace {
+    typedef long long int Time;
+    typedef std::ptrdiff_t RegionIndex;
+
+    /// Release time, deadline, and position in release-time order
+    struct Task {
+      Time min, max;
+      int minRank, maxRank;
+    };
+
+    /// Forbidden starting times (inclusive)
+    struct Forbidden {
+      Time min, max;
+    };
+
+    /// Adjustment interval in a doubly linked list sorted by minimum
+    struct Adjustment {
+      Time min, max;
+      RegionIndex previous, next;
+    };
+
+    /**
+     * \brief Scratch data for one direction of bounds filtering
+     *
+     * The Garey-Johnson-Simons-Tarjan feasibility pass constructs forbidden
+     * starting regions. An earliest-completion table and a latest-start
+     * vector allow the dominance sweep to generate only quadratically many
+     * adjustment intervals. The linked list and union-find propagate changes
+     * to bounds without rescanning all variables for each interval.
+     */
+    class Filter {
+    public:
+      const int n;
+      const Time p;
+      Task* tasks;
+      Task** minSorted;
+      Task** maxSorted;
+      Forbidden* forbidden;
+      int forbiddenCount;
+      Time* ectTable;
+      Time* lstTable;
+      Adjustment* regions;
+      RegionIndex regionCount;
+      RegionIndex* firstRegion;
+      RegionIndex* nextRegion;
+      Time* bounds;
+      int* links;
+      bool* processed;
+      int* leader;
+      /// Allocate scratch storage, with no persistent ownership
+      Filter(Region& r, int n0, int p0)
+        : n(n0), p(p0), forbiddenCount(0), regionCount(0) {
+        const size_t count = static_cast<size_t>(n);
+        const size_t limit = std::numeric_limits<size_t>::max();
+        // Region::alloc multiplies unchecked. Reject impossible byte sizes
+        // before allocating the quadratic tables or interval list.
+        if ((count > limit / sizeof(Time) / (count+1)) ||
+            (count > (limit / sizeof(Adjustment) - 3) / (count+3)))
+          throw MemoryExhausted();
+        tasks = r.alloc<Task>(n);
+        minSorted = r.alloc<Task*>(n);
+        maxSorted = r.alloc<Task*>(n);
+        forbidden = r.alloc<Forbidden>(n);
+        const size_t entries = count * (count+1);
+        ectTable = static_cast<Time*>(r.ralloc(entries * sizeof(Time)));
+        lstTable = r.alloc<Time>(n+2);
+        const size_t capacity = count * (count+3) / 2 + 3;
+        regions = static_cast<Adjustment*>(
+          r.ralloc(capacity * sizeof(Adjustment)));
+        firstRegion = r.alloc<RegionIndex>(n);
+        nextRegion = r.alloc<RegionIndex>(n);
+        bounds = r.alloc<Time>(n);
+        links = r.alloc<int>(n);
+        processed = r.alloc<bool>(n);
+        leader = r.alloc<int>(n);
+      }
+      /// Earliest completion time for q tasks at release time i
+      Time ect(int i, int q) const {
+        return ectTable[static_cast<size_t>(q)*n+i];
+      }
+      /// Latest start time for q tasks at the current deadline
+      Time lst(int q) const {
+        return lstTable[q];
+      }
+      /// Find the representative of a merged group of bounds
+      int find(int i) {
+        int j = i;
+        while (links[j] > j)
+          j = links[j];
+        while (links[i] > i) {
+          int k = links[i];
+          links[i] = j;
+          i = k;
+        }
+        return j;
+      }
+      /// Notify bounds of a new or expanded adjustment interval
+      int notify(RegionIndex r, int vi) {
+        assert((vi >= 0) && (links[vi] < vi));
+        while ((links[vi] >= 0) &&
+               (bounds[links[vi]] >= regions[r].min))
+          vi = links[vi];
+        while (regions[r].min <= bounds[vi]) {
+          if (bounds[vi] <= regions[r].max) {
+            while ((vi < n-1) &&
+                   (regions[r].max+1 >= minSorted[vi+1]->min)) {
+              int previous = links[vi];
+              links[vi] = vi+1;
+              vi = find(vi);
+              links[vi] = previous;
+            }
+            if (regions[r].max >= bounds[vi])
+              bounds[vi] = regions[r].max+1;
+          }
+          if (regions[r].min < regions[nextRegion[vi]].min)
+            r = nextRegion[vi];
+          else
+            nextRegion[vi] = r;
+          r = regions[r].next;
+        }
+        assert((vi >= 0) && (links[vi] < vi));
+        return vi;
+      }
+      /// Sort bounds and compute forbidden regions; detect infeasibility
+      bool initialize(Region& r) {
+        for (int i=0; i<n; i++)
+          minSorted[i] = maxSorted[i] = tasks+i;
+        std::sort(minSorted,minSorted+n,[](const Task* a, const Task* b) {
+          return (a->min < b->min) ||
+            ((a->min == b->min) && (a->max < b->max));
+        });
+        std::sort(maxSorted,maxSorted+n,[](const Task* a, const Task* b) {
+          return (a->max < b->max) ||
+            ((a->max == b->max) && (a->min < b->min));
+        });
+        Time* deadlines = r.alloc<Time>(n);
+        int dc = 0;
+        for (int i=0; i<n; i++) {
+          minSorted[i]->minRank = i;
+          if ((i == 0) || (maxSorted[i]->max > deadlines[dc-1]))
+            deadlines[dc++] = maxSorted[i]->max;
+          maxSorted[i]->maxRank = dc-1;
+        }
+        Time* times = r.alloc<Time>(dc);
+        int* cursor = r.alloc<int>(dc);
+        Forbidden* buffer = r.alloc<Forbidden>(n);
+        // Indices avoid both the one-past-end write and the before-begin
+        // pointer formed by the original 2006 implementation.
+        int last = n-1;
+        for (int i=0; i<dc; i++) {
+          times[i] = deadlines[i];
+          cursor[i] = last;
+        }
+        Time min = std::numeric_limits<Time>::max();
+        Time newMin = min;
+        forbiddenCount = 0;
+        for (int i=n; i--;) {
+          for (int j=minSorted[i]->maxRank; j<dc; j++) {
+            times[j] -= p;
+            while ((cursor[j] > last) &&
+                   (times[j] < buffer[cursor[j]].min))
+              cursor[j]--;
+            if ((cursor[j] > last) &&
+                (times[j] <= buffer[cursor[j]].max))
+              times[j] = buffer[cursor[j]--].min-1;
+            newMin = std::min(newMin,times[j]);
+          }
+          if ((i == 0) || (minSorted[i-1]->min < minSorted[i]->min))
+            min = newMin;
+          if (min < minSorted[i]->min)
+            return false;
+          if (min-p+1 < minSorted[i]->min) {
+            if ((forbiddenCount > 0) &&
+                (minSorted[i]->min > buffer[last+1].min)) {
+              buffer[last+1].min = min-p+1;
+            } else {
+              assert(last >= 0);
+              buffer[last--] = {min-p+1,minSorted[i]->min-1};
+              forbiddenCount++;
+            }
+          }
+        }
+        for (int i=0; i<forbiddenCount; i++)
+          forbidden[i] = buffer[last+1+i];
+        for (int i=0; i<n; i++) {
+          ectTable[i] = minSorted[i]->min;
+          int er = 0;
+          for (int q=1; q<=n; q++) {
+            Time start = ect(i,q-1);
+            while ((er < forbiddenCount) && (forbidden[er].max < start))
+              er++;
+            if ((er < forbiddenCount) && (forbidden[er].min <= start))
+              start = forbidden[er].max+1;
+            ectTable[static_cast<size_t>(q)*n+i] = start+p;
+          }
+        }
+        return true;
+      }
+      /// Apply internal adjustments, then external adjustments by deadline
+      void prune(void) {
+        const Time infinity = std::numeric_limits<Time>::max();
+        regions[0] = {-infinity,-infinity,-1,1};
+        regions[1] = {infinity,infinity,0,-1};
+        regionCount = 2;
+        RegionIndex lastRegion = 0;
+        for (int i=0; i<n; i++) {
+          links[i] = i-1;
+          processed[i] = false;
+          bounds[i] = minSorted[i]->min;
+          nextRegion[i] = 0;
+        }
+        int minP = n, maxP = 0;
+        for (int it=0; it<n; it++) {
+          int i = maxSorted[it]->minRank;
+          processed[i] = true;
+          maxP = std::max(maxP,i);
+          minP = std::min(minP,i);
+          int l = leader[i] = i;
+          int kp = 1;
+          while (++l <= maxP)
+            if (processed[l])
+              kp++;
+          l = i;
+          int k = kp;
+          if (i > minP) {
+            while (!processed[--l]) {}
+            k++;
+            while (l > leader[l]) {
+              while (!processed[--l]) {}
+              k++;
+            }
+            if (ect(i,1) > ect(l,k-kp+1)) {
+              l = i;
+              k = kp;
+            }
+          }
+          kp = k;
+          int j = l;
+          while (j < maxP) {
+            while (!processed[++j]) {}
+            if (ect(j,1) <= ect(l,k- --kp+1))
+              leader[j] = l;
+            else
+              break;
+          }
+          if ((it < n-1) && (maxSorted[it]->max == maxSorted[it+1]->max))
+            continue;
+          // Only one deadline is needed at a time. Computing this vector
+          // per deadline keeps quadratic time but removes a quadratic
+          // latest-start table. The extra entry serves external adjustments.
+          lstTable[0] = maxSorted[it]->max;
+          int lr = forbiddenCount-1;
+          for (int t=1; t<=it+2; t++) {
+            Time start = lst(t-1)-p;
+            while ((lr >= 0) && (forbidden[lr].min > start))
+              lr--;
+            if ((lr >= 0) && (forbidden[lr].max >= start))
+              start = forbidden[lr].min-1;
+            lstTable[t] = start;
+          }
+          int q = 0;
+          RegionIndex insertion = 0;
+          int vi = n-1;
+          while (true) {
+            for (int t=q; t<k; t++) {
+              regions[regionCount].min = lst(t+1)+1;
+              // The final empty region allows external adjustments to
+              // expand the preceding intervals by one more task.
+              regions[regionCount].max = (l >= 0) ? ect(l,k-t)-1 : -infinity;
+              if (t > 0) {
+                while (regions[insertion+1].min >= regions[insertion].min) {
+                  insertion = regions[insertion].previous;
+                  if (insertion >= 0) {
+                    if (regions[insertion].min <= regions[regionCount].min) {
+                      insertion--;
+                      break;
+                    }
+                  } else {
+                    break;
+                  }
+                }
+                insertion++;
+                while (regions[regions[insertion].next].min <
+                       regions[regionCount].min)
+                  insertion = regions[insertion].next;
+              } else {
+                insertion = lastRegion;
+                firstRegion[i] = lastRegion = regionCount;
+              }
+              assert(regions[insertion].min <= regions[regionCount].min);
+              RegionIndex next = regions[insertion].next;
+              regions[regionCount].next = next;
+              regions[insertion].next = regionCount;
+              regions[regionCount].previous = insertion;
+              regions[next].previous = regionCount;
+              assert(regions[regionCount].min <= regions[next].min);
+              vi = notify(regionCount++,vi);
+            }
+            if (l == -1)
+              break;
+            q = k++;
+            if (l > minP) {
+              while (!processed[--l]) {}
+              j = leader[l];
+              while (j < l) {
+                while (!processed[--l]) {}
+                k++;
+              }
+            } else {
+              l = -1;
+            }
+          }
+        }
+        // A variable is filtered before adding external intervals for its
+        // deadline, so it is never excluded by an interval it helped create.
+        for (int it=0; it<n; it++) {
+          int i = maxSorted[it]->minRank;
+          maxSorted[it]->min = bounds[find(i)];
+          if ((it == n-1) || (maxSorted[it]->max != maxSorted[it+1]->max)) {
+            int vi = n-1;
+            Time lastMax = regions[firstRegion[i]].max;
+            for (RegionIndex r=firstRegion[i]+1;
+                 (r < regionCount) && (regions[r].min < regions[r-1].min);
+                 r++) {
+              Time oldMax = regions[r].max;
+              regions[r].max = lastMax;
+              lastMax = oldMax;
+              vi = notify(r,vi);
+            }
+          }
+        }
+      }
+    };
+
+    /// Check the defining inequality once every view is assigned
+    bool valid_assignment(const ViewArray<IntView>& x, int p) {
+      for (int i=0; i<x.size(); i++)
+        for (int j=0; j<i; j++) {
+          Time d = static_cast<Time>(x[i].val())-x[j].val();
+          if ((-p < d) && (d < p))
+            return false;
+        }
+      return true;
+    }
+  }
+
+  Bnd::Bnd(Home home, ViewArray<IntView>& x0, int p0)
+    : NaryPropagator<IntView,PC_INT_BND>(home,x0), p(p0) {}
+
+  Bnd::Bnd(Space& home, Bnd& b)
+    : NaryPropagator<IntView,PC_INT_BND>(home,b), p(b.p) {}
+
+  Propagator*
+  Bnd::copy(Space& home) {
+    return new (home) Bnd(home,*this);
+  }
+
+  PropCost
+  Bnd::cost(const Space&, const ModEventDelta&) const {
+    return PropCost::quadratic(PropCost::HI,x.size());
+  }
+
+  size_t
+  Bnd::dispose(Space& home) {
+    (void) NaryPropagator<IntView,PC_INT_BND>::dispose(home);
+    return sizeof(*this);
+  }
+
+  ExecStatus
+  Bnd::post(Home home, ViewArray<IntView>& x, int p) {
+    if (x.size() > 1)
+      (void) new (home) Bnd(home,x,p);
+    return ES_OK;
+  }
+
+  ExecStatus
+  Bnd::propagate(Space& home, const ModEventDelta&) {
+    int min = x[0].min(), max = x[0].max();
+    bool assigned = true;
+    for (int i=0; i<x.size(); i++) {
+      min = std::min(min,x[i].min());
+      max = std::max(max,x[i].max());
+      assigned &= x[i].assigned();
+    }
+    if (assigned) {
+      // In particular, check assignments obtained by jumping across holes
+      // in the previous invocation. No filtering tables are needed here.
+      if (!valid_assignment(x,p))
+        return ES_FAILED;
+      return home.ES_SUBSUMED(*this);
+    }
+    if (static_cast<Time>(max)-min < static_cast<Time>(x.size()-1)*p)
+      return ES_FAILED;
+    Region region;
+    Filter f(region,x.size(),p);
+    bool nofix = false;
+    for (int direction=0; direction<2; direction++) {
+      for (int i=0; i<x.size(); i++) {
+        // Reverse task time: [r,d] becomes [-d,-r]. Variables denote
+        // starting times, while the algorithm's maxima are deadlines.
+        f.tasks[i].min = direction ? -static_cast<Time>(x[i].max())-p : x[i].min();
+        f.tasks[i].max = direction ? -static_cast<Time>(x[i].min()) :
+          static_cast<Time>(x[i].max())+p;
+      }
+      if (!f.initialize(region))
+        return ES_FAILED;
+      f.prune();
+      for (int i=0; i<x.size(); i++) {
+        Time bound = direction ? -f.tasks[i].min-p : f.tasks[i].min;
+        // Check in wide arithmetic before converting to the view's type.
+        if (direction ? (bound < x[i].min()) : (bound > x[i].max()))
+          return ES_FAILED;
+        ModEvent me = direction ? x[i].lq(home,static_cast<int>(bound)) :
+          x[i].gq(home,static_cast<int>(bound));
+        GECODE_ME_CHECK(me);
+        nofix |= (direction ? x[i].max() : x[i].min()) != bound;
+      }
+    }
+    assigned = true;
+    for (int i=0; i<x.size(); i++)
+      assigned &= x[i].assigned();
+    if (assigned) {
+      if (!valid_assignment(x,p))
+        return ES_FAILED;
+      return home.ES_SUBSUMED(*this);
+    }
+    // The interval algorithm reaches a fixpoint in one pair of sweeps.
+    // Actual bounds can jump across holes; only those jumps need a rerun.
+    return nofix ? ES_NOFIX : ES_FIX;
+  }
+
+}}}
+
+namespace Gecode {
+
+  void
+  inter_distance(Home home, const IntVarArgs& x, int p, IntPropLevel) {
+    using namespace Int;
+    Limits::nonnegative(p,"Int::inter_distance");
+    if ((p > 0) && same(x))
+      throw ArgumentSame("Int::inter_distance");
+    GECODE_POST;
+    if ((p == 0) || (x.size() < 2))
+      return;
+    ViewArray<IntView> xv(home,x);
+    if (p == 1) {
+      GECODE_ES_FAIL(Distinct::Bnd<IntView>::post(home,xv));
+    } else {
+      GECODE_ES_FAIL(InterDistance::Bnd::post(home,xv,p));
+    }
+  }
+
+}
+
+// STATISTICS: int-post
diff --git a/gecode/int/inter-distance.hh b/gecode/int/inter-distance.hh
new file mode 100644
index 0000000000..0be0d0e1b4
--- /dev/null
+++ b/gecode/int/inter-distance.hh
@@ -0,0 +1,87 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Claude-Guy Quimper
+ *
+ *  Contributing authors:
+ *     Mikael Zayenz Lagerkvist <lagerkvist@gecode.dev>
+ *
+ *  Copyright:
+ *     Claude-Guy Quimper, 2006
+ *     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.
+ *
+ */
+
+#ifndef GECODE_INT_INTER_DISTANCE_HH
+#define GECODE_INT_INTER_DISTANCE_HH
+
+#include <gecode/int.hh>
+
+/**
+ * \namespace Gecode::Int::InterDistance
+ * \brief Inter-distance propagator
+ */
+namespace Gecode { namespace Int { namespace InterDistance {
+
+  /**
+   * \brief Bounds-consistent inter-distance propagator
+   *
+   * Based on Claude-Guy Quimper, Alejandro Lopez-Ortiz, and Gilles Pesant,
+   * A Quadratic Propagator for the Inter-Distance Constraint,
+   * AAAI 2006, 123--128, and Quimper's 2006 implementation.
+   *
+   * Only the views and distance are kept across invocations. Quadratic
+   * scratch storage is allocated in a region and is not copied on cloning.
+   *
+   * Requires \code #include <gecode/int/inter-distance.hh> \endcode
+   * \ingroup FuncIntProp
+   */
+  class Bnd : public NaryPropagator<IntView,PC_INT_BND> {
+  protected:
+    /// Minimum distance
+    int p;
+    /// Constructor for posting
+    Bnd(Home home, ViewArray<IntView>& x, int p);
+    /// Constructor for cloning
+    Bnd(Space& home, Bnd& b);
+  public:
+    /// Copy during cloning
+    virtual Propagator* copy(Space& home);
+    /// Quadratic propagation cost
+    virtual PropCost cost(const Space&, const ModEventDelta&) const;
+    /// Perform propagation
+    virtual ExecStatus propagate(Space& home, const ModEventDelta&);
+    /// Cancel subscriptions and dispose
+    virtual size_t dispose(Space& home);
+    /// Post propagator
+    static ExecStatus post(Home home, ViewArray<IntView>& x, int p);
+  };
+
+}}}
+
+#endif
+
+// STATISTICS: int-prop
diff --git a/test/int/inter-distance.cpp b/test/int/inter-distance.cpp
new file mode 100644
index 0000000000..16d7cf8113
--- /dev/null
+++ b/test/int/inter-distance.cpp
@@ -0,0 +1,277 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Mikael Zayenz Lagerkvist <lagerkvist@gecode.dev>
+ *
+ *  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 <algorithm>
+#include <vector>
+#include <limits>
+
+namespace Test { namespace Int { namespace InterDistance {
+
+  /// Exercise assignment, cloning, search, and bounds(Z) consistency
+  class Distance : public Test {
+  protected:
+    int p;
+  public:
+    Distance(int n, int p0, int min, int max)
+      : Test("InterDistance::"+str(n)+"::"+str(p0)+"::"+str(min),
+             n,min,max), p(p0) {
+      contest = CTL_BOUNDS_Z;
+    }
+    virtual bool solution(const Assignment& x) const {
+      for (int i=0; i<x.size(); i++)
+        for (int j=0; j<i; j++) {
+          long long int d = static_cast<long long int>(x[i])-x[j];
+          if ((-p < d) && (d < p))
+            return false;
+        }
+      return true;
+    }
+    virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
+      Gecode::inter_distance(home,x,p);
+    }
+  };
+
+  /// Small independent oracle for heterogeneous and holey domains
+  class Bounds : public Base {
+    class Model : public Gecode::Space {
+    public:
+      Gecode::IntVarArray x;
+      Model(const std::vector<std::vector<int> >& domains)
+        : x(*this,static_cast<int>(domains.size())) {
+        for (int i=0; i<x.size(); i++)
+          x[i] = Gecode::IntVar(*this,Gecode::IntSet(
+            domains[i].data(),static_cast<int>(domains[i].size())));
+      }
+      Model(Model& s) : Gecode::Space(s) {
+        x.update(*this,s.x);
+      }
+      virtual Gecode::Space* copy(void) {
+        return new Model(*this);
+      }
+    };
+    /// Enumerate tuples using only the defining pairwise inequality
+    static void supports(const std::vector<std::vector<int> >& dom, int p,
+                         int i, std::vector<int>& tuple,
+                         std::vector<int>& lo, std::vector<int>& hi,
+                         bool& found) {
+      if (i == static_cast<int>(dom.size())) {
+        found = true;
+        for (int j=0; j<i; j++) {
+          lo[j] = std::min(lo[j],tuple[j]);
+          hi[j] = std::max(hi[j],tuple[j]);
+        }
+        return;
+      }
+      for (int value : dom[i]) {
+        bool valid = true;
+        for (int j=0; j<i; j++) {
+          long long int d = static_cast<long long int>(value)-tuple[j];
+          if ((-p < d) && (d < p)) {
+            valid = false;
+            break;
+          }
+        }
+        if (valid) {
+          tuple[i] = value;
+          supports(dom,p,i+1,tuple,lo,hi,found);
+        }
+      }
+    }
+    static bool check(const std::vector<std::vector<int> >& dom, int p,
+                      bool dense) {
+      const int n = static_cast<int>(dom.size());
+      std::vector<int> tuple(n), lo(n,Gecode::Int::Limits::max),
+        hi(n,Gecode::Int::Limits::min);
+      bool found = false;
+      supports(dom,p,0,tuple,lo,hi,found);
+      Model m(dom);
+      Gecode::inter_distance(m,m.x,p);
+      bool failed = m.status() == Gecode::SS_FAILED;
+      bool correct = found ? !failed : (!dense || failed);
+      if (found && !failed)
+        for (int i=0; i<n; i++)
+          correct &= dense ? ((m.x[i].min() == lo[i]) &&
+                              (m.x[i].max() == hi[i])) :
+            ((m.x[i].min() <= lo[i]) && (m.x[i].max() >= hi[i]));
+      if (!dense && !failed) {
+        // Bounds(Z) supports may use holes in other variables. Enumerate
+        // the final interval hulls to check that every remaining bound
+        // has such a support, including bounds that jumped across holes.
+        std::vector<std::vector<int> > hull(n);
+        for (int i=0; i<n; i++)
+          for (int v=m.x[i].min(); v<=m.x[i].max(); v++)
+            hull[i].push_back(v);
+        std::fill(lo.begin(),lo.end(),Gecode::Int::Limits::max);
+        std::fill(hi.begin(),hi.end(),Gecode::Int::Limits::min);
+        found = false;
+        supports(hull,p,0,tuple,lo,hi,found);
+        correct &= found;
+        for (int i=0; i<n; i++)
+          correct &= (m.x[i].min() == lo[i]) && (m.x[i].max() == hi[i]);
+      }
+      if (!correct) {
+        olog << "Distance " << p << ", domains:";
+        for (const auto& d : dom) {
+          olog << " {";
+          for (int v : d)
+            olog << v << ',';
+          olog << '}';
+        }
+        olog << " propagated " << m.x << std::endl;
+      }
+      return correct;
+    }
+  public:
+    Bounds(void) : Base("Int::InterDistance::BoundsOracle") {}
+    virtual bool run(void) {
+      // The paper's example, including its reflected form.
+      if (!check({{2,3,4,5,6},{10,11,12,13,14},
+                  {4,5,6,7,8,9,10,11,12,13,14,15}},6,true))
+        return false;
+      if (!check({{-6,-5,-4,-3,-2},{-14,-13,-12,-11,-10},
+                  {-15,-14,-13,-12,-11,-10,-9,-8,-7,-6,-5,-4}},6,true))
+        return false;
+      // Upper-bound pruning across holes can assign an invalid tuple in
+      // one pass; it must be checked rather than immediately subsumed.
+      if (!check({{0,2,6,7},{-3,2},{10,11,14},{1,2,3,6},
+                  {-1,0,3,5,9}},4,false))
+        return false;
+      // Exhaust all triples of intervals on [-2,3], including ties.
+      std::vector<std::vector<int> > intervals;
+      for (int l=-2; l<=3; l++)
+        for (int u=l; u<=3; u++) {
+          std::vector<int> d;
+          for (int v=l; v<=u; v++)
+            d.push_back(v);
+          intervals.push_back(d);
+        }
+      for (int p=2; p<=3; p++)
+        for (const auto& a : intervals)
+          for (const auto& b : intervals)
+            for (const auto& c : intervals)
+              if (!check({a,b,c},p,true))
+                return false;
+      // Larger sets cover dominance, external adjustments, holes, and
+      // arithmetic close to both integer limits. Use a fixed local seed.
+      Gecode::Support::RandomGenerator random(2006);
+      for (int test=0; test<2000; test++) {
+        int n = 2+random(7), p = 2+random(8);
+        int offset = (test % 3 == 0) ? Gecode::Int::Limits::min+30 :
+          (test % 3 == 1) ? Gecode::Int::Limits::max-30 : 0;
+        bool dense = (test % 2 == 0);
+        std::vector<std::vector<int> > dom(n);
+        for (int i=0; i<n; i++) {
+          int l = offset+static_cast<int>(random(21))-10;
+          int width = random(5);
+          for (int j=0; j<=width; j++)
+            if (dense || (j == 0) || (j == width) || random(2))
+              dom[i].push_back(l+j);
+        }
+        if (!check(dom,p,dense))
+          return false;
+      }
+      // A maximal distance exercises deadlines beyond Int::Limits::max.
+      const int limit = Gecode::Int::Limits::max;
+      return check({{-limit,-limit+1},{0,1},{limit-1,limit}},limit,true);
+    }
+  };
+
+  /// Posting contracts, vacuous constraints, and shared variables
+  class Posting : public Base {
+    class Model : public Gecode::Space {
+    public:
+      Model(void) {}
+      Model(Model& s) : Gecode::Space(s) {}
+      virtual Gecode::Space* copy(void) {
+        return new Model(*this);
+      }
+    };
+  public:
+    Posting(void) : Base("Int::InterDistance::Posting") {}
+    virtual bool run(void) {
+      using namespace Gecode;
+      Model s;
+      IntVar v(s,-2,2);
+      IntVarArgs duplicate(2);
+      duplicate[0] = duplicate[1] = v;
+      inter_distance(s,duplicate,0);
+      bool same = false, negative = false, tooLarge = false;
+      try {
+        inter_distance(s,duplicate,2);
+      } catch (const Gecode::Int::ArgumentSame&) {
+        same = true;
+      }
+      try {
+        inter_distance(s,IntVarArgs(),-1);
+      } catch (const Gecode::Int::OutOfLimits&) {
+        negative = true;
+      }
+      try {
+        inter_distance(s,IntVarArgs(),std::numeric_limits<int>::max());
+      } catch (const Gecode::Int::OutOfLimits&) {
+        tooLarge = true;
+      }
+      inter_distance(s,IntVarArgs(),2);
+      IntVarArgs singleton(1);
+      singleton[0] = v;
+      inter_distance(s,singleton,2);
+      if (!same || !negative || !tooLarge || (s.status() == SS_FAILED))
+        return false;
+      Model t;
+      IntVar assigned(t,3,3);
+      duplicate[0] = duplicate[1] = assigned;
+      inter_distance(t,duplicate,2);
+      return t.status() == SS_FAILED;
+    }
+  };
+
+  class Create {
+  public:
+    Create(void) {
+      for (int n=1; n<=4; n++)
+        for (int p=0; p<=4; p++)
+          (void) new Distance(n,p,-3,3);
+      (void) new Distance(3,2,Gecode::Int::Limits::min,
+                             Gecode::Int::Limits::min+5);
+      (void) new Distance(3,2,Gecode::Int::Limits::max-5,
+                             Gecode::Int::Limits::max);
+    }
+  } create;
+  Bounds bounds;
+  Posting posting;
+
+}}}
+
+// STATISTICS: test-int

From bcfb63891ae0c4f00b83c4b24e4ad1af7639c82b Mon Sep 17 00:00:00 2001
From: Mikael Zayenz Lagerkvist <lagerkvist@gecode.dev>
Date: Sat, 3 Oct 2026 13:41:47 +0200
Subject: [PATCH 02/13] Stage inter-distance propagation and support variable
 separation

---
 changelog.in                  |   6 +-
 gecode/int.hh                 |  36 +++-
 gecode/int/inter-distance.cpp | 319 ++++++++++++++++++++++++++++++----
 gecode/int/inter-distance.hh  |  24 ++-
 test/int/inter-distance.cpp   | 241 +++++++++++++++++++++++--
 5 files changed, 565 insertions(+), 61 deletions(-)

diff --git a/changelog.in b/changelog.in
index 39cf03f875..4b23946977 100755
--- a/changelog.in
+++ b/changelog.in
@@ -168,9 +168,11 @@ What:   new
 Rank:   major
 Thanks: Claude-Guy Quimper
 [DESCRIPTION]
-Add the inter-distance constraint with quadratic bounds filtering, adopting
+Add the inter-distance constraint for fixed and variable separation, adopting
 Claude-Guy Quimper's 2006 submission and the algorithm of Quimper,
-Lopez-Ortiz, and Pesant (AAAI 2006).
+Lopez-Ortiz, and Pesant (AAAI 2006, CPL 2008). A staged propagator combines
+the logarithmic-time-per-task feasibility check of Garey et al. (1981) with
+quadratic bounds filtering, selected through IPL_BASIC and IPL_ADVANCED.
 
 [RELEASE]
 Version: 6.4.0
diff --git a/gecode/int.hh b/gecode/int.hh
index 382ac4ef43..e5893ede4d 100755
--- a/gecode/int.hh
+++ b/gecode/int.hh
@@ -1755,10 +1755,18 @@ namespace Gecode {
   //@{
   /** \brief Post bounds-consistent propagator for \f$|x_i-x_j|\geq p\f$ for all \f$0\leq i\neq j<|x|\f$
    *
-   * Uses the quadratic algorithm of Quimper, Lopez-Ortiz, and Pesant
-   * (AAAI 2006). Supports bounds(Z) consistency (all values of \a ipl).
-   * Domains with holes are treated as intervals between their bounds.
-   * Each filtering pass uses quadratic time and temporary space.
+   * Uses the algorithms of Garey et al. (1981) and Quimper, Lopez-Ortiz,
+   * and Pesant (AAAI 2006). Domains with holes are treated as intervals
+   * between their bounds.
+   *
+   * - \a IPL_BASIC checks interval feasibility in \f$O(n\log n)\f$ time
+   *   and linear temporary space, where \f$n=|x|\f$.
+   * - \a IPL_ADVANCED and \a IPL_BASIC_ADVANCED first perform
+   *   the basic check, then schedule quadratic bounds(Z) filtering at
+   *   a higher cost. This filtering uses quadratic temporary space.
+   *
+   * The default, \a IPL_DEF, uses both stages. The value/bounds/domain part
+   * of \a ipl does not affect these algorithms.
    *
    * A zero distance, or fewer than two variables, imposes no restriction.
    * A distance of one is propagated as a bounds-consistent distinct constraint.
@@ -1770,6 +1778,26 @@ namespace Gecode {
   GECODE_INT_EXPORT void
   inter_distance(Home home, const IntVarArgs& x, int p,
                  IntPropLevel ipl=IPL_DEF);
+  /** \brief Post inter-distance constraint with variable separation
+   *
+   * Constrains \f$p\geq0\f$ and \f$|x_i-x_j|\geq p\f$ for all
+   * \f$0\leq i\neq j<|x|\f$.
+   *
+   * Uses the same algorithm options as the fixed-distance overload.
+   * The basic stage additionally tightens \a p's upper bound by binary
+   * search using the linear-space feasibility checker. Its time bound
+   * is \f$O(n\log n\log(1+\max(p)))\f$. The advanced stage provides
+   * bounds(Z) consistency for \a x using the minimum of \a p, giving
+   * bounds(Z) consistency for the whole constraint (CPL 3, 2008).
+   *
+   * Fewer than two variables only constrain \a p to be nonnegative.
+   * With at least two variables, throws Int::ArgumentSame if \a p is the
+   * same unassigned variable as a member of \a x, or if \a p can be positive
+   * and \a x contains the same unassigned variable multiply.
+   */
+  GECODE_INT_EXPORT void
+  inter_distance(Home home, const IntVarArgs& x, IntVar p,
+                 IntPropLevel ipl=IPL_DEF);
   //@}
 
 
diff --git a/gecode/int/inter-distance.cpp b/gecode/int/inter-distance.cpp
index da4a022a60..9d866a554e 100644
--- a/gecode/int/inter-distance.cpp
+++ b/gecode/int/inter-distance.cpp
@@ -40,6 +40,7 @@
 
 #include <algorithm>
 #include <limits>
+#include <map>
 
 namespace Gecode { namespace Int { namespace InterDistance {
 
@@ -58,6 +59,183 @@ namespace Gecode { namespace Int { namespace InterDistance {
       Time min, max;
     };
 
+    /**
+     * \brief Linear-space feasibility checker of Garey et al. (1981)
+     *
+     * Algorithm B represents each deadline's critical time as its deadline
+     * minus its task load and pseudo-offset. A Fenwick tree maintains loads.
+     * A weighted union-find merges deadlines with the same residue modulo p;
+     * an ordered map locates residues affected by a forbidden region. Each
+     * deadline is inserted once and each merge removes a residue, giving
+     * O(n log n) time. Relevant deadlines are kept in deadline order, with
+     * dominated predecessors removed permanently (Lemmas 5 and 6).
+     */
+    class Feasibility {
+      const int n;
+      int dc;
+      Task* tasks;
+      Task** release;
+      Time* deadlines;
+      int* loads;
+      int* successor;
+      int* previous;
+      int* parent;
+      int* size;
+      Time* offset;
+      /// First remaining relevant deadline at or after i
+      int find(int i) {
+        int root = i;
+        while (successor[root] != root)
+          root = successor[root];
+        while (successor[i] != i) {
+          int next = successor[i];
+          successor[i] = root;
+          i = next;
+        }
+        return root;
+      }
+      /// Number of processed tasks with a deadline at or before i
+      int load(int i) const {
+        int count = 0;
+        for (size_t j=static_cast<size_t>(i)+1; j; j-=j & -j)
+          count += loads[j];
+        return count;
+      }
+      /// Sum weighted links, including the root's shared offset
+      Time displacement(int i) const {
+        if (parent[i] == -1)
+          return 0;
+        Time d = offset[i];
+        while (parent[i] != i) {
+          i = parent[i];
+          d += offset[i];
+        }
+        return d;
+      }
+      /// Merge roots while preserving each deadline's displacement
+      int merge(int a, int b) {
+        if (size[a] < size[b])
+          std::swap(a,b);
+        parent[b] = a;
+        offset[b] -= offset[a];
+        size[a] += size[b];
+        return a;
+      }
+      /// Nonnegative remainder, including for negative deadlines
+      static Time residue(Time t, Time p) {
+        Time q = t % p;
+        return (q < 0) ? q+p : q;
+      }
+      /// Pseudo-critical time for deadline i
+      Time critical(int i, Time p) const {
+        return deadlines[i]+p-static_cast<Time>(load(i))*p-displacement(i);
+      }
+    public:
+      Feasibility(Region& r, const ViewArray<IntView>& x)
+        : n(x.size()), dc(0) {
+        tasks = r.alloc<Task>(n);
+        release = r.alloc<Task*>(n);
+        Task** finish = r.alloc<Task*>(n);
+        deadlines = r.alloc<Time>(n);
+        for (int i=0; i<n; i++) {
+          tasks[i].min = x[i].min();
+          tasks[i].max = x[i].max();
+          release[i] = finish[i] = tasks+i;
+        }
+        std::sort(release,release+n,[](const Task* a, const Task* b) {
+          return (a->min < b->min) ||
+            ((a->min == b->min) && (a->max < b->max));
+        });
+        std::sort(finish,finish+n,[](const Task* a, const Task* b) {
+          return a->max < b->max;
+        });
+        for (int i=0; i<n; i++) {
+          if ((i == 0) || (finish[i]->max != deadlines[dc-1]))
+            deadlines[dc++] = finish[i]->max;
+          finish[i]->maxRank = dc-1;
+        }
+        const size_t count = static_cast<size_t>(dc)+1;
+        loads = r.alloc<int>(count);
+        successor = r.alloc<int>(count);
+        previous = r.alloc<int>(dc);
+        parent = r.alloc<int>(dc);
+        size = r.alloc<int>(dc);
+        offset = r.alloc<Time>(dc);
+      }
+      /// Test interval feasibility, reusing the sorted bounds and scratch
+      bool check(int p) {
+        if (p == 0)
+          return true;
+        std::fill(loads,loads+dc+1,0);
+        for (int i=0; i<dc; i++) {
+          successor[i] = i;
+          previous[i] = i-1;
+          parent[i] = -1;
+        }
+        successor[dc] = dc;
+        std::map<Time,int> fractions;
+        int active = dc, pending = dc-1;
+        for (int i=n; i--;) {
+          int rank = release[i]->maxRank;
+          for (size_t j=static_cast<size_t>(rank)+1;
+               j<=static_cast<size_t>(dc); j+=j & -j)
+            loads[j]++;
+          int d = find(rank);
+          active = std::min(active,d);
+          Time c = critical(d,p);
+          while ((previous[d] >= 0) && (critical(previous[d],p) > c)) {
+            int obsolete = previous[d];
+            successor[obsolete] = d;
+            previous[d] = previous[obsolete];
+            if (active == obsolete)
+              active = d;
+          }
+          if ((i > 0) && (release[i-1]->min == release[i]->min))
+            continue;
+          c = critical(active,p);
+          Time r = release[i]->min;
+          if (c < r)
+            return false;
+          if (c-p+1 >= r)
+            continue;
+          // Only deadlines whose back-schedule can reach this region
+          // are activated. Earlier deadlines must retain zero offsets.
+          while ((pending >= 0) && (deadlines[pending]+p >= c)) {
+            parent[pending] = pending;
+            size[pending] = 1;
+            offset[pending] = 0;
+            Time q = residue(deadlines[pending]+p,p);
+            auto entry = fractions.emplace(q,pending);
+            if (!entry.second)
+              entry.first->second = merge(entry.first->second,pending);
+            pending--;
+          }
+          Time a = residue(c-p,p), b = residue(r,p);
+          auto target = fractions.find(a);
+          int root = (target == fractions.end()) ? -1 : target->second;
+          // The forbidden region is open: (c-p,r). At a wraparound,
+          // residue zero is included precisely when it is below b.
+          auto consume = [&](std::map<Time,int>::iterator it, Time end) {
+            while ((it != fractions.end()) && (it->first < end)) {
+              int group = it->second;
+              offset[group] += residue(it->first-a,p);
+              root = (root < 0) ? group : merge(root,group);
+              it = fractions.erase(it);
+            }
+          };
+          if (a < b) {
+            consume(fractions.upper_bound(a),b);
+          } else {
+            consume(fractions.upper_bound(a),p);
+            consume(fractions.begin(),b);
+          }
+          if (root >= 0)
+            fractions[a] = root;
+        }
+        return true;
+      }
+    };
+
     /// Adjustment interval in a doubly linked list sorted by minimum
     struct Adjustment {
       Time min, max;
@@ -216,7 +394,9 @@ namespace Gecode { namespace Int { namespace InterDistance {
             return false;
           if (min-p+1 < minSorted[i]->min) {
             if ((forbiddenCount > 0) &&
-                (minSorted[i]->min > buffer[last+1].min)) {
+                (minSorted[i]->min >= buffer[last+1].min)) {
+              // Adjacent integer regions must also be merged: skipping one
+              // region must not land on a forbidden start in its neighbour.
               buffer[last+1].min = min-p+1;
             } else {
               assert(last >= 0);
@@ -377,66 +557,114 @@ namespace Gecode { namespace Int { namespace InterDistance {
       }
     };
 
-    /// Check the defining inequality once every view is assigned
-    bool valid_assignment(const ViewArray<IntView>& x, int p) {
+    /// Minimum separation in an assigned tuple, without quadratic tables
+    Time assigned_distance(Region& r, const ViewArray<IntView>& x) {
+      Time* values = r.alloc<Time>(x.size());
       for (int i=0; i<x.size(); i++)
-        for (int j=0; j<i; j++) {
-          Time d = static_cast<Time>(x[i].val())-x[j].val();
-          if ((-p < d) && (d < p))
-            return false;
-        }
-      return true;
+        values[i] = x[i].val();
+      std::sort(values,values+x.size());
+      Time gap = std::numeric_limits<Time>::max();
+      for (int i=1; i<x.size(); i++)
+        gap = std::min(gap,values[i]-values[i-1]);
+      return gap;
     }
   }
 
-  Bnd::Bnd(Home home, ViewArray<IntView>& x0, int p0)
-    : NaryPropagator<IntView,PC_INT_BND>(home,x0), p(p0) {}
+  template<class PView>
+  Bnd<PView>::Bnd(Home home, ViewArray<IntView>& x0, PView p0, bool a)
+    : MixNaryOnePropagator<IntView,PC_INT_BND,PView,PC_INT_BND>(home,x0,p0),
+      advanced(a) {}
 
-  Bnd::Bnd(Space& home, Bnd& b)
-    : NaryPropagator<IntView,PC_INT_BND>(home,b), p(b.p) {}
+  template<class PView>
+  Bnd<PView>::Bnd(Space& home, Bnd& b)
+    : MixNaryOnePropagator<IntView,PC_INT_BND,PView,PC_INT_BND>(home,b),
+      advanced(b.advanced) {}
 
+  template<class PView>
   Propagator*
-  Bnd::copy(Space& home) {
+  Bnd<PView>::copy(Space& home) {
     return new (home) Bnd(home,*this);
   }
 
+  template<class PView>
   PropCost
-  Bnd::cost(const Space&, const ModEventDelta&) const {
-    return PropCost::quadratic(PropCost::HI,x.size());
+  Bnd<PView>::cost(const Space&, const ModEventDelta& med) const {
+    // ME_INT_DOM is a synthetic event: subscriptions only generate bound
+    // or assignment events. It schedules the quadratic stage separately.
+    if (IntView::me(med) == ME_INT_DOM)
+      return PropCost::quadratic(PropCost::HI,x.size());
+    return PropCost::linear(PropCost::HI,x.size());
   }
 
+  template<class PView>
   size_t
-  Bnd::dispose(Space& home) {
-    (void) NaryPropagator<IntView,PC_INT_BND>::dispose(home);
+  Bnd<PView>::dispose(Space& home) {
+    (void) MixNaryOnePropagator<IntView,PC_INT_BND,PView,PC_INT_BND>::dispose(home);
     return sizeof(*this);
   }
 
+  template<class PView>
   ExecStatus
-  Bnd::post(Home home, ViewArray<IntView>& x, int p) {
+  Bnd<PView>::post(Home home, ViewArray<IntView>& x, PView p, bool advanced) {
     if (x.size() > 1)
-      (void) new (home) Bnd(home,x,p);
+      (void) new (home) Bnd(home,x,p,advanced);
     return ES_OK;
   }
 
+  template<class PView>
   ExecStatus
-  Bnd::propagate(Space& home, const ModEventDelta&) {
-    int min = x[0].min(), max = x[0].max();
+  Bnd<PView>::propagate(Space& home, const ModEventDelta& med) {
+    Region region;
     bool assigned = true;
+    int min = x[0].min(), max = x[0].max();
     for (int i=0; i<x.size(); i++) {
       min = std::min(min,x[i].min());
       max = std::max(max,x[i].max());
       assigned &= x[i].assigned();
     }
     if (assigned) {
-      // In particular, check assignments obtained by jumping across holes
-      // in the previous invocation. No filtering tables are needed here.
-      if (!valid_assignment(x,p))
-        return ES_FAILED;
+      GECODE_ME_CHECK(y.lq(home,assigned_distance(region,x)));
       return home.ES_SUBSUMED(*this);
     }
-    if (static_cast<Time>(max)-min < static_cast<Time>(x.size()-1)*p)
-      return ES_FAILED;
-    Region region;
+    if (y.max() == 0)
+      return home.ES_SUBSUMED(*this);
+    if (y.assigned() && (y.val() == 1))
+      GECODE_REWRITE(*this,Distinct::Bnd<IntView>::post(home(*this),x));
+    const int p = y.min();
+    if (IntView::me(med) != ME_INT_DOM) {
+      Time limit = (static_cast<Time>(max)-min)/(x.size()-1);
+      int upper = static_cast<int>(std::min(limit,static_cast<Time>(y.max())));
+      if (upper < p)
+        return ES_FAILED;
+      Feasibility f(region,x);
+      if (!f.check(p))
+        return ES_FAILED;
+      if ((upper > p) && !f.check(upper)) {
+        // Feasibility is monotone in p. Keep the lower endpoint feasible
+        // and the upper endpoint infeasible, without enumerating distances.
+        int lower = p;
+        while (upper-lower > 1) {
+          int middle = lower+(upper-lower)/2;
+          if (f.check(middle))
+            lower = middle;
+          else
+            upper = middle;
+        }
+        upper = lower;
+      }
+      GECODE_ME_CHECK(y.lq(home,upper));
+      if (y.max() == 0)
+        return home.ES_SUBSUMED(*this);
+      if (y.assigned() && (y.val() == 1))
+        GECODE_REWRITE(*this,Distinct::Bnd<IntView>::post(home(*this),x));
+      if (!advanced || (p == 0))
+        return ES_FIX;
+      return home.ES_FIX_PARTIAL(*this,IntView::med(ME_INT_DOM));
+    }
+    // A zero minimum gives every x bound a support; only the basic stage
+    // needs to filter the distance. A later increase wakes that stage again.
+    if (p == 0)
+      return ES_FIX;
     Filter f(region,x.size(),p);
     bool nofix = false;
     for (int direction=0; direction<2; direction++) {
@@ -452,7 +680,6 @@ namespace Gecode { namespace Int { namespace InterDistance {
       f.prune();
       for (int i=0; i<x.size(); i++) {
         Time bound = direction ? -f.tasks[i].min-p : f.tasks[i].min;
-        // Check in wide arithmetic before converting to the view's type.
         if (direction ? (bound < x[i].min()) : (bound > x[i].max()))
           return ES_FAILED;
         ModEvent me = direction ? x[i].lq(home,static_cast<int>(bound)) :
@@ -465,12 +692,11 @@ namespace Gecode { namespace Int { namespace InterDistance {
     for (int i=0; i<x.size(); i++)
       assigned &= x[i].assigned();
     if (assigned) {
-      if (!valid_assignment(x,p))
-        return ES_FAILED;
+      GECODE_ME_CHECK(y.lq(home,assigned_distance(region,x)));
       return home.ES_SUBSUMED(*this);
     }
-    // The interval algorithm reaches a fixpoint in one pair of sweeps.
-    // Actual bounds can jump across holes; only those jumps need a rerun.
+    // Holes can move actual bounds beyond the computed bounds, invalidating
+    // an interval support for x or the distance. Restart the basic stage.
     return nofix ? ES_NOFIX : ES_FIX;
   }
 
@@ -479,7 +705,7 @@ namespace Gecode { namespace Int { namespace InterDistance {
 namespace Gecode {
 
   void
-  inter_distance(Home home, const IntVarArgs& x, int p, IntPropLevel) {
+  inter_distance(Home home, const IntVarArgs& x, int p, IntPropLevel ipl) {
     using namespace Int;
     Limits::nonnegative(p,"Int::inter_distance");
     if ((p > 0) && same(x))
@@ -491,8 +717,29 @@ namespace Gecode {
     if (p == 1) {
       GECODE_ES_FAIL(Distinct::Bnd<IntView>::post(home,xv));
     } else {
-      GECODE_ES_FAIL(InterDistance::Bnd::post(home,xv,p));
+      GECODE_ES_FAIL(InterDistance::Bnd<ConstIntView>::post(
+        home,xv,ConstIntView(p),ba(ipl) != IPL_BASIC));
+    }
+  }
+
+  void
+  inter_distance(Home home, const IntVarArgs& x, IntVar p, IntPropLevel ipl) {
+    using namespace Int;
+    if ((x.size() > 1) &&
+        (same(x,p) || ((p.max() > 0) && same(x))))
+      throw ArgumentSame("Int::inter_distance");
+    GECODE_POST;
+    IntView pv(p);
+    GECODE_ME_FAIL(pv.gq(home,0));
+    if ((pv.max() == 0) || (x.size() < 2))
+      return;
+    if (pv.assigned()) {
+      inter_distance(home,x,pv.val(),ipl);
+      return;
     }
+    ViewArray<IntView> xv(home,x);
+    GECODE_ES_FAIL(InterDistance::Bnd<IntView>::post(
+      home,xv,pv,ba(ipl) != IPL_BASIC));
   }
 
 }
diff --git a/gecode/int/inter-distance.hh b/gecode/int/inter-distance.hh
index 0be0d0e1b4..6a604890a5 100644
--- a/gecode/int/inter-distance.hh
+++ b/gecode/int/inter-distance.hh
@@ -53,31 +53,39 @@ namespace Gecode { namespace Int { namespace InterDistance {
    * A Quadratic Propagator for the Inter-Distance Constraint,
    * AAAI 2006, 123--128, and Quimper's 2006 implementation.
    *
-   * Only the views and distance are kept across invocations. Quadratic
-   * scratch storage is allocated in a region and is not copied on cloning.
+   * The basic stage uses the O(n log n) feasibility algorithm of Garey,
+   * Johnson, Simons, and Tarjan, SIAM Journal on Computing 10 (1981),
+   * 256--269. With a variable distance it also finds the largest feasible
+   * distance by binary search (Quimper et al., CPL 3 (2008), 21--35).
+   * The advanced stage performs quadratic bounds filtering.
+   * Only views and the algorithm flag are copied on cloning.
    *
    * Requires \code #include <gecode/int/inter-distance.hh> \endcode
    * \ingroup FuncIntProp
    */
-  class Bnd : public NaryPropagator<IntView,PC_INT_BND> {
+  template<class PView>
+  class Bnd : public MixNaryOnePropagator<IntView,PC_INT_BND,PView,PC_INT_BND> {
   protected:
-    /// Minimum distance
-    int p;
+    using MixNaryOnePropagator<IntView,PC_INT_BND,PView,PC_INT_BND>::x;
+    using MixNaryOnePropagator<IntView,PC_INT_BND,PView,PC_INT_BND>::y;
+    /// Whether to run quadratic filtering after the basic stage
+    bool advanced;
     /// Constructor for posting
-    Bnd(Home home, ViewArray<IntView>& x, int p);
+    Bnd(Home home, ViewArray<IntView>& x, PView p, bool advanced);
     /// Constructor for cloning
     Bnd(Space& home, Bnd& b);
   public:
     /// Copy during cloning
     virtual Propagator* copy(Space& home);
-    /// Quadratic propagation cost
+    /// Cost of the current stage
     virtual PropCost cost(const Space&, const ModEventDelta&) const;
     /// Perform propagation
     virtual ExecStatus propagate(Space& home, const ModEventDelta&);
     /// Cancel subscriptions and dispose
     virtual size_t dispose(Space& home);
     /// Post propagator
-    static ExecStatus post(Home home, ViewArray<IntView>& x, int p);
+    static ExecStatus post(Home home, ViewArray<IntView>& x, PView p,
+                           bool advanced);
   };
 
 }}}
diff --git a/test/int/inter-distance.cpp b/test/int/inter-distance.cpp
index 16d7cf8113..499e9c1068 100644
--- a/test/int/inter-distance.cpp
+++ b/test/int/inter-distance.cpp
@@ -43,11 +43,13 @@ namespace Test { namespace Int { namespace InterDistance {
   class Distance : public Test {
   protected:
     int p;
+    Gecode::IntPropLevel ipl;
   public:
-    Distance(int n, int p0, int min, int max)
-      : Test("InterDistance::"+str(n)+"::"+str(p0)+"::"+str(min),
-             n,min,max), p(p0) {
-      contest = CTL_BOUNDS_Z;
+    Distance(int n, int p0, int min, int max,
+             Gecode::IntPropLevel ipl0=Gecode::IPL_DEF)
+      : Test("InterDistance::"+str(n)+"::"+str(p0)+"::"+str(min)+
+             "::"+str(ipl0),n,min,max), p(p0), ipl(ipl0) {
+      contest = Gecode::ba(ipl) == Gecode::IPL_BASIC ? CTL_NONE : CTL_BOUNDS_Z;
     }
     virtual bool solution(const Assignment& x) const {
       for (int i=0; i<x.size(); i++)
@@ -59,7 +61,34 @@ namespace Test { namespace Int { namespace InterDistance {
       return true;
     }
     virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
-      Gecode::inter_distance(home,x,p);
+      Gecode::inter_distance(home,x,p,ipl);
+    }
+  };
+
+  /// Variable distance, including propagation after distance assignments
+  class Variable : public Test {
+    Gecode::IntPropLevel ipl;
+  public:
+    Variable(int n, Gecode::IntPropLevel ipl0)
+      : Test("InterDistance::Variable::"+str(n)+"::"+str(ipl0),
+             n+1,-2,3), ipl(ipl0) {
+      contest = Gecode::ba(ipl) == Gecode::IPL_BASIC ? CTL_NONE : CTL_BOUNDS_Z;
+    }
+    virtual bool solution(const Assignment& x) const {
+      int p = x[x.size()-1];
+      if (p < 0)
+        return false;
+      for (int i=0; i<x.size()-1; i++)
+        for (int j=0; j<i; j++)
+          if (std::abs(x[i]-x[j]) < p)
+            return false;
+      return true;
+    }
+    virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
+      Gecode::IntVarArgs a(x.size()-1);
+      for (int i=0; i<a.size(); i++)
+        a[i] = x[i];
+      Gecode::inter_distance(home,a,x[x.size()-1],ipl);
     }
   };
 
@@ -68,14 +97,19 @@ namespace Test { namespace Int { namespace InterDistance {
     class Model : public Gecode::Space {
     public:
       Gecode::IntVarArray x;
-      Model(const std::vector<std::vector<int> >& domains)
-        : x(*this,static_cast<int>(domains.size())) {
+      Gecode::IntVar p;
+      Model(const std::vector<std::vector<int> >& domains,
+            const std::vector<int>& distance={0})
+        : x(*this,static_cast<int>(domains.size())),
+          p(*this,Gecode::IntSet(distance.data(),
+                                static_cast<int>(distance.size()))) {
         for (int i=0; i<x.size(); i++)
           x[i] = Gecode::IntVar(*this,Gecode::IntSet(
             domains[i].data(),static_cast<int>(domains[i].size())));
       }
       Model(Model& s) : Gecode::Space(s) {
         x.update(*this,s.x);
+        p.update(*this,s.p);
       }
       virtual Gecode::Space* copy(void) {
         return new Model(*this);
@@ -85,13 +119,22 @@ namespace Test { namespace Int { namespace InterDistance {
     static void supports(const std::vector<std::vector<int> >& dom, int p,
                          int i, std::vector<int>& tuple,
                          std::vector<int>& lo, std::vector<int>& hi,
-                         bool& found) {
+                         bool& found, long long int* gap=nullptr) {
       if (i == static_cast<int>(dom.size())) {
         found = true;
         for (int j=0; j<i; j++) {
           lo[j] = std::min(lo[j],tuple[j]);
           hi[j] = std::max(hi[j],tuple[j]);
         }
+        if (gap != nullptr) {
+          long long int d = Gecode::Int::Limits::max;
+          for (int j=0; j<i; j++)
+            for (int k=0; k<j; k++) {
+              long long int delta = static_cast<long long int>(tuple[j])-tuple[k];
+              d = std::min(d,std::abs(delta));
+            }
+          *gap = std::max(*gap,d);
+        }
         return;
       }
       for (int value : dom[i]) {
@@ -105,7 +148,7 @@ namespace Test { namespace Int { namespace InterDistance {
         }
         if (valid) {
           tuple[i] = value;
-          supports(dom,p,i+1,tuple,lo,hi,found);
+          supports(dom,p,i+1,tuple,lo,hi,found,gap);
         }
       }
     }
@@ -153,6 +196,56 @@ namespace Test { namespace Int { namespace InterDistance {
       }
       return correct;
     }
+    /// Check the largest distance and x supports against tuple enumeration
+    static bool check_variable(const std::vector<std::vector<int> >& dom,
+                               const std::vector<int>& distance, bool dense,
+                               Gecode::IntPropLevel ipl) {
+      const int n = static_cast<int>(dom.size());
+      std::vector<int> tuple(n), lo(n,Gecode::Int::Limits::max),
+        hi(n,Gecode::Int::Limits::min);
+      bool found = false;
+      long long int gap = -1;
+      supports(dom,distance.front(),0,tuple,lo,hi,found,&gap);
+      Model m(dom,distance);
+      Gecode::inter_distance(m,m.x,m.p,ipl);
+      bool failed = m.status() == Gecode::SS_FAILED;
+      bool correct = found ? !failed : (!dense || failed);
+      if (found && !failed) {
+        for (int i=0; i<n; i++)
+          correct &= dense && (Gecode::ba(ipl) != Gecode::IPL_BASIC) ?
+            ((m.x[i].min() == lo[i]) && (m.x[i].max() == hi[i])) :
+            ((m.x[i].min() <= lo[i]) && (m.x[i].max() >= hi[i]));
+        if (dense) {
+          auto largest = std::upper_bound(distance.begin(),distance.end(),gap);
+          correct &= (m.p.max() == *--largest);
+        }
+      }
+      if (!dense && !failed) {
+        // Bounds(Z) supports can use holes in the other x domains.
+        std::vector<std::vector<int> > hull(n);
+        for (int i=0; i<n; i++)
+          for (int v=m.x[i].min(); v<=m.x[i].max(); v++)
+            hull[i].push_back(v);
+        std::fill(lo.begin(),lo.end(),Gecode::Int::Limits::max);
+        std::fill(hi.begin(),hi.end(),Gecode::Int::Limits::min);
+        found = false;
+        gap = -1;
+        supports(hull,m.p.min(),0,tuple,lo,hi,found,&gap);
+        correct &= found;
+        if (found) {
+          auto largest = std::upper_bound(distance.begin(),distance.end(),gap);
+          correct &= (m.p.max() == *--largest);
+          if (Gecode::ba(ipl) != Gecode::IPL_BASIC)
+            for (int i=0; i<n; i++)
+              correct &= (m.x[i].min() == lo[i]) && (m.x[i].max() == hi[i]);
+        }
+      }
+      if (!correct)
+        olog << "Variable distance " << distance.front() << ".."
+             << distance.back() << ", propagated " << m.x << ", " << m.p
+             << std::endl;
+      return correct;
+    }
   public:
     Bounds(void) : Base("Int::InterDistance::BoundsOracle") {}
     virtual bool run(void) {
@@ -204,7 +297,73 @@ namespace Test { namespace Int { namespace InterDistance {
       }
       // A maximal distance exercises deadlines beyond Int::Limits::max.
       const int limit = Gecode::Int::Limits::max;
-      return check({{-limit,-limit+1},{0,1},{limit-1,limit}},limit,true);
+      if (!check({{-limit,-limit+1},{0,1},{limit-1,limit}},limit,true))
+        return false;
+      // Adjacent forbidden regions used to let the feasibility pass miss
+      // this overload. The maximum feasible separation is six, not seven.
+      std::vector<std::vector<int> > adjacent(3);
+      for (int v=1; v<=17; v++) adjacent[0].push_back(v);
+      for (int v=5; v<=8; v++) adjacent[1].push_back(v);
+      for (int v=2; v<=14; v++) adjacent[2].push_back(v);
+      if (!check(adjacent,7,true))
+        return false;
+      for (Gecode::IntPropLevel ipl : {Gecode::IPL_BASIC,Gecode::IPL_ADVANCED,
+                                      Gecode::IPL_BASIC_ADVANCED})
+        if (!check_variable(adjacent,{0,1,2,3,4,5,6,7,8},true,ipl))
+          return false;
+      for (int test=0; test<512; test++) {
+        int n = 2+random(4);
+        int offset = test%3 == 0 ? Gecode::Int::Limits::min+30 :
+          test%3 == 1 ? Gecode::Int::Limits::max-30 : 0;
+        bool dense = test%2 == 0;
+        std::vector<std::vector<int> > dom(n);
+        for (int i=0; i<n; i++) {
+          int l = offset+static_cast<int>(random(21))-10;
+          int width = random(5);
+          for (int j=0; j<=width; j++)
+            if (dense || (j == 0) || (j == width) || random(2))
+              dom[i].push_back(l+j);
+        }
+        std::vector<int> distance;
+        int lower = random(4);
+        for (int p=lower; p<=12; p++)
+          if (dense || (p == lower) || (p == 12) || random(2))
+            distance.push_back(p);
+        Gecode::IntPropLevel ipl = test%3 == 0 ? Gecode::IPL_BASIC :
+          test%3 == 1 ? Gecode::IPL_ADVANCED : Gecode::IPL_DEF;
+        if (!check_variable(dom,distance,dense,ipl))
+          return false;
+      }
+      // Raise the minimum distance in a clone after an initial fixpoint.
+      // Both p's subscription and staging must survive cloning.
+      std::vector<std::vector<int> > paper = {{2,3,4,5,6},
+        {10,11,12,13,14},{4,5,6,7,8,9,10,11,12,13,14,15}};
+      Model m(paper,{0,1,2,3,4,5,6,7,8});
+      Gecode::inter_distance(m,m.x,m.p);
+      if ((m.status() == Gecode::SS_FAILED) || (m.p.max() != 6))
+        return false;
+      Model* clone = static_cast<Model*>(m.clone());
+      Gecode::rel(*clone,clone->p,Gecode::IRT_GQ,6);
+      bool correct = clone->status() != Gecode::SS_FAILED;
+      correct &= clone->p.assigned() && (clone->p.val() == 6);
+      correct &= clone->x.assigned() && (clone->x[0].val() == 2) &&
+        (clone->x[1].val() == 14) && (clone->x[2].val() == 8);
+      correct &= (m.p.min() == 0) && !m.x.assigned();
+      delete clone;
+      if (!correct)
+        return false;
+      Model basic(paper,{6,7,8});
+      Gecode::inter_distance(basic,basic.x,basic.p,Gecode::IPL_BASIC);
+      if ((basic.status() == Gecode::SS_FAILED) || !basic.p.assigned() ||
+          (basic.p.val() != 6) ||
+          (basic.x[0].min() != 2) || (basic.x[0].max() != 6))
+        return false;
+      // Assigning p to one must immediately rewrite to distinct, so a
+      // newly posted constraint cannot prune further at the same fixpoint.
+      Model unit({{-2},{-2,-1}},{1,3});
+      Gecode::inter_distance(unit,unit.x,unit.p,Gecode::IPL_BASIC);
+      return (unit.status() != Gecode::SS_FAILED) && unit.p.assigned() &&
+        (unit.p.val() == 1) && unit.x[1].assigned() && (unit.x[1].val() == -1);
     }
   };
 
@@ -253,7 +412,55 @@ namespace Test { namespace Int { namespace InterDistance {
       IntVar assigned(t,3,3);
       duplicate[0] = duplicate[1] = assigned;
       inter_distance(t,duplicate,2);
-      return t.status() == SS_FAILED;
+      if (t.status() != SS_FAILED)
+        return false;
+      Model empty;
+      IntVar distance(empty,-3,9);
+      inter_distance(empty,IntVarArgs(),distance);
+      if ((empty.status() == SS_FAILED) || (distance.min() != 0))
+        return false;
+      Model negativeDistance;
+      IntVar negativeVar(negativeDistance,-3,-1);
+      inter_distance(negativeDistance,IntVarArgs(),negativeVar);
+      if (negativeDistance.status() != SS_FAILED)
+        return false;
+      Model shared;
+      IntVar a(shared,0,9), b(shared,0,9), p(shared,0,9);
+      IntVarArgs pair(2);
+      pair[0] = a;
+      pair[1] = b;
+      bool alias = false, repeated = false;
+      try {
+        inter_distance(shared,pair,a);
+      } catch (const Gecode::Int::ArgumentSame&) {
+        alias = true;
+      }
+      pair[1] = a;
+      try {
+        inter_distance(shared,pair,p);
+      } catch (const Gecode::Int::ArgumentSame&) {
+        repeated = true;
+      }
+      if (!alias || !repeated)
+        return false;
+      // A wide search interval exercises binary search and integer limits.
+      Model wide;
+      const int limit = Gecode::Int::Limits::max;
+      IntVarArgs x(3);
+      x[0] = IntVar(wide,0,limit/4);
+      x[1] = IntVar(wide,0,limit/4);
+      x[2] = IntVar(wide,limit-1,limit);
+      IntVar separation(wide,0,limit);
+      inter_distance(wide,x,separation,IPL_BASIC);
+      if ((wide.status() == SS_FAILED) || (separation.max() != limit/4))
+        return false;
+      // The assigned gap can exceed the representable distance domain.
+      Model extremes;
+      pair[0] = IntVar(extremes,-limit,-limit);
+      pair[1] = IntVar(extremes,limit,limit);
+      IntVar large(extremes,0,limit);
+      inter_distance(extremes,pair,large);
+      return (extremes.status() != SS_FAILED) && (large.max() == limit);
     }
   };
 
@@ -267,6 +474,18 @@ namespace Test { namespace Int { namespace InterDistance {
                              Gecode::Int::Limits::min+5);
       (void) new Distance(3,2,Gecode::Int::Limits::max-5,
                              Gecode::Int::Limits::max);
+      for (Gecode::IntPropLevel ipl : {Gecode::IPL_DEF,Gecode::IPL_BASIC,
+                                      Gecode::IPL_ADVANCED}) {
+        (void) new Variable(2,ipl);
+        (void) new Variable(3,ipl);
+      }
+      (void) new Variable(0,Gecode::IPL_DEF);
+      (void) new Variable(1,Gecode::IPL_DEF);
+      for (Gecode::IntPropLevel ipl : {Gecode::IPL_BASIC,Gecode::IPL_ADVANCED,
+                                      Gecode::IPL_BASIC_ADVANCED})
+        (void) new Distance(3,2,-3,3,ipl);
+      (void) new Distance(3,2,-3,3,static_cast<Gecode::IntPropLevel>(
+        Gecode::IPL_BND | Gecode::IPL_BASIC));
     }
   } create;
   Bounds bounds;

From 35cbd579c6a3b816d89c4b1b97752cae1e4e5af7 Mon Sep 17 00:00:00 2001
From: Mikael Zayenz Lagerkvist <lagerkvist@gecode.dev>
Date: Sat, 3 Oct 2026 13:53:27 +0200
Subject: [PATCH 03/13] Document inter-distance algorithm sources and
 invariants

---
 changelog.in                  | 13 +++++++++----
 gecode/int.hh                 | 24 ++++++++++++++++++++----
 gecode/int/inter-distance.cpp | 11 ++++++++---
 gecode/int/inter-distance.hh  | 21 ++++++++++++++-------
 4 files changed, 51 insertions(+), 18 deletions(-)

diff --git a/changelog.in b/changelog.in
index 4b23946977..cf3edad7e9 100755
--- a/changelog.in
+++ b/changelog.in
@@ -169,10 +169,15 @@ Rank:   major
 Thanks: Claude-Guy Quimper
 [DESCRIPTION]
 Add the inter-distance constraint for fixed and variable separation, adopting
-Claude-Guy Quimper's 2006 submission and the algorithm of Quimper,
-Lopez-Ortiz, and Pesant (AAAI 2006, CPL 2008). A staged propagator combines
-the logarithmic-time-per-task feasibility check of Garey et al. (1981) with
-quadratic bounds filtering, selected through IPL_BASIC and IPL_ADVANCED.
+Claude-Guy Quimper's 2006 submission. Basic propagation checks feasibility
+and bounds the distance; advanced propagation adds staged quadratic bounds
+filtering. The algorithms are described in:
+C.-G. Quimper, A. Lopez-Ortiz, G. Pesant, A Quadratic Propagator for the
+Inter-Distance Constraint, AAAI 2006, and Constraint Programming Letters 3
+(2008), 21-35.
+M. R. Garey, D. S. Johnson, B. B. Simons, R. E. Tarjan, Scheduling Unit-Time
+Tasks with Arbitrary Release Times and Deadlines, SIAM Journal on Computing
+10(2) (1981), 256-269.
 
 [RELEASE]
 Version: 6.4.0
diff --git a/gecode/int.hh b/gecode/int.hh
index e5893ede4d..04bfb99d70 100755
--- a/gecode/int.hh
+++ b/gecode/int.hh
@@ -1755,9 +1755,7 @@ namespace Gecode {
   //@{
   /** \brief Post bounds-consistent propagator for \f$|x_i-x_j|\geq p\f$ for all \f$0\leq i\neq j<|x|\f$
    *
-   * Uses the algorithms of Garey et al. (1981) and Quimper, Lopez-Ortiz,
-   * and Pesant (AAAI 2006). Domains with holes are treated as intervals
-   * between their bounds.
+   * Domains with holes are treated as intervals between their bounds.
    *
    * - \a IPL_BASIC checks interval feasibility in \f$O(n\log n)\f$ time
    *   and linear temporary space, where \f$n=|x|\f$.
@@ -1771,6 +1769,18 @@ namespace Gecode {
    * A zero distance, or fewer than two variables, imposes no restriction.
    * A distance of one is propagated as a bounds-consistent distinct constraint.
    *
+   * The propagator uses algorithms taken from:
+   *
+   * Claude-Guy Quimper, Alejandro Lopez-Ortiz, and Gilles Pesant,
+   * A Quadratic Propagator for the Inter-Distance Constraint,
+   * AAAI, pages 123-128, 2006.
+   *
+   * and
+   *
+   * M. R. Garey, D. S. Johnson, B. B. Simons, and R. E. Tarjan,
+   * Scheduling Unit-Time Tasks with Arbitrary Release Times and Deadlines,
+   * SIAM Journal on Computing 10(2), pages 256-269, 1981.
+   *
    * Throws Int::OutOfLimits if \a p is negative or exceeds Int::Limits::max.
    * Throws Int::ArgumentSame if \a p is positive and \a x contains the same
    * unassigned variable multiply.
@@ -1788,7 +1798,13 @@ namespace Gecode {
    * search using the linear-space feasibility checker. Its time bound
    * is \f$O(n\log n\log(1+\max(p)))\f$. The advanced stage provides
    * bounds(Z) consistency for \a x using the minimum of \a p, giving
-   * bounds(Z) consistency for the whole constraint (CPL 3, 2008).
+   * bounds(Z) consistency for the whole constraint.
+   *
+   * The variable-distance algorithm is taken from:
+   *
+   * Claude-Guy Quimper, Alejandro Lopez-Ortiz, and Gilles Pesant,
+   * A Quadratic Propagator for the Inter-Distance Constraint,
+   * Constraint Programming Letters 3, pages 21-35, 2008, Section 5.
    *
    * Fewer than two variables only constrain \a p to be nonnegative.
    * With at least two variables, throws Int::ArgumentSame if \a p is the
diff --git a/gecode/int/inter-distance.cpp b/gecode/int/inter-distance.cpp
index 9d866a554e..01d56683aa 100644
--- a/gecode/int/inter-distance.cpp
+++ b/gecode/int/inter-distance.cpp
@@ -48,7 +48,7 @@ namespace Gecode { namespace Int { namespace InterDistance {
     typedef long long int Time;
     typedef std::ptrdiff_t RegionIndex;
 
-    /// Release time, deadline, and position in release-time order
+    /// Task bounds and ranks in their sorted orders
     struct Task {
       Time min, max;
       int minRank, maxRank;
@@ -75,6 +75,7 @@ namespace Gecode { namespace Int { namespace InterDistance {
       int dc;
       Task* tasks;
       Task** release;
+      /// Distinct latest start times; critical() adds p to obtain deadlines
       Time* deadlines;
       int* loads;
       int* successor;
@@ -190,6 +191,7 @@ namespace Gecode { namespace Int { namespace InterDistance {
             if (active == obsolete)
               active = d;
           }
+          // Construct regions after processing all tasks at this release time.
           if ((i > 0) && (release[i-1]->min == release[i]->min))
             continue;
           c = critical(active,p);
@@ -250,6 +252,8 @@ namespace Gecode { namespace Int { namespace InterDistance {
      * vector allow the dominance sweep to generate only quadratically many
      * adjustment intervals. The linked list and union-find propagate changes
      * to bounds without rescanning all variables for each interval.
+     * This implements Algorithm 2 and the adjustment data structure in
+     * Sections 4.1 and 4.2 of Quimper et al. (2008).
      */
     class Filter {
     public:
@@ -640,8 +644,9 @@ namespace Gecode { namespace Int { namespace InterDistance {
       if (!f.check(p))
         return ES_FAILED;
       if ((upper > p) && !f.check(upper)) {
-        // Feasibility is monotone in p. Keep the lower endpoint feasible
-        // and the upper endpoint infeasible, without enumerating distances.
+        // Quimper et al. (2008), Section 5: feasibility is monotone in p.
+        // Keep the lower endpoint feasible and the upper endpoint infeasible,
+        // without enumerating distances.
         int lower = p;
         while (upper-lower > 1) {
           int middle = lower+(upper-lower)/2;
diff --git a/gecode/int/inter-distance.hh b/gecode/int/inter-distance.hh
index 6a604890a5..cec2da592d 100644
--- a/gecode/int/inter-distance.hh
+++ b/gecode/int/inter-distance.hh
@@ -42,6 +42,16 @@
 
 /**
  * \namespace Gecode::Int::InterDistance
+ *
+ * The feasibility and bounds-filtering algorithms follow:
+ *   M. R. Garey, D. S. Johnson, B. B. Simons, and R. E. Tarjan,
+ *   Scheduling Unit-Time Tasks with Arbitrary Release Times and Deadlines,
+ *   SIAM Journal on Computing 10(2), pages 256-269, 1981.
+ *   Claude-Guy Quimper, Alejandro Lopez-Ortiz, and Gilles Pesant,
+ *   A Quadratic Propagator for the Inter-Distance Constraint,
+ *   AAAI, pages 123-128, 2006, and Constraint Programming Letters 3,
+ *   pages 21-35, 2008.
+ *
  * \brief Inter-distance propagator
  */
 namespace Gecode { namespace Int { namespace InterDistance {
@@ -49,14 +59,11 @@ namespace Gecode { namespace Int { namespace InterDistance {
   /**
    * \brief Bounds-consistent inter-distance propagator
    *
-   * Based on Claude-Guy Quimper, Alejandro Lopez-Ortiz, and Gilles Pesant,
-   * A Quadratic Propagator for the Inter-Distance Constraint,
-   * AAAI 2006, 123--128, and Quimper's 2006 implementation.
+   * Adopts Claude-Guy Quimper's 2006 implementation.
    *
-   * The basic stage uses the O(n log n) feasibility algorithm of Garey,
-   * Johnson, Simons, and Tarjan, SIAM Journal on Computing 10 (1981),
-   * 256--269. With a variable distance it also finds the largest feasible
-   * distance by binary search (Quimper et al., CPL 3 (2008), 21--35).
+   * The basic stage uses Garey et al.'s O(n log n) feasibility algorithm.
+   * With a variable distance it also finds the largest feasible distance
+   * by binary search (Quimper et al., 2008, Section 5).
    * The advanced stage performs quadratic bounds filtering.
    * Only views and the algorithm flag are copied on cloning.
    *

From f54691531af05b41a01ef928854063796dd5e6d2 Mon Sep 17 00:00:00 2001
From: Mikael Zayenz Lagerkvist <lagerkvist@gecode.dev>
Date: Sat, 3 Oct 2026 14:02:22 +0200
Subject: [PATCH 04/13] Credit inter-distance coauthors and cite only the
 papers

---
 changelog.in                  | 8 +++-----
 gecode/int/inter-distance.cpp | 8 +++-----
 gecode/int/inter-distance.hh  | 6 +-----
 3 files changed, 7 insertions(+), 15 deletions(-)

diff --git a/changelog.in b/changelog.in
index cf3edad7e9..394b936a5d 100755
--- a/changelog.in
+++ b/changelog.in
@@ -166,12 +166,10 @@ over Selected Points, ModRef 2026.
 Module: int
 What:   new
 Rank:   major
-Thanks: Claude-Guy Quimper
 [DESCRIPTION]
-Add the inter-distance constraint for fixed and variable separation, adopting
-Claude-Guy Quimper's 2006 submission. Basic propagation checks feasibility
-and bounds the distance; advanced propagation adds staged quadratic bounds
-filtering. The algorithms are described in:
+Add the inter-distance constraint for fixed and variable separation. Basic
+propagation checks feasibility and bounds the distance; advanced propagation
+adds staged quadratic bounds filtering. The algorithms are described in:
 C.-G. Quimper, A. Lopez-Ortiz, G. Pesant, A Quadratic Propagator for the
 Inter-Distance Constraint, AAAI 2006, and Constraint Programming Letters 3
 (2008), 21-35.
diff --git a/gecode/int/inter-distance.cpp b/gecode/int/inter-distance.cpp
index 01d56683aa..002cee0eea 100644
--- a/gecode/int/inter-distance.cpp
+++ b/gecode/int/inter-distance.cpp
@@ -1,9 +1,7 @@
 /* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
 /*
  *  Main authors:
- *     Claude-Guy Quimper
- *
- *  Contributing authors:
+ *     Claude-Guy Quimper <claude-guy.quimper@ift.ulaval.ca>
  *     Mikael Zayenz Lagerkvist <lagerkvist@gecode.dev>
  *
  *  Copyright:
@@ -371,8 +369,8 @@ namespace Gecode { namespace Int { namespace InterDistance {
         Time* times = r.alloc<Time>(dc);
         int* cursor = r.alloc<int>(dc);
         Forbidden* buffer = r.alloc<Forbidden>(n);
-        // Indices avoid both the one-past-end write and the before-begin
-        // pointer formed by the original 2006 implementation.
+        // Indices keep cursor movement within the allocated forbidden-region
+        // buffer, including its empty-prefix boundary.
         int last = n-1;
         for (int i=0; i<dc; i++) {
           times[i] = deadlines[i];
diff --git a/gecode/int/inter-distance.hh b/gecode/int/inter-distance.hh
index cec2da592d..b8dc2a6f54 100644
--- a/gecode/int/inter-distance.hh
+++ b/gecode/int/inter-distance.hh
@@ -1,9 +1,7 @@
 /* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
 /*
  *  Main authors:
- *     Claude-Guy Quimper
- *
- *  Contributing authors:
+ *     Claude-Guy Quimper <claude-guy.quimper@ift.ulaval.ca>
  *     Mikael Zayenz Lagerkvist <lagerkvist@gecode.dev>
  *
  *  Copyright:
@@ -59,8 +57,6 @@ namespace Gecode { namespace Int { namespace InterDistance {
   /**
    * \brief Bounds-consistent inter-distance propagator
    *
-   * Adopts Claude-Guy Quimper's 2006 implementation.
-   *
    * The basic stage uses Garey et al.'s O(n log n) feasibility algorithm.
    * With a variable distance it also finds the largest feasible distance
    * by binary search (Quimper et al., 2008, Section 5).

From 58cc72d40b14a5e8ae86c0d70ae195c4f03a659c Mon Sep 17 00:00:00 2001
From: Mikael Zayenz Lagerkvist <lagerkvist@gecode.dev>
Date: Sat, 3 Oct 2026 14:27:31 +0200
Subject: [PATCH 05/13] Export inter-distance propagators and split struct
 declarations

---
 gecode/int/inter-distance.cpp | 19 ++++++++++++++-----
 gecode/int/inter-distance.hh  |  2 ++
 2 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/gecode/int/inter-distance.cpp b/gecode/int/inter-distance.cpp
index 002cee0eea..c91de801b1 100644
--- a/gecode/int/inter-distance.cpp
+++ b/gecode/int/inter-distance.cpp
@@ -48,13 +48,16 @@ namespace Gecode { namespace Int { namespace InterDistance {
 
     /// Task bounds and ranks in their sorted orders
     struct Task {
-      Time min, max;
-      int minRank, maxRank;
+      Time min;
+      Time max;
+      int minRank;
+      int maxRank;
     };
 
     /// Forbidden starting times (inclusive)
     struct Forbidden {
-      Time min, max;
+      Time min;
+      Time max;
     };
 
     /**
@@ -238,8 +241,10 @@ namespace Gecode { namespace Int { namespace InterDistance {
 
     /// Adjustment interval in a doubly linked list sorted by minimum
     struct Adjustment {
-      Time min, max;
-      RegionIndex previous, next;
+      Time min;
+      Time max;
+      RegionIndex previous;
+      RegionIndex next;
     };
 
     /**
@@ -703,6 +708,10 @@ namespace Gecode { namespace Int { namespace InterDistance {
     return nofix ? ES_NOFIX : ES_FIX;
   }
 
+  // Export the compiled view specializations for propagator reuse.
+  template class GECODE_INT_EXPORT Bnd<IntView>;
+  template class GECODE_INT_EXPORT Bnd<ConstIntView>;
+
 }}}
 
 namespace Gecode {
diff --git a/gecode/int/inter-distance.hh b/gecode/int/inter-distance.hh
index b8dc2a6f54..ee222f332d 100644
--- a/gecode/int/inter-distance.hh
+++ b/gecode/int/inter-distance.hh
@@ -62,6 +62,7 @@ namespace Gecode { namespace Int { namespace InterDistance {
    * by binary search (Quimper et al., 2008, Section 5).
    * The advanced stage performs quadratic bounds filtering.
    * Only views and the algorithm flag are copied on cloning.
+   * The compiled distance views are IntView and ConstIntView.
    *
    * Requires \code #include <gecode/int/inter-distance.hh> \endcode
    * \ingroup FuncIntProp
@@ -87,6 +88,7 @@ namespace Gecode { namespace Int { namespace InterDistance {
     /// Cancel subscriptions and dispose
     virtual size_t dispose(Space& home);
     /// Post propagator
+    GECODE_INT_EXPORT
     static ExecStatus post(Home home, ViewArray<IntView>& x, PView p,
                            bool advanced);
   };

From e9eae58bf163e83a146c1aba7e9693c2dd9410cc Mon Sep 17 00:00:00 2001
From: Mikael Zayenz Lagerkvist <lagerkvist@gecode.dev>
Date: Sun, 4 Oct 2026 10:56:28 +0200
Subject: [PATCH 06/13] Fix inter-distance allocation and DLL exports on
 Windows

---
 gecode/int/inter-distance.cpp | 8 +++++---
 gecode/int/inter-distance.hh  | 4 ++--
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/gecode/int/inter-distance.cpp b/gecode/int/inter-distance.cpp
index c91de801b1..bf4a6720e4 100644
--- a/gecode/int/inter-distance.cpp
+++ b/gecode/int/inter-distance.cpp
@@ -156,7 +156,9 @@ namespace Gecode { namespace Int { namespace InterDistance {
             deadlines[dc++] = finish[i]->max;
           finish[i]->maxRank = dc-1;
         }
-        const size_t count = static_cast<size_t>(dc)+1;
+        // Include the successor sentinel without overflowing signed int.
+        // Region::alloc has an unsigned-int overload on every platform.
+        const unsigned int count = static_cast<unsigned int>(dc)+1;
         loads = r.alloc<int>(count);
         successor = r.alloc<int>(count);
         previous = r.alloc<int>(dc);
@@ -709,8 +711,8 @@ namespace Gecode { namespace Int { namespace InterDistance {
   }
 
   // Export the compiled view specializations for propagator reuse.
-  template class GECODE_INT_EXPORT Bnd<IntView>;
-  template class GECODE_INT_EXPORT Bnd<ConstIntView>;
+  template class Bnd<IntView>;
+  template class Bnd<ConstIntView>;
 
 }}}
 
diff --git a/gecode/int/inter-distance.hh b/gecode/int/inter-distance.hh
index ee222f332d..760ddd7cfd 100644
--- a/gecode/int/inter-distance.hh
+++ b/gecode/int/inter-distance.hh
@@ -68,7 +68,8 @@ namespace Gecode { namespace Int { namespace InterDistance {
    * \ingroup FuncIntProp
    */
   template<class PView>
-  class Bnd : public MixNaryOnePropagator<IntView,PC_INT_BND,PView,PC_INT_BND> {
+  class GECODE_INT_EXPORT Bnd
+    : public MixNaryOnePropagator<IntView,PC_INT_BND,PView,PC_INT_BND> {
   protected:
     using MixNaryOnePropagator<IntView,PC_INT_BND,PView,PC_INT_BND>::x;
     using MixNaryOnePropagator<IntView,PC_INT_BND,PView,PC_INT_BND>::y;
@@ -88,7 +89,6 @@ namespace Gecode { namespace Int { namespace InterDistance {
     /// Cancel subscriptions and dispose
     virtual size_t dispose(Space& home);
     /// Post propagator
-    GECODE_INT_EXPORT
     static ExecStatus post(Home home, ViewArray<IntView>& x, PView p,
                            bool advanced);
   };

From 6d6d5f88103ca59c1f87ae89bab5c1c8a027baa0 Mon Sep 17 00:00:00 2001
From: Mikael Zayenz Lagerkvist <lagerkvist@gecode.dev>
Date: Sun, 4 Oct 2026 11:38:29 +0200
Subject: [PATCH 07/13] Use region-backed residues and clarify inter-distance
 sweeps

---
 gecode/int/inter-distance.cpp | 440 ++++++++++++++++++++++++----------
 test/int/inter-distance.cpp   | 420 ++++++++++++++++++++------------
 2 files changed, 582 insertions(+), 278 deletions(-)

diff --git a/gecode/int/inter-distance.cpp b/gecode/int/inter-distance.cpp
index bf4a6720e4..69fcd7e4d7 100644
--- a/gecode/int/inter-distance.cpp
+++ b/gecode/int/inter-distance.cpp
@@ -38,7 +38,6 @@
 
 #include <algorithm>
 #include <limits>
-#include <map>
 
 namespace Gecode { namespace Int { namespace InterDistance {
 
@@ -60,13 +59,117 @@ namespace Gecode { namespace Int { namespace InterDistance {
       Time max;
     };
 
+    /// Nonnegative remainder, including for negative deadlines
+    Time residue(Time t, Time p) {
+      Time q = t % p;
+      return (q < 0) ? q+p : q;
+    }
+
+    /**
+     * \brief Ordered residue groups with region-backed storage
+     *
+     * Group keys are drawn from the original deadline residues. A shift
+     * merges groups into an existing key, but later deadline activation can
+     * reinsert a removed key. A Fenwick tree of active-key counts supports
+     * insertion, removal, and successor queries in O(log n) time.
+     */
+    class ResidueGroups {
+      Time* keys;
+      int* groups;
+      int* counts;
+      int keyCount;
+      int activeCount;
+      int topBit;
+
+      /// Change the active-key count at rank i
+      void update(int i, int delta) {
+        for (unsigned int j=static_cast<unsigned int>(i)+1;
+             j<=static_cast<unsigned int>(keyCount); j+=j & -j)
+          counts[j] += delta;
+        activeCount += delta;
+      }
+
+      /// First active key at or after rank i, or keyCount
+      int next_active(int i) const {
+        int before = 0;
+        for (unsigned int j=static_cast<unsigned int>(i); j; j-=j & -j)
+          before += counts[j];
+        if (before == activeCount)
+          return keyCount;
+
+        int ordinal = before+1;
+        int rank = 0;
+        for (int bit=topBit; bit; bit/=2)
+          if ((bit <= keyCount-rank) && (counts[rank+bit] < ordinal)) {
+            rank += bit;
+            ordinal -= counts[rank];
+          }
+        return rank;
+      }
+    public:
+      /// Allocate once; repeated distance checks reuse these arrays
+      ResidueGroups(Region& r, int n)
+        : keys(r.alloc<Time>(n)), groups(r.alloc<int>(n)),
+          counts(r.alloc<int>(static_cast<unsigned int>(n)+1)),
+          keyCount(0), activeCount(0), topBit(0) {}
+
+      /// Prepare the key universe for distance p
+      void reset(const Time* deadlines, int n, int p) {
+        for (int i=0; i<n; i++)
+          keys[i] = residue(deadlines[i],p);
+        std::sort(keys,keys+n);
+        keyCount = static_cast<int>(std::unique(keys,keys+n)-keys);
+        std::fill(groups,groups+keyCount,-1);
+        std::fill(counts,counts+keyCount+1,0);
+        activeCount = 0;
+        topBit = 1;
+        while (topBit <= keyCount/2)
+          topBit *= 2;
+      }
+
+      /// Rank of a key in the fixed universe
+      int rank(Time key) const {
+        int i = static_cast<int>(std::lower_bound(keys,keys+keyCount,key)-keys);
+        assert((i < keyCount) && (keys[i] == key));
+        return i;
+      }
+
+      /// Key and group at rank i; -1 denotes an inactive group
+      Time key(int i) const { return keys[i]; }
+      int group(int i) const { return groups[i]; }
+
+      /// Insert a key or replace its group representative
+      void set_group(int i, int root) {
+        if (groups[i] < 0)
+          update(i,1);
+        groups[i] = root;
+      }
+
+      /// Remove an active key
+      void remove(int i) {
+        assert(groups[i] >= 0);
+        groups[i] = -1;
+        update(i,-1);
+      }
+
+      /// First active key, or the end rank
+      int first_active(void) const { return next_active(0); }
+      /// First active key greater than key, or the end rank
+      int active_after(Time key) const {
+        return next_active(static_cast<int>(
+          std::upper_bound(keys,keys+keyCount,key)-keys));
+      }
+      /// Whether a successor query returned the end rank
+      bool at_end(int i) const { return i == keyCount; }
+    };
+
     /**
      * \brief Linear-space feasibility checker of Garey et al. (1981)
      *
      * Algorithm B represents each deadline's critical time as its deadline
      * minus its task load and pseudo-offset. A Fenwick tree maintains loads.
      * A weighted union-find merges deadlines with the same residue modulo p;
-     * an ordered map locates residues affected by a forbidden region. Each
+     * ordered region-backed arrays locate affected residues. Each
      * deadline is inserted once and each merge removes a residue, giving
      * O(n log n) time. Relevant deadlines are kept in deadline order, with
      * dominated predecessors removed permanently (Lemmas 5 and 6).
@@ -84,6 +187,7 @@ namespace Gecode { namespace Int { namespace InterDistance {
       int* parent;
       int* size;
       Time* offset;
+      ResidueGroups residues;
       /// First remaining relevant deadline at or after i
       int find(int i) {
         int root = i;
@@ -123,18 +227,39 @@ namespace Gecode { namespace Int { namespace InterDistance {
         size[a] += size[b];
         return a;
       }
-      /// Nonnegative remainder, including for negative deadlines
-      static Time residue(Time t, Time p) {
-        Time q = t % p;
-        return (q < 0) ? q+p : q;
-      }
       /// Pseudo-critical time for deadline i
       Time critical(int i, Time p) const {
         return deadlines[i]+p-static_cast<Time>(load(i))*p-displacement(i);
       }
+
+      /// Move groups in the open residue arc (a,b) into the group at a
+      void forbid(Time a, Time b, int p) {
+        int target = residues.rank(a);
+        int root = residues.group(target);
+        // The active deadline's group has residue critical(active,p) % p,
+        // so activation has already supplied the target key.
+        assert(root >= 0);
+
+        auto consume = [&](int i, Time end) {
+          while (!residues.at_end(i) && (residues.key(i) < end)) {
+            Time key = residues.key(i);
+            int group = residues.group(i);
+            offset[group] += residue(key-a,p);
+            root = merge(root,group);
+            residues.remove(i);
+            i = residues.active_after(key);
+          }
+        };
+
+        // At a wraparound, zero is included precisely when it is below b.
+        consume(residues.active_after(a),(a < b) ? b : p);
+        if (a >= b)
+          consume(residues.first_active(),b);
+        residues.set_group(target,root);
+      }
     public:
       Feasibility(Region& r, const ViewArray<IntView>& x)
-        : n(x.size()), dc(0) {
+        : n(x.size()), dc(0), residues(r,x.size()) {
         tasks = r.alloc<Task>(n);
         release = r.alloc<Task*>(n);
         Task** finish = r.alloc<Task*>(n);
@@ -170,6 +295,7 @@ namespace Gecode { namespace Int { namespace InterDistance {
       bool check(int p) {
         if (p == 0)
           return true;
+
         std::fill(loads,loads+dc+1,0);
         for (int i=0; i<dc; i++) {
           successor[i] = i;
@@ -177,8 +303,10 @@ namespace Gecode { namespace Int { namespace InterDistance {
           parent[i] = -1;
         }
         successor[dc] = dc;
-        std::map<Time,int> fractions;
-        int active = dc, pending = dc-1;
+        residues.reset(deadlines,dc,p);
+
+        int active = dc;
+        int pending = dc-1;
         for (int i=n; i--;) {
           int rank = release[i]->maxRank;
           for (size_t j=static_cast<size_t>(rank)+1;
@@ -194,6 +322,7 @@ namespace Gecode { namespace Int { namespace InterDistance {
             if (active == obsolete)
               active = d;
           }
+
           // Construct regions after processing all tasks at this release time.
           if ((i > 0) && (release[i-1]->min == release[i]->min))
             continue;
@@ -203,39 +332,19 @@ namespace Gecode { namespace Int { namespace InterDistance {
             return false;
           if (c-p+1 >= r)
             continue;
+
           // Only deadlines whose back-schedule can reach this region
           // are activated. Earlier deadlines must retain zero offsets.
           while ((pending >= 0) && (deadlines[pending]+p >= c)) {
             parent[pending] = pending;
             size[pending] = 1;
             offset[pending] = 0;
-            Time q = residue(deadlines[pending]+p,p);
-            auto entry = fractions.emplace(q,pending);
-            if (!entry.second)
-              entry.first->second = merge(entry.first->second,pending);
+            int key = residues.rank(residue(deadlines[pending],p));
+            int group = residues.group(key);
+            residues.set_group(key,(group < 0) ? pending : merge(group,pending));
             pending--;
           }
-          Time a = residue(c-p,p), b = residue(r,p);
-          auto target = fractions.find(a);
-          int root = (target == fractions.end()) ? -1 : target->second;
-          // The forbidden region is open: (c-p,r). At a wraparound,
-          // residue zero is included precisely when it is below b.
-          auto consume = [&](std::map<Time,int>::iterator it, Time end) {
-            while ((it != fractions.end()) && (it->first < end)) {
-              int group = it->second;
-              offset[group] += residue(it->first-a,p);
-              root = (root < 0) ? group : merge(root,group);
-              it = fractions.erase(it);
-            }
-          };
-          if (a < b) {
-            consume(fractions.upper_bound(a),b);
-          } else {
-            consume(fractions.upper_bound(a),p);
-            consume(fractions.begin(),b);
-          }
-          if (root >= 0)
-            fractions[a] = root;
+          forbid(residue(c-p,p),residue(r,p),p);
         }
         return true;
       }
@@ -261,10 +370,9 @@ namespace Gecode { namespace Int { namespace InterDistance {
      * Sections 4.1 and 4.2 of Quimper et al. (2008).
      */
     class Filter {
-    public:
+    private:
       const int n;
       const Time p;
-      Task* tasks;
       Task** minSorted;
       Task** maxSorted;
       Forbidden* forbidden;
@@ -279,6 +387,9 @@ namespace Gecode { namespace Int { namespace InterDistance {
       int* links;
       bool* processed;
       int* leader;
+    public:
+      /// Bounds loaded by the propagator, then tightened by this sweep
+      Task* tasks;
       /// Allocate scratch storage, with no persistent ownership
       Filter(Region& r, int n0, int p0)
         : n(n0), p(p0), forbiddenCount(0), regionCount(0) {
@@ -353,8 +464,9 @@ namespace Gecode { namespace Int { namespace InterDistance {
         assert((vi >= 0) && (links[vi] < vi));
         return vi;
       }
-      /// Sort bounds and compute forbidden regions; detect infeasibility
-      bool initialize(Region& r) {
+    private:
+      /// Sort task pointers and record release ranks
+      void sort_tasks(void) {
         for (int i=0; i<n; i++)
           minSorted[i] = maxSorted[i] = tasks+i;
         std::sort(minSorted,minSorted+n,[](const Task* a, const Task* b) {
@@ -365,14 +477,20 @@ namespace Gecode { namespace Int { namespace InterDistance {
           return (a->max < b->max) ||
             ((a->max == b->max) && (a->min < b->min));
         });
+        for (int i=0; i<n; i++)
+          minSorted[i]->minRank = i;
+      }
+
+      /// Construct forbidden start regions, detecting interval infeasibility
+      bool compute_forbidden_regions(Region& r) {
         Time* deadlines = r.alloc<Time>(n);
         int dc = 0;
         for (int i=0; i<n; i++) {
-          minSorted[i]->minRank = i;
           if ((i == 0) || (maxSorted[i]->max > deadlines[dc-1]))
             deadlines[dc++] = maxSorted[i]->max;
           maxSorted[i]->maxRank = dc-1;
         }
+
         Time* times = r.alloc<Time>(dc);
         int* cursor = r.alloc<int>(dc);
         Forbidden* buffer = r.alloc<Forbidden>(n);
@@ -383,6 +501,7 @@ namespace Gecode { namespace Int { namespace InterDistance {
           times[i] = deadlines[i];
           cursor[i] = last;
         }
+
         Time min = std::numeric_limits<Time>::max();
         Time newMin = min;
         forbiddenCount = 0;
@@ -416,6 +535,11 @@ namespace Gecode { namespace Int { namespace InterDistance {
         }
         for (int i=0; i<forbiddenCount; i++)
           forbidden[i] = buffer[last+1+i];
+        return true;
+      }
+
+      /// Tabulate earliest completions outside the forbidden start regions
+      void compute_earliest_completions(void) {
         for (int i=0; i<n; i++) {
           ectTable[i] = minSorted[i]->min;
           int er = 0;
@@ -428,27 +552,83 @@ namespace Gecode { namespace Int { namespace InterDistance {
             ectTable[static_cast<size_t>(q)*n+i] = start+p;
           }
         }
-        return true;
       }
-      /// Apply internal adjustments, then external adjustments by deadline
-      void prune(void) {
+
+      /// Latest starts for one deadline, including the external adjustment
+      void compute_latest_starts(Time deadline, int taskCount) {
+        // Keeping only the current deadline's vector avoids a second
+        // quadratic table without increasing the sweep's complexity.
+        lstTable[0] = deadline;
+        int region = forbiddenCount-1;
+        for (int t=1; t<=taskCount+1; t++) {
+          Time start = lst(t-1)-p;
+          while ((region >= 0) && (forbidden[region].min > start))
+            region--;
+          if ((region >= 0) && (forbidden[region].max >= start))
+            start = forbidden[region].min-1;
+          lstTable[t] = start;
+        }
+      }
+
+      /// Initialize the adjustment list and the groups of variable bounds
+      void initialize_adjustments(void) {
         const Time infinity = std::numeric_limits<Time>::max();
         regions[0] = {-infinity,-infinity,-1,1};
         regions[1] = {infinity,infinity,0,-1};
         regionCount = 2;
-        RegionIndex lastRegion = 0;
         for (int i=0; i<n; i++) {
           links[i] = i-1;
           processed[i] = false;
           bounds[i] = minSorted[i]->min;
           nextRegion[i] = 0;
         }
-        int minP = n, maxP = 0;
+      }
+
+      /// Find the predecessor for an adjustment with lower bound min
+      RegionIndex insertion_point(RegionIndex hint, Time min) const {
+        // Intervals are appended in decreasing-minimum runs. Follow previous
+        // links between runs, then next links within the ordered list.
+        while (((hint+1 == regionCount) ? min : regions[hint+1].min) >=
+               regions[hint].min) {
+          hint = regions[hint].previous;
+          if (hint < 0)
+            break;
+          if (regions[hint].min <= min) {
+            hint--;
+            break;
+          }
+        }
+        hint++;
+        while (regions[regions[hint].next].min < min)
+          hint = regions[hint].next;
+        return hint;
+      }
+
+      /// Insert an adjustment after its predecessor and return its index
+      RegionIndex insert_adjustment(RegionIndex previous, Time min, Time max) {
+        RegionIndex next = regions[previous].next;
+        assert((regions[previous].min <= min) && (min <= regions[next].min));
+        RegionIndex inserted = regionCount++;
+        regions[inserted] = {min,max,previous,next};
+        regions[previous].next = inserted;
+        regions[next].previous = inserted;
+        return inserted;
+      }
+
+      /// Build and apply internal adjustments in deadline order
+      void apply_internal_adjustments(void) {
+        const Time infinity = std::numeric_limits<Time>::max();
+        RegionIndex lastRegion = 0;
+        int minP = n;
+        int maxP = 0;
         for (int it=0; it<n; it++) {
           int i = maxSorted[it]->minRank;
           processed[i] = true;
           maxP = std::max(maxP,i);
           minP = std::min(minP,i);
+
+          // Maintain the dominating blocks before generating their intervals.
+          // These cursors share the sweep's task counts and stay together.
           int l = leader[i] = i;
           int kp = 1;
           while (++l <= maxP)
@@ -479,56 +659,25 @@ namespace Gecode { namespace Int { namespace InterDistance {
           }
           if ((it < n-1) && (maxSorted[it]->max == maxSorted[it+1]->max))
             continue;
-          // Only one deadline is needed at a time. Computing this vector
-          // per deadline keeps quadratic time but removes a quadratic
-          // latest-start table. The extra entry serves external adjustments.
-          lstTable[0] = maxSorted[it]->max;
-          int lr = forbiddenCount-1;
-          for (int t=1; t<=it+2; t++) {
-            Time start = lst(t-1)-p;
-            while ((lr >= 0) && (forbidden[lr].min > start))
-              lr--;
-            if ((lr >= 0) && (forbidden[lr].max >= start))
-              start = forbidden[lr].min-1;
-            lstTable[t] = start;
-          }
+
+          compute_latest_starts(maxSorted[it]->max,it+1);
+
           int q = 0;
           RegionIndex insertion = 0;
           int vi = n-1;
           while (true) {
             for (int t=q; t<k; t++) {
-              regions[regionCount].min = lst(t+1)+1;
+              Time min = lst(t+1)+1;
               // The final empty region allows external adjustments to
               // expand the preceding intervals by one more task.
-              regions[regionCount].max = (l >= 0) ? ect(l,k-t)-1 : -infinity;
+              Time max = (l >= 0) ? ect(l,k-t)-1 : -infinity;
               if (t > 0) {
-                while (regions[insertion+1].min >= regions[insertion].min) {
-                  insertion = regions[insertion].previous;
-                  if (insertion >= 0) {
-                    if (regions[insertion].min <= regions[regionCount].min) {
-                      insertion--;
-                      break;
-                    }
-                  } else {
-                    break;
-                  }
-                }
-                insertion++;
-                while (regions[regions[insertion].next].min <
-                       regions[regionCount].min)
-                  insertion = regions[insertion].next;
+                insertion = insertion_point(insertion,min);
               } else {
                 insertion = lastRegion;
                 firstRegion[i] = lastRegion = regionCount;
               }
-              assert(regions[insertion].min <= regions[regionCount].min);
-              RegionIndex next = regions[insertion].next;
-              regions[regionCount].next = next;
-              regions[insertion].next = regionCount;
-              regions[regionCount].previous = insertion;
-              regions[next].previous = regionCount;
-              assert(regions[regionCount].min <= regions[next].min);
-              vi = notify(regionCount++,vi);
+              vi = notify(insert_adjustment(insertion,min,max),vi);
             }
             if (l == -1)
               break;
@@ -545,6 +694,10 @@ namespace Gecode { namespace Int { namespace InterDistance {
             }
           }
         }
+      }
+
+      /// Apply external adjustments after reading each task's tightened bound
+      void apply_external_adjustments(void) {
         // A variable is filtered before adding external intervals for its
         // deadline, so it is never excluded by an interval it helped create.
         for (int it=0; it<n; it++) {
@@ -564,8 +717,75 @@ namespace Gecode { namespace Int { namespace InterDistance {
           }
         }
       }
+    public:
+      /// Prepare bounds filtering, detecting interval infeasibility
+      bool initialize(Region& r) {
+        sort_tasks();
+        if (!compute_forbidden_regions(r))
+          return false;
+        compute_earliest_completions();
+        return true;
+      }
+
+      /// Apply internal adjustments, then external adjustments by deadline
+      void prune(void) {
+        initialize_adjustments();
+        apply_internal_adjustments();
+        apply_external_adjustments();
+      }
     };
 
+    /// Largest feasible distance in [min,max], or -1 when min is infeasible
+    int maximum_feasible_distance(Region& region,
+                                  const ViewArray<IntView>& x,
+                                  int min, int max) {
+      Feasibility feasibility(region,x);
+      if (!feasibility.check(min))
+        return -1;
+      if ((max == min) || feasibility.check(max))
+        return max;
+
+      // Quimper et al. (2008), Section 5: feasibility is monotone in p.
+      // Keep min feasible and max infeasible without enumerating distances.
+      while (max-min > 1) {
+        int middle = min+(max-min)/2;
+        if (feasibility.check(middle))
+          min = middle;
+        else
+          max = middle;
+      }
+      return min;
+    }
+
+    /// Tighten x bounds in both directions; holes may require another pass
+    ExecStatus filter_bounds(Space& home, Region& region,
+                             ViewArray<IntView>& x, int p) {
+      Filter f(region,x.size(),p);
+      bool nofix = false;
+      for (int direction=0; direction<2; direction++) {
+        for (int i=0; i<x.size(); i++) {
+          // Reverse task time: [r,d] becomes [-d,-r]. Variables denote
+          // starting times, while the algorithm's maxima are deadlines.
+          f.tasks[i].min = direction ? -static_cast<Time>(x[i].max())-p : x[i].min();
+          f.tasks[i].max = direction ? -static_cast<Time>(x[i].min()) :
+            static_cast<Time>(x[i].max())+p;
+        }
+        if (!f.initialize(region))
+          return ES_FAILED;
+        f.prune();
+        for (int i=0; i<x.size(); i++) {
+          Time bound = direction ? -f.tasks[i].min-p : f.tasks[i].min;
+          if (direction ? (bound < x[i].min()) : (bound > x[i].max()))
+            return ES_FAILED;
+          ModEvent me = direction ? x[i].lq(home,static_cast<int>(bound)) :
+            x[i].gq(home,static_cast<int>(bound));
+          GECODE_ME_CHECK(me);
+          nofix |= (direction ? x[i].max() : x[i].min()) != bound;
+        }
+      }
+      return nofix ? ES_NOFIX : ES_FIX;
+    }
+
     /// Minimum separation in an assigned tuple, without quadratic tables
     Time assigned_distance(Region& r, const ViewArray<IntView>& x) {
       Time* values = r.alloc<Time>(x.size());
@@ -625,12 +845,14 @@ namespace Gecode { namespace Int { namespace InterDistance {
   Bnd<PView>::propagate(Space& home, const ModEventDelta& med) {
     Region region;
     bool assigned = true;
-    int min = x[0].min(), max = x[0].max();
+    int min = x[0].min();
+    int max = x[0].max();
     for (int i=0; i<x.size(); i++) {
       min = std::min(min,x[i].min());
       max = std::max(max,x[i].max());
       assigned &= x[i].assigned();
     }
+
     if (assigned) {
       GECODE_ME_CHECK(y.lq(home,assigned_distance(region,x)));
       return home.ES_SUBSUMED(*this);
@@ -639,29 +861,16 @@ namespace Gecode { namespace Int { namespace InterDistance {
       return home.ES_SUBSUMED(*this);
     if (y.assigned() && (y.val() == 1))
       GECODE_REWRITE(*this,Distinct::Bnd<IntView>::post(home(*this),x));
+
     const int p = y.min();
     if (IntView::me(med) != ME_INT_DOM) {
       Time limit = (static_cast<Time>(max)-min)/(x.size()-1);
       int upper = static_cast<int>(std::min(limit,static_cast<Time>(y.max())));
       if (upper < p)
         return ES_FAILED;
-      Feasibility f(region,x);
-      if (!f.check(p))
+      upper = maximum_feasible_distance(region,x,p,upper);
+      if (upper < 0)
         return ES_FAILED;
-      if ((upper > p) && !f.check(upper)) {
-        // Quimper et al. (2008), Section 5: feasibility is monotone in p.
-        // Keep the lower endpoint feasible and the upper endpoint infeasible,
-        // without enumerating distances.
-        int lower = p;
-        while (upper-lower > 1) {
-          int middle = lower+(upper-lower)/2;
-          if (f.check(middle))
-            lower = middle;
-          else
-            upper = middle;
-        }
-        upper = lower;
-      }
       GECODE_ME_CHECK(y.lq(home,upper));
       if (y.max() == 0)
         return home.ES_SUBSUMED(*this);
@@ -671,33 +880,15 @@ namespace Gecode { namespace Int { namespace InterDistance {
         return ES_FIX;
       return home.ES_FIX_PARTIAL(*this,IntView::med(ME_INT_DOM));
     }
+
     // A zero minimum gives every x bound a support; only the basic stage
     // needs to filter the distance. A later increase wakes that stage again.
     if (p == 0)
       return ES_FIX;
-    Filter f(region,x.size(),p);
-    bool nofix = false;
-    for (int direction=0; direction<2; direction++) {
-      for (int i=0; i<x.size(); i++) {
-        // Reverse task time: [r,d] becomes [-d,-r]. Variables denote
-        // starting times, while the algorithm's maxima are deadlines.
-        f.tasks[i].min = direction ? -static_cast<Time>(x[i].max())-p : x[i].min();
-        f.tasks[i].max = direction ? -static_cast<Time>(x[i].min()) :
-          static_cast<Time>(x[i].max())+p;
-      }
-      if (!f.initialize(region))
-        return ES_FAILED;
-      f.prune();
-      for (int i=0; i<x.size(); i++) {
-        Time bound = direction ? -f.tasks[i].min-p : f.tasks[i].min;
-        if (direction ? (bound < x[i].min()) : (bound > x[i].max()))
-          return ES_FAILED;
-        ModEvent me = direction ? x[i].lq(home,static_cast<int>(bound)) :
-          x[i].gq(home,static_cast<int>(bound));
-        GECODE_ME_CHECK(me);
-        nofix |= (direction ? x[i].max() : x[i].min()) != bound;
-      }
-    }
+    ExecStatus filtered = filter_bounds(home,region,x,p);
+    if (filtered == ES_FAILED)
+      return ES_FAILED;
+
     assigned = true;
     for (int i=0; i<x.size(); i++)
       assigned &= x[i].assigned();
@@ -705,9 +896,10 @@ namespace Gecode { namespace Int { namespace InterDistance {
       GECODE_ME_CHECK(y.lq(home,assigned_distance(region,x)));
       return home.ES_SUBSUMED(*this);
     }
+
     // Holes can move actual bounds beyond the computed bounds, invalidating
     // an interval support for x or the distance. Restart the basic stage.
-    return nofix ? ES_NOFIX : ES_FIX;
+    return filtered;
   }
 
   // Export the compiled view specializations for propagator reuse.
diff --git a/test/int/inter-distance.cpp b/test/int/inter-distance.cpp
index 499e9c1068..be1b05b489 100644
--- a/test/int/inter-distance.cpp
+++ b/test/int/inter-distance.cpp
@@ -43,12 +43,11 @@ namespace Test { namespace Int { namespace InterDistance {
   class Distance : public Test {
   protected:
     int p;
-    Gecode::IntPropLevel ipl;
   public:
     Distance(int n, int p0, int min, int max,
              Gecode::IntPropLevel ipl0=Gecode::IPL_DEF)
       : Test("InterDistance::"+str(n)+"::"+str(p0)+"::"+str(min)+
-             "::"+str(ipl0),n,min,max), p(p0), ipl(ipl0) {
+             "::"+str(ipl0),n,min,max,false,ipl0), p(p0) {
       contest = Gecode::ba(ipl) == Gecode::IPL_BASIC ? CTL_NONE : CTL_BOUNDS_Z;
     }
     virtual bool solution(const Assignment& x) const {
@@ -67,11 +66,10 @@ namespace Test { namespace Int { namespace InterDistance {
 
   /// Variable distance, including propagation after distance assignments
   class Variable : public Test {
-    Gecode::IntPropLevel ipl;
   public:
     Variable(int n, Gecode::IntPropLevel ipl0)
       : Test("InterDistance::Variable::"+str(n)+"::"+str(ipl0),
-             n+1,-2,3), ipl(ipl0) {
+             n+1,-2,3,false,ipl0) {
       contest = Gecode::ba(ipl) == Gecode::IPL_BASIC ? CTL_NONE : CTL_BOUNDS_Z;
     }
     virtual bool solution(const Assignment& x) const {
@@ -94,12 +92,14 @@ namespace Test { namespace Int { namespace InterDistance {
 
   /// Small independent oracle for heterogeneous and holey domains
   class Bounds : public Base {
+    typedef std::vector<int> Domain;
+    typedef std::vector<Domain> Domains;
+
     class Model : public Gecode::Space {
     public:
       Gecode::IntVarArray x;
       Gecode::IntVar p;
-      Model(const std::vector<std::vector<int> >& domains,
-            const std::vector<int>& distance={0})
+      Model(const Domains& domains, const Domain& distance={0})
         : x(*this,static_cast<int>(domains.size())),
           p(*this,Gecode::IntSet(distance.data(),
                                 static_cast<int>(distance.size()))) {
@@ -115,140 +115,177 @@ namespace Test { namespace Int { namespace InterDistance {
         return new Model(*this);
       }
     };
-    /// Enumerate tuples using only the defining pairwise inequality
-    static void supports(const std::vector<std::vector<int> >& dom, int p,
-                         int i, std::vector<int>& tuple,
-                         std::vector<int>& lo, std::vector<int>& hi,
-                         bool& found, long long int* gap=nullptr) {
-      if (i == static_cast<int>(dom.size())) {
+
+    /// Supported bounds and largest separation found by tuple enumeration
+    struct Supports {
+      bool found;
+      std::vector<int> min;
+      std::vector<int> max;
+      long long int gap;
+
+      Supports(int n)
+        : found(false), min(n,Gecode::Int::Limits::max),
+          max(n,Gecode::Int::Limits::min), gap(-1) {}
+
+      void include(const std::vector<int>& tuple) {
         found = true;
-        for (int j=0; j<i; j++) {
-          lo[j] = std::min(lo[j],tuple[j]);
-          hi[j] = std::max(hi[j],tuple[j]);
-        }
-        if (gap != nullptr) {
-          long long int d = Gecode::Int::Limits::max;
-          for (int j=0; j<i; j++)
-            for (int k=0; k<j; k++) {
-              long long int delta = static_cast<long long int>(tuple[j])-tuple[k];
-              d = std::min(d,std::abs(delta));
-            }
-          *gap = std::max(*gap,d);
+        long long int distance = Gecode::Int::Limits::max;
+        for (int i=0; i<static_cast<int>(tuple.size()); i++) {
+          min[i] = std::min(min[i],tuple[i]);
+          max[i] = std::max(max[i],tuple[i]);
+          for (int j=0; j<i; j++) {
+            long long int delta = static_cast<long long int>(tuple[i])-tuple[j];
+            distance = std::min(distance,std::abs(delta));
+          }
         }
+        gap = std::max(gap,distance);
+      }
+    };
+
+    /// Enumerate using only the defining pairwise inequality
+    static void enumerate(const Domains& dom, int p, int i,
+                          std::vector<int>& tuple, Supports& result) {
+      if (i == static_cast<int>(dom.size())) {
+        result.include(tuple);
         return;
       }
+
       for (int value : dom[i]) {
         bool valid = true;
         for (int j=0; j<i; j++) {
-          long long int d = static_cast<long long int>(value)-tuple[j];
-          if ((-p < d) && (d < p)) {
+          long long int delta = static_cast<long long int>(value)-tuple[j];
+          if ((-p < delta) && (delta < p)) {
             valid = false;
             break;
           }
         }
         if (valid) {
           tuple[i] = value;
-          supports(dom,p,i+1,tuple,lo,hi,found,gap);
+          enumerate(dom,p,i+1,tuple,result);
         }
       }
     }
-    static bool check(const std::vector<std::vector<int> >& dom, int p,
-                      bool dense) {
-      const int n = static_cast<int>(dom.size());
-      std::vector<int> tuple(n), lo(n,Gecode::Int::Limits::max),
-        hi(n,Gecode::Int::Limits::min);
-      bool found = false;
-      supports(dom,p,0,tuple,lo,hi,found);
-      Model m(dom);
-      Gecode::inter_distance(m,m.x,p);
-      bool failed = m.status() == Gecode::SS_FAILED;
-      bool correct = found ? !failed : (!dense || failed);
-      if (found && !failed)
-        for (int i=0; i<n; i++)
-          correct &= dense ? ((m.x[i].min() == lo[i]) &&
-                              (m.x[i].max() == hi[i])) :
-            ((m.x[i].min() <= lo[i]) && (m.x[i].max() >= hi[i]));
-      if (!dense && !failed) {
-        // Bounds(Z) supports may use holes in other variables. Enumerate
-        // the final interval hulls to check that every remaining bound
-        // has such a support, including bounds that jumped across holes.
-        std::vector<std::vector<int> > hull(n);
-        for (int i=0; i<n; i++)
-          for (int v=m.x[i].min(); v<=m.x[i].max(); v++)
-            hull[i].push_back(v);
-        std::fill(lo.begin(),lo.end(),Gecode::Int::Limits::max);
-        std::fill(hi.begin(),hi.end(),Gecode::Int::Limits::min);
-        found = false;
-        supports(hull,p,0,tuple,lo,hi,found);
-        correct &= found;
-        for (int i=0; i<n; i++)
-          correct &= (m.x[i].min() == lo[i]) && (m.x[i].max() == hi[i]);
-      }
-      if (!correct) {
-        olog << "Distance " << p << ", domains:";
-        for (const auto& d : dom) {
-          olog << " {";
-          for (int v : d)
-            olog << v << ',';
-          olog << '}';
-        }
-        olog << " propagated " << m.x << std::endl;
-      }
-      return correct;
+
+    /// Return independent supports for these domains and separation
+    static Supports enumerate(const Domains& dom, int p) {
+      Supports result(static_cast<int>(dom.size()));
+      std::vector<int> tuple(dom.size());
+      enumerate(dom,p,0,tuple,result);
+      return result;
     }
-    /// Check the largest distance and x supports against tuple enumeration
-    static bool check_variable(const std::vector<std::vector<int> >& dom,
-                               const std::vector<int>& distance, bool dense,
-                               Gecode::IntPropLevel ipl) {
-      const int n = static_cast<int>(dom.size());
-      std::vector<int> tuple(n), lo(n,Gecode::Int::Limits::max),
-        hi(n,Gecode::Int::Limits::min);
-      bool found = false;
-      long long int gap = -1;
-      supports(dom,distance.front(),0,tuple,lo,hi,found,&gap);
-      Model m(dom,distance);
-      Gecode::inter_distance(m,m.x,m.p,ipl);
-      bool failed = m.status() == Gecode::SS_FAILED;
-      bool correct = found ? !failed : (!dense || failed);
-      if (found && !failed) {
-        for (int i=0; i<n; i++)
-          correct &= dense && (Gecode::ba(ipl) != Gecode::IPL_BASIC) ?
-            ((m.x[i].min() == lo[i]) && (m.x[i].max() == hi[i])) :
-            ((m.x[i].min() <= lo[i]) && (m.x[i].max() >= hi[i]));
-        if (dense) {
-          auto largest = std::upper_bound(distance.begin(),distance.end(),gap);
-          correct &= (m.p.max() == *--largest);
-        }
-      }
-      if (!dense && !failed) {
-        // Bounds(Z) supports can use holes in the other x domains.
-        std::vector<std::vector<int> > hull(n);
-        for (int i=0; i<n; i++)
-          for (int v=m.x[i].min(); v<=m.x[i].max(); v++)
-            hull[i].push_back(v);
-        std::fill(lo.begin(),lo.end(),Gecode::Int::Limits::max);
-        std::fill(hi.begin(),hi.end(),Gecode::Int::Limits::min);
-        found = false;
-        gap = -1;
-        supports(hull,m.p.min(),0,tuple,lo,hi,found,&gap);
-        correct &= found;
-        if (found) {
-          auto largest = std::upper_bound(distance.begin(),distance.end(),gap);
-          correct &= (m.p.max() == *--largest);
-          if (Gecode::ba(ipl) != Gecode::IPL_BASIC)
-            for (int i=0; i<n; i++)
-              correct &= (m.x[i].min() == lo[i]) && (m.x[i].max() == hi[i]);
-        }
+
+    /// Interval supports for bounds(Z) may use holes in other variables
+    static Domains interval_hulls(const Gecode::IntVarArray& x) {
+      Domains hull(x.size());
+      for (int i=0; i<x.size(); i++)
+        for (int value=x[i].min(); value<=x[i].max(); value++)
+          hull[i].push_back(value);
+      return hull;
+    }
+
+    /// Check preservation of every feasible tuple's supported bounds
+    static bool preserves_supports(const Gecode::IntVarArray& x,
+                                   const Supports& expected) {
+      for (int i=0; i<x.size(); i++)
+        if ((x[i].min() > expected.min[i]) || (x[i].max() < expected.max[i]))
+          return false;
+      return true;
+    }
+
+    /// Check that each remaining bound has an interval support
+    static bool matches_supports(const Gecode::IntVarArray& x,
+                                 const Supports& expected) {
+      if (!expected.found)
+        return false;
+      for (int i=0; i<x.size(); i++)
+        if ((x[i].min() != expected.min[i]) || (x[i].max() != expected.max[i]))
+          return false;
+      return true;
+    }
+
+    static void print_domain(const Domain& domain) {
+      olog << '{';
+      for (int value : domain)
+        olog << value << ',';
+      olog << '}';
+    }
+
+    /// Record complete inputs and expectations in the test harness log
+    static bool mismatch(const char* reason, const Domains& domains,
+                         const Domain& distance, Gecode::IntPropLevel ipl,
+                         const Supports& expected, const Model& model) {
+      olog << reason << ": domains ";
+      for (const Domain& domain : domains) {
+        print_domain(domain);
+        olog << ' ';
       }
-      if (!correct)
-        olog << "Variable distance " << distance.front() << ".."
-             << distance.back() << ", propagated " << m.x << ", " << m.p
-             << std::endl;
-      return correct;
+      olog << "distance ";
+      print_domain(distance);
+      olog << ", propagation level " << ipl
+           << ", solution exists " << expected.found << ", expected bounds ";
+      for (int i=0; i<model.x.size(); i++)
+        olog << '[' << expected.min[i] << ',' << expected.max[i] << "] ";
+      olog << ", maximum gap " << expected.gap << ", propagated " << model.x
+           << ", distance " << model.p << std::endl;
+      return false;
     }
-  public:
-    Bounds(void) : Base("Int::InterDistance::BoundsOracle") {}
-    virtual bool run(void) {
+
+    static bool check(const Domains& dom, int p, bool dense) {
+      Supports expected = enumerate(dom,p);
+      Model model(dom,{p});
+      Gecode::inter_distance(model,model.x,p);
+      bool failed = model.status() == Gecode::SS_FAILED;
+
+      if ((expected.found && failed) || (!expected.found && dense && !failed))
+        return mismatch("Feasibility",dom,{p},Gecode::IPL_DEF,expected,model);
+      if (failed)
+        return true;
+      if (expected.found && !preserves_supports(model.x,expected))
+        return mismatch("Lost solution",dom,{p},Gecode::IPL_DEF,expected,model);
+
+      // Check the final hulls after jumps across domain holes as well.
+      if (!dense)
+        expected = enumerate(interval_hulls(model.x),p);
+      if (!matches_supports(model.x,expected))
+        return mismatch("Bounds(Z) consistency",dom,{p},Gecode::IPL_DEF,
+                        expected,model);
+      return true;
+    }
+
+    /// Largest domain value supported by the enumerated maximum gap
+    static int largest_distance(const Domain& distance, long long int gap) {
+      auto end = std::upper_bound(distance.begin(),distance.end(),gap);
+      assert(end != distance.begin());
+      return *--end;
+    }
+
+    /// Check distance supports separately from BASIC's weaker x filtering
+    static bool check_variable(const Domains& dom, const Domain& distance,
+                               bool dense, Gecode::IntPropLevel ipl) {
+      Supports expected = enumerate(dom,distance.front());
+      Model model(dom,distance);
+      Gecode::inter_distance(model,model.x,model.p,ipl);
+      bool failed = model.status() == Gecode::SS_FAILED;
+
+      if ((expected.found && failed) || (!expected.found && dense && !failed))
+        return mismatch("Feasibility",dom,distance,ipl,expected,model);
+      if (failed)
+        return true;
+      if (expected.found && !preserves_supports(model.x,expected))
+        return mismatch("Lost solution",dom,distance,ipl,expected,model);
+
+      if (!dense)
+        expected = enumerate(interval_hulls(model.x),model.p.min());
+      if (!expected.found)
+        return mismatch("Interval feasibility",dom,distance,ipl,expected,model);
+      if (model.p.max() != largest_distance(distance,expected.gap))
+        return mismatch("Maximum distance",dom,distance,ipl,expected,model);
+      if ((Gecode::ba(ipl) != Gecode::IPL_BASIC) &&
+          !matches_supports(model.x,expected))
+        return mismatch("Bounds(Z) consistency",dom,distance,ipl,expected,model);
+      return true;
+    }
+    static bool regression_examples(void) {
       // The paper's example, including its reflected form.
       if (!check({{2,3,4,5,6},{10,11,12,13,14},
                   {4,5,6,7,8,9,10,11,12,13,14,15}},6,true))
@@ -261,8 +298,21 @@ namespace Test { namespace Int { namespace InterDistance {
       if (!check({{0,2,6,7},{-3,2},{10,11,14},{1,2,3,6},
                   {-1,0,3,5,9}},4,false))
         return false;
+      // A maximal distance exercises deadlines beyond Int::Limits::max.
+      const int limit = Gecode::Int::Limits::max;
+      if (!check({{-limit,-limit+1},{0,1},{limit-1,limit}},limit,true))
+        return false;
+      // A consumed residue can be reactivated by a later deadline.
+      if (!check_variable({{2,3,4,5,6,7,8,9,10,11},
+                           {-10,-9,-8,-7,-6,-5,-4,-3,-2},{16,17}},
+                          {13,14},true,Gecode::IPL_BASIC))
+        return false;
+      return true;
+    }
+
+    static bool exhaustive_intervals(void) {
       // Exhaust all triples of intervals on [-2,3], including ties.
-      std::vector<std::vector<int> > intervals;
+      Domains intervals;
       for (int l=-2; l<=3; l++)
         for (int u=l; u<=3; u++) {
           std::vector<int> d;
@@ -276,32 +326,41 @@ namespace Test { namespace Int { namespace InterDistance {
             for (const auto& c : intervals)
               if (!check({a,b,c},p,true))
                 return false;
-      // Larger sets cover dominance, external adjustments, holes, and
-      // arithmetic close to both integer limits. Use a fixed local seed.
-      Gecode::Support::RandomGenerator random(2006);
+      return true;
+    }
+
+    /// Generate heterogeneous domains while preserving the fixed RNG sequence
+    static Domains random_domains(Gecode::Support::RandomGenerator& random,
+                                  int n, int offset, bool dense) {
+      Domains domains(n);
+      for (Domain& domain : domains) {
+        int min = offset+static_cast<int>(random(21))-10;
+        int width = random(5);
+        for (int j=0; j<=width; j++)
+          if (dense || (j == 0) || (j == width) || random(2))
+            domain.push_back(min+j);
+      }
+      return domains;
+    }
+
+    static bool random_constant_cases(Gecode::Support::RandomGenerator& random) {
       for (int test=0; test<2000; test++) {
-        int n = 2+random(7), p = 2+random(8);
+        int n = 2+random(7);
+        int p = 2+random(8);
         int offset = (test % 3 == 0) ? Gecode::Int::Limits::min+30 :
           (test % 3 == 1) ? Gecode::Int::Limits::max-30 : 0;
         bool dense = (test % 2 == 0);
-        std::vector<std::vector<int> > dom(n);
-        for (int i=0; i<n; i++) {
-          int l = offset+static_cast<int>(random(21))-10;
-          int width = random(5);
-          for (int j=0; j<=width; j++)
-            if (dense || (j == 0) || (j == width) || random(2))
-              dom[i].push_back(l+j);
-        }
+        Domains dom = random_domains(random,n,offset,dense);
         if (!check(dom,p,dense))
           return false;
       }
-      // A maximal distance exercises deadlines beyond Int::Limits::max.
-      const int limit = Gecode::Int::Limits::max;
-      if (!check({{-limit,-limit+1},{0,1},{limit-1,limit}},limit,true))
-        return false;
+      return true;
+    }
+
+    static bool adjacent_regions(void) {
       // Adjacent forbidden regions used to let the feasibility pass miss
       // this overload. The maximum feasible separation is six, not seven.
-      std::vector<std::vector<int> > adjacent(3);
+      Domains adjacent(3);
       for (int v=1; v<=17; v++) adjacent[0].push_back(v);
       for (int v=5; v<=8; v++) adjacent[1].push_back(v);
       for (int v=2; v<=14; v++) adjacent[2].push_back(v);
@@ -311,19 +370,16 @@ namespace Test { namespace Int { namespace InterDistance {
                                       Gecode::IPL_BASIC_ADVANCED})
         if (!check_variable(adjacent,{0,1,2,3,4,5,6,7,8},true,ipl))
           return false;
+      return true;
+    }
+
+    static bool random_variable_cases(Gecode::Support::RandomGenerator& random) {
       for (int test=0; test<512; test++) {
         int n = 2+random(4);
         int offset = test%3 == 0 ? Gecode::Int::Limits::min+30 :
           test%3 == 1 ? Gecode::Int::Limits::max-30 : 0;
         bool dense = test%2 == 0;
-        std::vector<std::vector<int> > dom(n);
-        for (int i=0; i<n; i++) {
-          int l = offset+static_cast<int>(random(21))-10;
-          int width = random(5);
-          for (int j=0; j<=width; j++)
-            if (dense || (j == 0) || (j == width) || random(2))
-              dom[i].push_back(l+j);
-        }
+        Domains dom = random_domains(random,n,offset,dense);
         std::vector<int> distance;
         int lower = random(4);
         for (int p=lower; p<=12; p++)
@@ -334,9 +390,13 @@ namespace Test { namespace Int { namespace InterDistance {
         if (!check_variable(dom,distance,dense,ipl))
           return false;
       }
+      return true;
+    }
+
+    static bool distance_updates(void) {
       // Raise the minimum distance in a clone after an initial fixpoint.
       // Both p's subscription and staging must survive cloning.
-      std::vector<std::vector<int> > paper = {{2,3,4,5,6},
+      Domains paper = {{2,3,4,5,6},
         {10,11,12,13,14},{4,5,6,7,8,9,10,11,12,13,14,15}};
       Model m(paper,{0,1,2,3,4,5,6,7,8});
       Gecode::inter_distance(m,m.x,m.p);
@@ -352,12 +412,14 @@ namespace Test { namespace Int { namespace InterDistance {
       delete clone;
       if (!correct)
         return false;
+
       Model basic(paper,{6,7,8});
       Gecode::inter_distance(basic,basic.x,basic.p,Gecode::IPL_BASIC);
       if ((basic.status() == Gecode::SS_FAILED) || !basic.p.assigned() ||
           (basic.p.val() != 6) ||
           (basic.x[0].min() != 2) || (basic.x[0].max() != 6))
         return false;
+
       // Assigning p to one must immediately rewrite to distinct, so a
       // newly posted constraint cannot prune further at the same fixpoint.
       Model unit({{-2},{-2,-1}},{1,3});
@@ -365,6 +427,20 @@ namespace Test { namespace Int { namespace InterDistance {
       return (unit.status() != Gecode::SS_FAILED) && unit.p.assigned() &&
         (unit.p.val() == 1) && unit.x[1].assigned() && (unit.x[1].val() == -1);
     }
+  public:
+    Bounds(void) : Base("Int::InterDistance::BoundsOracle") {}
+    virtual bool run(void) {
+      Gecode::Support::RandomGenerator random(2006);
+      if (!regression_examples() || !exhaustive_intervals() ||
+          !random_constant_cases(random) || !adjacent_regions() ||
+          !random_variable_cases(random))
+        return false;
+      if (!distance_updates()) {
+        olog << "Distance updates, cloning, or rewriting failed" << std::endl;
+        return false;
+      }
+      return true;
+    }
   };
 
   /// Posting contracts, vacuous constraints, and shared variables
@@ -377,16 +453,16 @@ namespace Test { namespace Int { namespace InterDistance {
         return new Model(*this);
       }
     };
-  public:
-    Posting(void) : Base("Int::InterDistance::Posting") {}
-    virtual bool run(void) {
+    static bool constant_contracts(void) {
       using namespace Gecode;
       Model s;
       IntVar v(s,-2,2);
       IntVarArgs duplicate(2);
       duplicate[0] = duplicate[1] = v;
       inter_distance(s,duplicate,0);
-      bool same = false, negative = false, tooLarge = false;
+      bool same = false;
+      bool negative = false;
+      bool tooLarge = false;
       try {
         inter_distance(s,duplicate,2);
       } catch (const Gecode::Int::ArgumentSame&) {
@@ -402,34 +478,46 @@ namespace Test { namespace Int { namespace InterDistance {
       } catch (const Gecode::Int::OutOfLimits&) {
         tooLarge = true;
       }
+
       inter_distance(s,IntVarArgs(),2);
       IntVarArgs singleton(1);
       singleton[0] = v;
       inter_distance(s,singleton,2);
       if (!same || !negative || !tooLarge || (s.status() == SS_FAILED))
         return false;
+
       Model t;
       IntVar assigned(t,3,3);
       duplicate[0] = duplicate[1] = assigned;
       inter_distance(t,duplicate,2);
       if (t.status() != SS_FAILED)
         return false;
+      return true;
+    }
+
+    static bool variable_contracts(void) {
+      using namespace Gecode;
       Model empty;
       IntVar distance(empty,-3,9);
       inter_distance(empty,IntVarArgs(),distance);
       if ((empty.status() == SS_FAILED) || (distance.min() != 0))
         return false;
+
       Model negativeDistance;
       IntVar negativeVar(negativeDistance,-3,-1);
       inter_distance(negativeDistance,IntVarArgs(),negativeVar);
       if (negativeDistance.status() != SS_FAILED)
         return false;
+
       Model shared;
-      IntVar a(shared,0,9), b(shared,0,9), p(shared,0,9);
+      IntVar a(shared,0,9);
+      IntVar b(shared,0,9);
+      IntVar p(shared,0,9);
       IntVarArgs pair(2);
       pair[0] = a;
       pair[1] = b;
-      bool alias = false, repeated = false;
+      bool alias = false;
+      bool repeated = false;
       try {
         inter_distance(shared,pair,a);
       } catch (const Gecode::Int::ArgumentSame&) {
@@ -443,6 +531,11 @@ namespace Test { namespace Int { namespace InterDistance {
       }
       if (!alias || !repeated)
         return false;
+      return true;
+    }
+
+    static bool large_distances(void) {
+      using namespace Gecode;
       // A wide search interval exercises binary search and integer limits.
       Model wide;
       const int limit = Gecode::Int::Limits::max;
@@ -454,14 +547,33 @@ namespace Test { namespace Int { namespace InterDistance {
       inter_distance(wide,x,separation,IPL_BASIC);
       if ((wide.status() == SS_FAILED) || (separation.max() != limit/4))
         return false;
+
       // The assigned gap can exceed the representable distance domain.
       Model extremes;
+      IntVarArgs pair(2);
       pair[0] = IntVar(extremes,-limit,-limit);
       pair[1] = IntVar(extremes,limit,limit);
       IntVar large(extremes,0,limit);
       inter_distance(extremes,pair,large);
       return (extremes.status() != SS_FAILED) && (large.max() == limit);
     }
+  public:
+    Posting(void) : Base("Int::InterDistance::Posting") {}
+    virtual bool run(void) {
+      if (!constant_contracts()) {
+        olog << "Constant posting contracts failed" << std::endl;
+        return false;
+      }
+      if (!variable_contracts()) {
+        olog << "Variable posting contracts failed" << std::endl;
+        return false;
+      }
+      if (!large_distances()) {
+        olog << "Large-distance arithmetic failed" << std::endl;
+        return false;
+      }
+      return true;
+    }
   };
 
   class Create {

From 551c6ab249edec4d467345e2609e43d6ad436027 Mon Sep 17 00:00:00 2001
From: Mikael Zayenz Lagerkvist <lagerkvist@gecode.dev>
Date: Sun, 4 Oct 2026 12:45:52 +0200
Subject: [PATCH 08/13] Name the inter-distance residue range merge

---
 gecode/int/inter-distance.cpp | 35 +++++++++++++++++++----------------
 1 file changed, 19 insertions(+), 16 deletions(-)

diff --git a/gecode/int/inter-distance.cpp b/gecode/int/inter-distance.cpp
index 69fcd7e4d7..5d72c50f68 100644
--- a/gecode/int/inter-distance.cpp
+++ b/gecode/int/inter-distance.cpp
@@ -232,30 +232,33 @@ namespace Gecode { namespace Int { namespace InterDistance {
         return deadlines[i]+p-static_cast<Time>(load(i))*p-displacement(i);
       }
 
+      /// Shift and merge active residues from first up to end into target
+      void merge_residue_range(int first, Time end, int target, int p) {
+        Time a = residues.key(target);
+        int root = residues.group(target);
+        int i = first;
+        while (!residues.at_end(i) && (residues.key(i) < end)) {
+          Time key = residues.key(i);
+          int group = residues.group(i);
+          offset[group] += residue(key-a,p);
+          root = merge(root,group);
+          residues.remove(i);
+          i = residues.active_after(key);
+        }
+        residues.set_group(target,root);
+      }
+
       /// Move groups in the open residue arc (a,b) into the group at a
       void forbid(Time a, Time b, int p) {
         int target = residues.rank(a);
-        int root = residues.group(target);
         // The active deadline's group has residue critical(active,p) % p,
         // so activation has already supplied the target key.
-        assert(root >= 0);
-
-        auto consume = [&](int i, Time end) {
-          while (!residues.at_end(i) && (residues.key(i) < end)) {
-            Time key = residues.key(i);
-            int group = residues.group(i);
-            offset[group] += residue(key-a,p);
-            root = merge(root,group);
-            residues.remove(i);
-            i = residues.active_after(key);
-          }
-        };
+        assert(residues.group(target) >= 0);
 
         // At a wraparound, zero is included precisely when it is below b.
-        consume(residues.active_after(a),(a < b) ? b : p);
+        merge_residue_range(residues.active_after(a),(a < b) ? b : p,target,p);
         if (a >= b)
-          consume(residues.first_active(),b);
-        residues.set_group(target,root);
+          merge_residue_range(residues.first_active(),b,target,p);
       }
     public:
       Feasibility(Region& r, const ViewArray<IntView>& x)

From e75cd41570c7e0924a44fc1307a038bb9e757627 Mon Sep 17 00:00:00 2001
From: Mikael Zayenz Lagerkvist <lagerkvist@gecode.dev>
Date: Sun, 4 Oct 2026 14:54:59 +0200
Subject: [PATCH 09/13] Make inter-distance filtering prerequisites explicit

---
 gecode/int/inter-distance.cpp | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

diff --git a/gecode/int/inter-distance.cpp b/gecode/int/inter-distance.cpp
index 5d72c50f68..68a9acbde9 100644
--- a/gecode/int/inter-distance.cpp
+++ b/gecode/int/inter-distance.cpp
@@ -385,8 +385,12 @@ namespace Gecode { namespace Int { namespace InterDistance {
       Adjustment* regions;
       RegionIndex regionCount;
       RegionIndex* firstRegion;
+      /// Adjustment-list cursor for each live bound-group representative
       RegionIndex* nextRegion;
       Time* bounds;
+      // links[i] > i forwards to a merged group's representative; otherwise
+      // i is a live representative and links[i] < i is its predecessor (-1
+      // for the first group). Merging preserves this predecessor at the root.
       int* links;
       bool* processed;
       int* leader;
@@ -721,20 +725,16 @@ namespace Gecode { namespace Int { namespace InterDistance {
         }
       }
     public:
-      /// Prepare bounds filtering, detecting interval infeasibility
-      bool initialize(Region& r) {
+      /// Filter bounds, returning false on interval infeasibility
+      bool filter(Region& r) {
         sort_tasks();
         if (!compute_forbidden_regions(r))
           return false;
         compute_earliest_completions();
-        return true;
-      }
-
-      /// Apply internal adjustments, then external adjustments by deadline
-      void prune(void) {
         initialize_adjustments();
         apply_internal_adjustments();
         apply_external_adjustments();
+        return true;
       }
     };
 
@@ -773,9 +773,8 @@ namespace Gecode { namespace Int { namespace InterDistance {
           f.tasks[i].max = direction ? -static_cast<Time>(x[i].min()) :
             static_cast<Time>(x[i].max())+p;
         }
-        if (!f.initialize(region))
+        if (!f.filter(region))
           return ES_FAILED;
-        f.prune();
         for (int i=0; i<x.size(); i++) {
           Time bound = direction ? -f.tasks[i].min-p : f.tasks[i].min;
           if (direction ? (bound < x[i].min()) : (bound > x[i].max()))

From b880d0e94b119058a91b6fb2131a42b4cf660423 Mon Sep 17 00:00:00 2001
From: Mikael Zayenz Lagerkvist <lagerkvist@gecode.dev>
Date: Mon, 5 Oct 2026 08:05:40 +0200
Subject: [PATCH 10/13] Track inter-distance sources in Autoconf dependencies

---
 Makefile.dep | 136 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 136 insertions(+)

diff --git a/Makefile.dep b/Makefile.dep
index 1ea49eac45..e6c20d7d10 100644
--- a/Makefile.dep
+++ b/Makefile.dep
@@ -35244,3 +35244,139 @@ test/int/min-distance$(OBJSUFFIX) test/int/min-distance$(SBJSUFFIX): \
 	./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/inter-distance$(OBJSUFFIX) gecode/int/inter-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 \
+	./gecode/int/branch/assign.hpp ./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/distinct.hh ./gecode/int/distinct/bnd.hpp ./gecode/int/distinct/cbs.hpp \
+	./gecode/int/distinct/dom-ctrl.hpp ./gecode/int/distinct/dom.hpp ./gecode/int/distinct/eqite.hpp \
+	./gecode/int/distinct/graph.hpp ./gecode/int/distinct/ter-dom.hpp ./gecode/int/distinct/val.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/inter-distance.hh \
+	./gecode/int/ipl.hpp ./gecode/int/irt.hpp ./gecode/int/limits.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-val-graph.hh \
+	./gecode/int/view-val-graph/bi-link.hpp ./gecode/int/view-val-graph/comb-ptr-flag.hpp ./gecode/int/view-val-graph/edge.hpp \
+	./gecode/int/view-val-graph/graph.hpp ./gecode/int/view-val-graph/iter-prune-val.hpp ./gecode/int/view-val-graph/node.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/inter-distance$(OBJSUFFIX) test/int/inter-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 \
+	./gecode/int/branch/assign.hpp ./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/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 \
+	./test/int.hh ./test/int.hpp ./test/test.hh \
+	./test/test.hpp

From 27b3543a6b05b82164dfc7f648de0c47a5c63d56 Mon Sep 17 00:00:00 2001
From: Mikael Zayenz Lagerkvist <lagerkvist@gecode.dev>
Date: Mon, 5 Oct 2026 20:18:32 +0200
Subject: [PATCH 11/13] Express inter-distance task ordering with tuple
 comparisons

---
 gecode/int/inter-distance.cpp | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/gecode/int/inter-distance.cpp b/gecode/int/inter-distance.cpp
index 68a9acbde9..77b39cef20 100644
--- a/gecode/int/inter-distance.cpp
+++ b/gecode/int/inter-distance.cpp
@@ -38,6 +38,7 @@
 
 #include <algorithm>
 #include <limits>
+#include <tuple>
 
 namespace Gecode { namespace Int { namespace InterDistance {
 
@@ -273,8 +274,7 @@ namespace Gecode { namespace Int { namespace InterDistance {
           release[i] = finish[i] = tasks+i;
         }
         std::sort(release,release+n,[](const Task* a, const Task* b) {
-          return (a->min < b->min) ||
-            ((a->min == b->min) && (a->max < b->max));
+          return std::tie(a->min,a->max) < std::tie(b->min,b->max);
         });
         std::sort(finish,finish+n,[](const Task* a, const Task* b) {
           return a->max < b->max;
@@ -477,12 +477,10 @@ namespace Gecode { namespace Int { namespace InterDistance {
         for (int i=0; i<n; i++)
           minSorted[i] = maxSorted[i] = tasks+i;
         std::sort(minSorted,minSorted+n,[](const Task* a, const Task* b) {
-          return (a->min < b->min) ||
-            ((a->min == b->min) && (a->max < b->max));
+          return std::tie(a->min,a->max) < std::tie(b->min,b->max);
         });
         std::sort(maxSorted,maxSorted+n,[](const Task* a, const Task* b) {
-          return (a->max < b->max) ||
-            ((a->max == b->max) && (a->min < b->min));
+          return std::tie(a->max,a->min) < std::tie(b->max,b->min);
         });
         for (int i=0; i<n; i++)
           minSorted[i]->minRank = i;

From aa53003ae99d90d26b5aba3ade29e32f3be6cf8e Mon Sep 17 00:00:00 2001
From: Mikael Zayenz Lagerkvist <lagerkvist@gecode.dev>
Date: Fri, 9 Oct 2026 15:51:19 +0200
Subject: [PATCH 12/13] Keep inter-distance tests focused on harness checks and
 regressions

---
 test/int/inter-distance.cpp | 338 +++++++-----------------------------
 1 file changed, 59 insertions(+), 279 deletions(-)

diff --git a/test/int/inter-distance.cpp b/test/int/inter-distance.cpp
index be1b05b489..3c6985a6d4 100644
--- a/test/int/inter-distance.cpp
+++ b/test/int/inter-distance.cpp
@@ -46,10 +46,17 @@ namespace Test { namespace Int { namespace InterDistance {
   public:
     Distance(int n, int p0, int min, int max,
              Gecode::IntPropLevel ipl0=Gecode::IPL_DEF)
-      : Test("InterDistance::"+str(n)+"::"+str(p0)+"::"+str(min)+
+      : Test((n == 3 && p0 == 2 && min == -3)
+             ? TestTags::check() : TestTags::standard(),
+             "InterDistance::"+str(n)+"::"+str(p0)+"::"+str(min)+
              "::"+str(ipl0),n,min,max,false,ipl0), p(p0) {
       contest = Gecode::ba(ipl) == Gecode::IPL_BASIC ? CTL_NONE : CTL_BOUNDS_Z;
     }
+    Distance(int n, int p0, const Gecode::IntSet& domain)
+      : Test(TestTags::standard(),"InterDistance::Holes::"+str(n)+"::"+str(p0),
+             n,domain,false,Gecode::IPL_DEF), p(p0) {
+      contest = CTL_BOUNDS_Z;
+    }
     virtual bool solution(const Assignment& x) const {
       for (int i=0; i<x.size(); i++)
         for (int j=0; j<i; j++) {
@@ -68,7 +75,8 @@ namespace Test { namespace Int { namespace InterDistance {
   class Variable : public Test {
   public:
     Variable(int n, Gecode::IntPropLevel ipl0)
-      : Test("InterDistance::Variable::"+str(n)+"::"+str(ipl0),
+      : Test(n == 3 ? TestTags::check() : TestTags::standard(),
+             "InterDistance::Variable::"+str(n)+"::"+str(ipl0),
              n+1,-2,3,false,ipl0) {
       contest = Gecode::ba(ipl) == Gecode::IPL_BASIC ? CTL_NONE : CTL_BOUNDS_Z;
     }
@@ -90,8 +98,8 @@ namespace Test { namespace Int { namespace InterDistance {
     }
   };
 
-  /// Small independent oracle for heterogeneous and holey domains
-  class Bounds : public Base {
+  /// Regressions for hole jumps, critical regions, and distance updates
+  class Regression : public Base {
     typedef std::vector<int> Domain;
     typedef std::vector<Domain> Domains;
 
@@ -116,281 +124,60 @@ namespace Test { namespace Int { namespace InterDistance {
       }
     };
 
-    /// Supported bounds and largest separation found by tuple enumeration
-    struct Supports {
-      bool found;
-      std::vector<int> min;
-      std::vector<int> max;
-      long long int gap;
-
-      Supports(int n)
-        : found(false), min(n,Gecode::Int::Limits::max),
-          max(n,Gecode::Int::Limits::min), gap(-1) {}
-
-      void include(const std::vector<int>& tuple) {
-        found = true;
-        long long int distance = Gecode::Int::Limits::max;
-        for (int i=0; i<static_cast<int>(tuple.size()); i++) {
-          min[i] = std::min(min[i],tuple[i]);
-          max[i] = std::max(max[i],tuple[i]);
-          for (int j=0; j<i; j++) {
-            long long int delta = static_cast<long long int>(tuple[i])-tuple[j];
-            distance = std::min(distance,std::abs(delta));
-          }
-        }
-        gap = std::max(gap,distance);
-      }
-    };
-
-    /// Enumerate using only the defining pairwise inequality
-    static void enumerate(const Domains& dom, int p, int i,
-                          std::vector<int>& tuple, Supports& result) {
-      if (i == static_cast<int>(dom.size())) {
-        result.include(tuple);
-        return;
-      }
-
-      for (int value : dom[i]) {
-        bool valid = true;
-        for (int j=0; j<i; j++) {
-          long long int delta = static_cast<long long int>(value)-tuple[j];
-          if ((-p < delta) && (delta < p)) {
-            valid = false;
-            break;
-          }
-        }
-        if (valid) {
-          tuple[i] = value;
-          enumerate(dom,p,i+1,tuple,result);
+    static bool regressions(void) {
+      using namespace Gecode;
+      // The paper's example and its reflection have unique solutions.
+      for (int sign : {1,-1}) {
+        Domains domains = {{2,3,4,5,6},{10,11,12,13,14},
+          {4,5,6,7,8,9,10,11,12,13,14,15}};
+        for (Domain& domain : domains) {
+          for (int& value : domain)
+            value *= sign;
+          std::sort(domain.begin(),domain.end());
         }
-      }
-    }
-
-    /// Return independent supports for these domains and separation
-    static Supports enumerate(const Domains& dom, int p) {
-      Supports result(static_cast<int>(dom.size()));
-      std::vector<int> tuple(dom.size());
-      enumerate(dom,p,0,tuple,result);
-      return result;
-    }
-
-    /// Interval supports for bounds(Z) may use holes in other variables
-    static Domains interval_hulls(const Gecode::IntVarArray& x) {
-      Domains hull(x.size());
-      for (int i=0; i<x.size(); i++)
-        for (int value=x[i].min(); value<=x[i].max(); value++)
-          hull[i].push_back(value);
-      return hull;
-    }
-
-    /// Check preservation of every feasible tuple's supported bounds
-    static bool preserves_supports(const Gecode::IntVarArray& x,
-                                   const Supports& expected) {
-      for (int i=0; i<x.size(); i++)
-        if ((x[i].min() > expected.min[i]) || (x[i].max() < expected.max[i]))
-          return false;
-      return true;
-    }
-
-    /// Check that each remaining bound has an interval support
-    static bool matches_supports(const Gecode::IntVarArray& x,
-                                 const Supports& expected) {
-      if (!expected.found)
-        return false;
-      for (int i=0; i<x.size(); i++)
-        if ((x[i].min() != expected.min[i]) || (x[i].max() != expected.max[i]))
+        Model model(domains);
+        inter_distance(model,model.x,6);
+        if ((model.status() == SS_FAILED) || !model.x.assigned() ||
+            (model.x[0].val() != sign*2) ||
+            (model.x[1].val() != sign*14) ||
+            (model.x[2].val() != sign*8))
           return false;
-      return true;
-    }
-
-    static void print_domain(const Domain& domain) {
-      olog << '{';
-      for (int value : domain)
-        olog << value << ',';
-      olog << '}';
-    }
-
-    /// Record complete inputs and expectations in the test harness log
-    static bool mismatch(const char* reason, const Domains& domains,
-                         const Domain& distance, Gecode::IntPropLevel ipl,
-                         const Supports& expected, const Model& model) {
-      olog << reason << ": domains ";
-      for (const Domain& domain : domains) {
-        print_domain(domain);
-        olog << ' ';
       }
-      olog << "distance ";
-      print_domain(distance);
-      olog << ", propagation level " << ipl
-           << ", solution exists " << expected.found << ", expected bounds ";
-      for (int i=0; i<model.x.size(); i++)
-        olog << '[' << expected.min[i] << ',' << expected.max[i] << "] ";
-      olog << ", maximum gap " << expected.gap << ", propagated " << model.x
-           << ", distance " << model.p << std::endl;
-      return false;
-    }
-
-    static bool check(const Domains& dom, int p, bool dense) {
-      Supports expected = enumerate(dom,p);
-      Model model(dom,{p});
-      Gecode::inter_distance(model,model.x,p);
-      bool failed = model.status() == Gecode::SS_FAILED;
-
-      if ((expected.found && failed) || (!expected.found && dense && !failed))
-        return mismatch("Feasibility",dom,{p},Gecode::IPL_DEF,expected,model);
-      if (failed)
-        return true;
-      if (expected.found && !preserves_supports(model.x,expected))
-        return mismatch("Lost solution",dom,{p},Gecode::IPL_DEF,expected,model);
 
-      // Check the final hulls after jumps across domain holes as well.
-      if (!dense)
-        expected = enumerate(interval_hulls(model.x),p);
-      if (!matches_supports(model.x,expected))
-        return mismatch("Bounds(Z) consistency",dom,{p},Gecode::IPL_DEF,
-                        expected,model);
-      return true;
-    }
-
-    /// Largest domain value supported by the enumerated maximum gap
-    static int largest_distance(const Domain& distance, long long int gap) {
-      auto end = std::upper_bound(distance.begin(),distance.end(),gap);
-      assert(end != distance.begin());
-      return *--end;
-    }
-
-    /// Check distance supports separately from BASIC's weaker x filtering
-    static bool check_variable(const Domains& dom, const Domain& distance,
-                               bool dense, Gecode::IntPropLevel ipl) {
-      Supports expected = enumerate(dom,distance.front());
-      Model model(dom,distance);
-      Gecode::inter_distance(model,model.x,model.p,ipl);
-      bool failed = model.status() == Gecode::SS_FAILED;
-
-      if ((expected.found && failed) || (!expected.found && dense && !failed))
-        return mismatch("Feasibility",dom,distance,ipl,expected,model);
-      if (failed)
-        return true;
-      if (expected.found && !preserves_supports(model.x,expected))
-        return mismatch("Lost solution",dom,distance,ipl,expected,model);
-
-      if (!dense)
-        expected = enumerate(interval_hulls(model.x),model.p.min());
-      if (!expected.found)
-        return mismatch("Interval feasibility",dom,distance,ipl,expected,model);
-      if (model.p.max() != largest_distance(distance,expected.gap))
-        return mismatch("Maximum distance",dom,distance,ipl,expected,model);
-      if ((Gecode::ba(ipl) != Gecode::IPL_BASIC) &&
-          !matches_supports(model.x,expected))
-        return mismatch("Bounds(Z) consistency",dom,distance,ipl,expected,model);
-      return true;
-    }
-    static bool regression_examples(void) {
-      // The paper's example, including its reflected form.
-      if (!check({{2,3,4,5,6},{10,11,12,13,14},
-                  {4,5,6,7,8,9,10,11,12,13,14,15}},6,true))
-        return false;
-      if (!check({{-6,-5,-4,-3,-2},{-14,-13,-12,-11,-10},
-                  {-15,-14,-13,-12,-11,-10,-9,-8,-7,-6,-5,-4}},6,true))
-        return false;
-      // Upper-bound pruning across holes can assign an invalid tuple in
-      // one pass; it must be checked rather than immediately subsumed.
-      if (!check({{0,2,6,7},{-3,2},{10,11,14},{1,2,3,6},
-                  {-1,0,3,5,9}},4,false))
-        return false;
-      // A maximal distance exercises deadlines beyond Int::Limits::max.
-      const int limit = Gecode::Int::Limits::max;
-      if (!check({{-limit,-limit+1},{0,1},{limit-1,limit}},limit,true))
-        return false;
-      // A consumed residue can be reactivated by a later deadline.
-      if (!check_variable({{2,3,4,5,6,7,8,9,10,11},
-                           {-10,-9,-8,-7,-6,-5,-4,-3,-2},{16,17}},
-                          {13,14},true,Gecode::IPL_BASIC))
+      // A jump across holes must not subsume an invalid assigned tuple.
+      Model holes({{0,2,6,7},{-3,2},{10,11,14},{1,2,3,6},
+                   {-1,0,3,5,9}});
+      inter_distance(holes,holes.x,4);
+      if (holes.status() != SS_FAILED)
         return false;
-      return true;
-    }
-
-    static bool exhaustive_intervals(void) {
-      // Exhaust all triples of intervals on [-2,3], including ties.
-      Domains intervals;
-      for (int l=-2; l<=3; l++)
-        for (int u=l; u<=3; u++) {
-          std::vector<int> d;
-          for (int v=l; v<=u; v++)
-            d.push_back(v);
-          intervals.push_back(d);
-        }
-      for (int p=2; p<=3; p++)
-        for (const auto& a : intervals)
-          for (const auto& b : intervals)
-            for (const auto& c : intervals)
-              if (!check({a,b,c},p,true))
-                return false;
-      return true;
-    }
-
-    /// Generate heterogeneous domains while preserving the fixed RNG sequence
-    static Domains random_domains(Gecode::Support::RandomGenerator& random,
-                                  int n, int offset, bool dense) {
-      Domains domains(n);
-      for (Domain& domain : domains) {
-        int min = offset+static_cast<int>(random(21))-10;
-        int width = random(5);
-        for (int j=0; j<=width; j++)
-          if (dense || (j == 0) || (j == width) || random(2))
-            domain.push_back(min+j);
-      }
-      return domains;
-    }
 
-    static bool random_constant_cases(Gecode::Support::RandomGenerator& random) {
-      for (int test=0; test<2000; test++) {
-        int n = 2+random(7);
-        int p = 2+random(8);
-        int offset = (test % 3 == 0) ? Gecode::Int::Limits::min+30 :
-          (test % 3 == 1) ? Gecode::Int::Limits::max-30 : 0;
-        bool dense = (test % 2 == 0);
-        Domains dom = random_domains(random,n,offset,dense);
-        if (!check(dom,p,dense))
-          return false;
-      }
-      return true;
-    }
+      // A consumed residue can become active at a later deadline.
+      Model residue({{2,3,4,5,6,7,8,9,10,11},
+                     {-10,-9,-8,-7,-6,-5,-4,-3,-2},{16,17}},{13,14});
+      inter_distance(residue,residue.x,residue.p,IPL_BASIC);
+      if ((residue.status() == SS_FAILED) || !residue.p.assigned() ||
+          (residue.p.val() != 13))
+        return false;
 
-    static bool adjacent_regions(void) {
-      // Adjacent forbidden regions used to let the feasibility pass miss
-      // this overload. The maximum feasible separation is six, not seven.
+      // Adjacent forbidden regions limit separation to six, not seven.
       Domains adjacent(3);
       for (int v=1; v<=17; v++) adjacent[0].push_back(v);
       for (int v=5; v<=8; v++) adjacent[1].push_back(v);
       for (int v=2; v<=14; v++) adjacent[2].push_back(v);
-      if (!check(adjacent,7,true))
-        return false;
-      for (Gecode::IntPropLevel ipl : {Gecode::IPL_BASIC,Gecode::IPL_ADVANCED,
-                                      Gecode::IPL_BASIC_ADVANCED})
-        if (!check_variable(adjacent,{0,1,2,3,4,5,6,7,8},true,ipl))
-          return false;
-      return true;
-    }
-
-    static bool random_variable_cases(Gecode::Support::RandomGenerator& random) {
-      for (int test=0; test<512; test++) {
-        int n = 2+random(4);
-        int offset = test%3 == 0 ? Gecode::Int::Limits::min+30 :
-          test%3 == 1 ? Gecode::Int::Limits::max-30 : 0;
-        bool dense = test%2 == 0;
-        Domains dom = random_domains(random,n,offset,dense);
-        std::vector<int> distance;
-        int lower = random(4);
-        for (int p=lower; p<=12; p++)
-          if (dense || (p == lower) || (p == 12) || random(2))
-            distance.push_back(p);
-        Gecode::IntPropLevel ipl = test%3 == 0 ? Gecode::IPL_BASIC :
-          test%3 == 1 ? Gecode::IPL_ADVANCED : Gecode::IPL_DEF;
-        if (!check_variable(dom,distance,dense,ipl))
+      for (IntPropLevel ipl : {IPL_BASIC,IPL_ADVANCED,IPL_BASIC_ADVANCED}) {
+        Model model(adjacent,{0,1,2,3,4,5,6,7,8});
+        inter_distance(model,model.x,model.p,ipl);
+        if ((model.status() == SS_FAILED) || (model.p.max() != 6))
           return false;
       }
-      return true;
+
+      // Deadlines can extend beyond the representable integer domain.
+      const int limit = Gecode::Int::Limits::max;
+      Model extremes({{-limit,-limit+1},{0,1},{limit-1,limit}});
+      inter_distance(extremes,extremes.x,limit);
+      return (extremes.status() != SS_FAILED) && extremes.x.assigned() &&
+        (extremes.x[0].val() == -limit) && (extremes.x[1].val() == 0) &&
+        (extremes.x[2].val() == limit);
     }
 
     static bool distance_updates(void) {
@@ -428,18 +215,10 @@ namespace Test { namespace Int { namespace InterDistance {
         (unit.p.val() == 1) && unit.x[1].assigned() && (unit.x[1].val() == -1);
     }
   public:
-    Bounds(void) : Base("Int::InterDistance::BoundsOracle") {}
+    Regression(void)
+      : Base("Int::InterDistance::Regression",TestTags::check()) {}
     virtual bool run(void) {
-      Gecode::Support::RandomGenerator random(2006);
-      if (!regression_examples() || !exhaustive_intervals() ||
-          !random_constant_cases(random) || !adjacent_regions() ||
-          !random_variable_cases(random))
-        return false;
-      if (!distance_updates()) {
-        olog << "Distance updates, cloning, or rewriting failed" << std::endl;
-        return false;
-      }
-      return true;
+      return regressions() && distance_updates();
     }
   };
 
@@ -558,7 +337,7 @@ namespace Test { namespace Int { namespace InterDistance {
       return (extremes.status() != SS_FAILED) && (large.max() == limit);
     }
   public:
-    Posting(void) : Base("Int::InterDistance::Posting") {}
+    Posting(void) : Base("Int::InterDistance::Posting",TestTags::check()) {}
     virtual bool run(void) {
       if (!constant_contracts()) {
         olog << "Constant posting contracts failed" << std::endl;
@@ -582,6 +361,7 @@ namespace Test { namespace Int { namespace InterDistance {
       for (int n=1; n<=4; n++)
         for (int p=0; p<=4; p++)
           (void) new Distance(n,p,-3,3);
+      (void) new Distance(3,2,Gecode::IntSet({-3,-1,0,2,3}));
       (void) new Distance(3,2,Gecode::Int::Limits::min,
                              Gecode::Int::Limits::min+5);
       (void) new Distance(3,2,Gecode::Int::Limits::max-5,
@@ -600,7 +380,7 @@ namespace Test { namespace Int { namespace InterDistance {
         Gecode::IPL_BND | Gecode::IPL_BASIC));
     }
   } create;
-  Bounds bounds;
+  Regression regression;
   Posting posting;
 
 }}}

From f6dfaba86c77c9fcfef1d4b4e3826a96edf5249d Mon Sep 17 00:00:00 2001
From: Mikael Zayenz Lagerkvist <zayenz@egwene.local>
Date: Mon, 12 Oct 2026 20:59:00 +0200
Subject: [PATCH 13/13] Use the standard harness for inter-distance tests

---
 test/int/inter-distance.cpp | 317 ++++++++++++++++++------------------
 1 file changed, 162 insertions(+), 155 deletions(-)

diff --git a/test/int/inter-distance.cpp b/test/int/inter-distance.cpp
index 3c6985a6d4..362a76b513 100644
--- a/test/int/inter-distance.cpp
+++ b/test/int/inter-distance.cpp
@@ -34,7 +34,6 @@
 #include "test/int.hh"
 
 #include <algorithm>
-#include <vector>
 #include <limits>
 
 namespace Test { namespace Int { namespace InterDistance {
@@ -98,143 +97,150 @@ namespace Test { namespace Int { namespace InterDistance {
     }
   };
 
-  /// Regressions for hole jumps, critical regions, and distance updates
-  class Regression : public Base {
-    typedef std::vector<int> Domain;
-    typedef std::vector<Domain> Domains;
-
-    class Model : public Gecode::Space {
-    public:
-      Gecode::IntVarArray x;
-      Gecode::IntVar p;
-      Model(const Domains& domains, const Domain& distance={0})
-        : x(*this,static_cast<int>(domains.size())),
-          p(*this,Gecode::IntSet(distance.data(),
-                                static_cast<int>(distance.size()))) {
-        for (int i=0; i<x.size(); i++)
-          x[i] = Gecode::IntVar(*this,Gecode::IntSet(
-            domains[i].data(),static_cast<int>(domains[i].size())));
-      }
-      Model(Model& s) : Gecode::Space(s) {
-        x.update(*this,s.x);
-        p.update(*this,s.p);
-      }
-      virtual Gecode::Space* copy(void) {
-        return new Model(*this);
-      }
-    };
-
-    static bool regressions(void) {
-      using namespace Gecode;
-      // The paper's example and its reflection have unique solutions.
-      for (int sign : {1,-1}) {
-        Domains domains = {{2,3,4,5,6},{10,11,12,13,14},
-          {4,5,6,7,8,9,10,11,12,13,14,15}};
-        for (Domain& domain : domains) {
-          for (int& value : domain)
-            value *= sign;
-          std::sort(domain.begin(),domain.end());
+  /// Mix arbitrary assignments with sorted, separated values and shuffle them
+  class DistanceAssignment : public RandomAssignment {
+  protected:
+    int p;
+    bool variable;
+  public:
+    DistanceAssignment(int n, const Gecode::IntSet& d, int p0, bool v,
+                       Gecode::Support::RandomGenerator& rand)
+      : RandomAssignment(n,d,100,rand), p(p0), variable(v) {}
+    virtual void next(Gecode::Support::RandomGenerator& rand) {
+      RandomAssignment::next(rand);
+      if (a % 2 == 0) {
+        int m = n - static_cast<int>(variable);
+        int distance = variable ? static_cast<int>(rand(p+1)) : p;
+        int slack = d.max()-d.min()-(m-1)*distance;
+        int value = d.min();
+        for (int i=0; i<m; i++) {
+          int extra = static_cast<int>(rand(slack+1));
+          slack -= extra;
+          value += extra;
+          vals[i] = value;
+          if (i+1 < m)
+            value += distance;
         }
-        Model model(domains);
-        inter_distance(model,model.x,6);
-        if ((model.status() == SS_FAILED) || !model.x.assigned() ||
-            (model.x[0].val() != sign*2) ||
-            (model.x[1].val() != sign*14) ||
-            (model.x[2].val() != sign*8))
-          return false;
+        for (int i=m-1; i>0; i--) {
+          int j = static_cast<int>(rand(i+1));
+          std::swap(vals[i],vals[j]);
+        }
+        if (variable)
+          vals[m] = distance;
       }
+    }
+  };
 
-      // A jump across holes must not subsume an invalid assigned tuple.
-      Model holes({{0,2,6,7},{-3,2},{10,11,14},{1,2,3,6},
-                   {-1,0,3,5,9}});
-      inter_distance(holes,holes.x,4);
-      if (holes.status() != SS_FAILED)
-        return false;
-
-      // A consumed residue can become active at a later deadline.
-      Model residue({{2,3,4,5,6,7,8,9,10,11},
-                     {-10,-9,-8,-7,-6,-5,-4,-3,-2},{16,17}},{13,14});
-      inter_distance(residue,residue.x,residue.p,IPL_BASIC);
-      if ((residue.status() == SS_FAILED) || !residue.p.assigned() ||
-          (residue.p.val() != 13))
-        return false;
+  /// Larger instances with a bounded total slack
+  class Random : public Test {
+  protected:
+    int p;
+    bool variable;
+  public:
+    Random(int n, int p0, int slack, bool v, Gecode::IntPropLevel level)
+      : Test("InterDistance::Random::"+str(n)+"::"+str(p0)+"::"+
+             str(slack)+"::"+str(v)+"::"+str(level),
+             n+static_cast<int>(v),0,(n-1)*p0+slack,false,level),
+        p(p0), variable(v) {
+      testsearch = false;
+    }
+    virtual Assignment* assignment(void) const {
+      return new DistanceAssignment(arity,dom,p,variable,_rand);
+    }
+    virtual bool solution(const Assignment& x) const {
+      int n = x.size()-static_cast<int>(variable);
+      int distance = variable ? x[n] : p;
+      for (int i=0; i<n; i++)
+        for (int j=0; j<i; j++)
+          if (std::abs(x[i]-x[j]) < distance)
+            return false;
+      return true;
+    }
+    virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
+      Gecode::IntVarArgs y(x.size()-static_cast<int>(variable));
+      for (int i=0; i<y.size(); i++)
+        y[i] = x[i];
+      if (variable)
+        Gecode::inter_distance(home,y,x[y.size()],ipl);
+      else
+        Gecode::inter_distance(home,y,p,ipl);
+    }
+  };
 
-      // Adjacent forbidden regions limit separation to six, not seven.
-      Domains adjacent(3);
-      for (int v=1; v<=17; v++) adjacent[0].push_back(v);
-      for (int v=5; v<=8; v++) adjacent[1].push_back(v);
-      for (int v=2; v<=14; v++) adjacent[2].push_back(v);
-      for (IntPropLevel ipl : {IPL_BASIC,IPL_ADVANCED,IPL_BASIC_ADVANCED}) {
-        Model model(adjacent,{0,1,2,3,4,5,6,7,8});
-        inter_distance(model,model.x,model.p,ipl);
-        if ((model.status() == SS_FAILED) || (model.p.max() != 6))
-          return false;
+  /// Enumerate assignments within each example's individual variable domains
+  class ExampleAssignment : public Assignment {
+    Gecode::IntSet domains[6];
+    Gecode::IntSetValues values[6];
+  public:
+    ExampleAssignment(int n, const Gecode::IntSet* d)
+      : Assignment(n,Gecode::IntSet()) {
+      for (int i=0; i<n; i++) {
+        domains[i] = d[i];
+        values[i].init(domains[i]);
       }
-
-      // Deadlines can extend beyond the representable integer domain.
-      const int limit = Gecode::Int::Limits::max;
-      Model extremes({{-limit,-limit+1},{0,1},{limit-1,limit}});
-      inter_distance(extremes,extremes.x,limit);
-      return (extremes.status() != SS_FAILED) && extremes.x.assigned() &&
-        (extremes.x[0].val() == -limit) && (extremes.x[1].val() == 0) &&
-        (extremes.x[2].val() == limit);
     }
-
-    static bool distance_updates(void) {
-      // Raise the minimum distance in a clone after an initial fixpoint.
-      // Both p's subscription and staging must survive cloning.
-      Domains paper = {{2,3,4,5,6},
-        {10,11,12,13,14},{4,5,6,7,8,9,10,11,12,13,14,15}};
-      Model m(paper,{0,1,2,3,4,5,6,7,8});
-      Gecode::inter_distance(m,m.x,m.p);
-      if ((m.status() == Gecode::SS_FAILED) || (m.p.max() != 6))
-        return false;
-      Model* clone = static_cast<Model*>(m.clone());
-      Gecode::rel(*clone,clone->p,Gecode::IRT_GQ,6);
-      bool correct = clone->status() != Gecode::SS_FAILED;
-      correct &= clone->p.assigned() && (clone->p.val() == 6);
-      correct &= clone->x.assigned() && (clone->x[0].val() == 2) &&
-        (clone->x[1].val() == 14) && (clone->x[2].val() == 8);
-      correct &= (m.p.min() == 0) && !m.x.assigned();
-      delete clone;
-      if (!correct)
-        return false;
-
-      Model basic(paper,{6,7,8});
-      Gecode::inter_distance(basic,basic.x,basic.p,Gecode::IPL_BASIC);
-      if ((basic.status() == Gecode::SS_FAILED) || !basic.p.assigned() ||
-          (basic.p.val() != 6) ||
-          (basic.x[0].min() != 2) || (basic.x[0].max() != 6))
-        return false;
-
-      // Assigning p to one must immediately rewrite to distinct, so a
-      // newly posted constraint cannot prune further at the same fixpoint.
-      Model unit({{-2},{-2,-1}},{1,3});
-      Gecode::inter_distance(unit,unit.x,unit.p,Gecode::IPL_BASIC);
-      return (unit.status() != Gecode::SS_FAILED) && unit.p.assigned() &&
-        (unit.p.val() == 1) && unit.x[1].assigned() && (unit.x[1].val() == -1);
+    virtual bool has_more(void) const {
+      return values[0]();
+    }
+    virtual void next(Gecode::Support::RandomGenerator&) {
+      int i = n-1;
+      while (true) {
+        ++values[i];
+        if (values[i]() || (i == 0))
+          return;
+        values[i--].init(domains[i]);
+      }
+    }
+    virtual int operator[](int i) const {
+      return values[i].val();
     }
+  };
+
+  /// Hole-jump and residue examples use the same assignment checks
+  class Examples : public Test {
+  protected:
+    Gecode::IntSet domains[6];
   public:
-    Regression(void)
-      : Base("Int::InterDistance::Regression",TestTags::check()) {}
-    virtual bool run(void) {
-      return regressions() && distance_updates();
+    Examples(const std::string& name, int n, const Gecode::IntSet& domain,
+             const Gecode::IntSet* d, Gecode::IntPropLevel level)
+      : Test(TestTags::check(),"InterDistance::"+name+"::"+str(level),
+             n,domain,false,level) {
+      for (int i=0; i<n; i++)
+        domains[i] = d[i];
+      testsearch = false;
+    }
+    virtual Assignment* assignment(void) const {
+      return new ExampleAssignment(arity,domains);
+    }
+    virtual bool solution(const Assignment& x) const {
+      for (int i=0; i<x.size(); i++)
+        if (!domains[i].in(x[i]))
+          return false;
+      int p = x[x.size()-1];
+      for (int i=0; i<x.size()-1; i++)
+        for (int j=0; j<i; j++) {
+          long long int d = static_cast<long long int>(x[i])-x[j];
+          if ((-p < d) && (d < p))
+            return false;
+        }
+      return true;
+    }
+    virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
+      for (int i=0; i<x.size(); i++)
+        Gecode::dom(home,x[i],domains[i]);
+      Gecode::IntVarArgs y(x.size()-1);
+      for (int i=0; i<y.size(); i++)
+        y[i] = x[i];
+      Gecode::inter_distance(home,y,x[x.size()-1],ipl);
     }
   };
 
   /// Posting contracts, vacuous constraints, and shared variables
   class Posting : public Base {
-    class Model : public Gecode::Space {
-    public:
-      Model(void) {}
-      Model(Model& s) : Gecode::Space(s) {}
-      virtual Gecode::Space* copy(void) {
-        return new Model(*this);
-      }
-    };
     static bool constant_contracts(void) {
       using namespace Gecode;
-      Model s;
+      IntSet domain(-2,2);
+      TestSpace s(0,domain,nullptr);
       IntVar v(s,-2,2);
       IntVarArgs duplicate(2);
       duplicate[0] = duplicate[1] = v;
@@ -265,7 +271,7 @@ namespace Test { namespace Int { namespace InterDistance {
       if (!same || !negative || !tooLarge || (s.status() == SS_FAILED))
         return false;
 
-      Model t;
+      TestSpace t(0,domain,nullptr);
       IntVar assigned(t,3,3);
       duplicate[0] = duplicate[1] = assigned;
       inter_distance(t,duplicate,2);
@@ -276,19 +282,20 @@ namespace Test { namespace Int { namespace InterDistance {
 
     static bool variable_contracts(void) {
       using namespace Gecode;
-      Model empty;
+      IntSet domain(-3,9);
+      TestSpace empty(0,domain,nullptr);
       IntVar distance(empty,-3,9);
       inter_distance(empty,IntVarArgs(),distance);
       if ((empty.status() == SS_FAILED) || (distance.min() != 0))
         return false;
 
-      Model negativeDistance;
+      TestSpace negativeDistance(0,domain,nullptr);
       IntVar negativeVar(negativeDistance,-3,-1);
       inter_distance(negativeDistance,IntVarArgs(),negativeVar);
       if (negativeDistance.status() != SS_FAILED)
         return false;
 
-      Model shared;
+      TestSpace shared(0,domain,nullptr);
       IntVar a(shared,0,9);
       IntVar b(shared,0,9);
       IntVar p(shared,0,9);
@@ -313,29 +320,6 @@ namespace Test { namespace Int { namespace InterDistance {
       return true;
     }
 
-    static bool large_distances(void) {
-      using namespace Gecode;
-      // A wide search interval exercises binary search and integer limits.
-      Model wide;
-      const int limit = Gecode::Int::Limits::max;
-      IntVarArgs x(3);
-      x[0] = IntVar(wide,0,limit/4);
-      x[1] = IntVar(wide,0,limit/4);
-      x[2] = IntVar(wide,limit-1,limit);
-      IntVar separation(wide,0,limit);
-      inter_distance(wide,x,separation,IPL_BASIC);
-      if ((wide.status() == SS_FAILED) || (separation.max() != limit/4))
-        return false;
-
-      // The assigned gap can exceed the representable distance domain.
-      Model extremes;
-      IntVarArgs pair(2);
-      pair[0] = IntVar(extremes,-limit,-limit);
-      pair[1] = IntVar(extremes,limit,limit);
-      IntVar large(extremes,0,limit);
-      inter_distance(extremes,pair,large);
-      return (extremes.status() != SS_FAILED) && (large.max() == limit);
-    }
   public:
     Posting(void) : Base("Int::InterDistance::Posting",TestTags::check()) {}
     virtual bool run(void) {
@@ -347,10 +331,6 @@ namespace Test { namespace Int { namespace InterDistance {
         olog << "Variable posting contracts failed" << std::endl;
         return false;
       }
-      if (!large_distances()) {
-        olog << "Large-distance arithmetic failed" << std::endl;
-        return false;
-      }
       return true;
     }
   };
@@ -358,6 +338,34 @@ namespace Test { namespace Int { namespace InterDistance {
   class Create {
   public:
     Create(void) {
+      using namespace Gecode;
+      for (IntPropLevel level : {IPL_BASIC,IPL_ADVANCED,IPL_BASIC_ADVANCED}) {
+        for (int n : {8,24})
+          for (int slack : {0,8})
+            for (bool variable : {false,true})
+              (void) new Random(n,3,slack,variable,level);
+        const IntSet paper[] = {IntSet(2,6),IntSet(10,14),
+                                IntSet(4,15),IntSet(0,8)};
+        (void) new Examples("Paper",4,IntSet(0,15),paper,level);
+        const IntSet adjacent[] = {IntSet(1,17),IntSet(5,8),
+                                   IntSet(2,14),IntSet(0,8)};
+        (void) new Examples("Adjacent",4,IntSet(0,17),adjacent,level);
+        const IntSet holes[] = {IntSet({0,2,6,7}),IntSet({-3,2}),
+          IntSet({10,11,14}),IntSet({1,2,3,6}),IntSet({-1,0,3,5,9}),
+          IntSet(4,4)};
+        (void) new Examples("HoleJump",6,IntSet(-3,14),holes,level);
+        const IntSet residue[] = {IntSet(2,11),IntSet(-10,-2),
+                                  IntSet(16,17),IntSet(13,14)};
+        (void) new Examples("Residue",4,IntSet(-10,17),residue,level);
+      }
+      const int limit = Gecode::Int::Limits::max;
+      const IntSet extremes[] = {IntSet(-limit,-limit+1),IntSet(0,1),
+                                 IntSet(limit-1,limit),IntSet(limit-1,limit)};
+      (void) new Examples("Limits",4,
+                         IntSet({-limit,-limit+1,0,1,limit-1,limit}),
+                         extremes,IPL_BASIC);
+      (void) new Distance(3,limit,IntSet({-limit,-limit+1,0,1,
+                                        limit-1,limit}));
       for (int n=1; n<=4; n++)
         for (int p=0; p<=4; p++)
           (void) new Distance(n,p,-3,3);
@@ -380,7 +388,6 @@ namespace Test { namespace Int { namespace InterDistance {
         Gecode::IPL_BND | Gecode::IPL_BASIC));
     }
   } create;
-  Regression regression;
   Posting posting;
 
 }}}