fix(interval): intersect overlapping and touching intervals correctly

QwtInterval.intersect (and the `&` operator) returned an invalid interval
for partially overlapping intervals, e.g. QwtInterval(0, 2) &
QwtInterval(1, 3), and for intervals sharing an included bound: after
ordering the intervals by their minimum, it tested
`i1.maxValue() < i2.maxValue()` instead of `i1.maxValue() < i2.minValue()`
(Qwt C++).

QwtInterval.intersects gave the opposite result for intervals sharing a
bound: `[0, 1]` and `[1, 2]` did not intersect, while `[0, 1)` and
`(1, 2]` did. Qwt C++ returns
`!(i1 excludes its maximum || i2 excludes its minimum)`.

- Restore the Qwt C++ conditions; intersects now always returns a bool.
- Results which were already valid are unchanged: checked on all the
  4096 pairs of intervals with bounds in 0..3 and any border flags
  (including invalid intervals), both methods now match a direct
  transcription of the Qwt C++ code.
- Regression tests: table of overlapping, nested, equal, disjoint and
  touching intervals with various border flags, in both orders, with
  `intersect` and `&`; `intersects` cases; invalid intervals.
- Changelog entry.

Refs #115

Assisted-by: Claude Opus 5.5

Author: PierreRaybaut

CHANGELOG.md

@@ -19,6 +19,7 @@
 - Fixed `QwtDynGridLayout` (used by `QwtLegend`), whose `numRows()` returned a float (e.g. `2.5` for 3 items on 2 columns) and which raised a `TypeError` when laying out its items with vertical expansion (`setExpandingDirections(Qt.Vertical)`) ([Issue #115](https://github.com/PlotPyStack/PythonQwt/issues/115))
 - Fixed canvas style sheets with rounded borders (e.g. `plot.canvas().setStyleSheet("border: 2px solid black; border-radius: 8px;")`), which raised a `TypeError` on each style change, resize and paint event (aborting the process with PyQt's default exception hook): the rounded border of the style sheet is now taken into account to clip the plot items and to fill the corners with the background of the parent widget, as in Qwt ([Issue #115](https://github.com/PlotPyStack/PythonQwt/issues/115))
 - Fixed the image formats listed by the file dialog of `QwtPlotRenderer.exportTo`, which read `*.b'bmp' *.b'png' ...` instead of `*.bmp *.png ...` ([Issue #115](https://github.com/PlotPyStack/PythonQwt/issues/115))
+- Fixed `QwtInterval.intersect` (and the `&` operator), which returned an invalid interval for partially overlapping intervals (e.g. `QwtInterval(0, 2) & QwtInterval(1, 3)` instead of `[1, 2]`), and `QwtInterval.intersects`, which gave the opposite result for intervals sharing a bound (e.g. `False` for `[0, 1]` and `[1, 2]`) ([Issue #115](https://github.com/PlotPyStack/PythonQwt/issues/115))
 
 ## Version 0.16.3
 

qwt/interval.py

@@ -296,7 +296,7 @@ def intersect(self, other):
             if i1.borderFlags() & self.ExcludeMinimum:
                 i1, i2 = i2, i1
 
-        if i1.maxValue() < i2.maxValue():
+        if i1.maxValue() < i2.minValue():
             return QwtInterval()
 
         if i1.maxValue() == i2.minValue():
@@ -346,9 +346,9 @@ def intersects(self, other):
         if i1.maxValue() > i2.minValue():
             return True
         elif i1.maxValue() == i2.minValue():
-            return (
+            return not (
                 i1.borderFlags() & self.ExcludeMaximum
-                and i2.borderFlags() & self.ExcludeMinimum
+                or i2.borderFlags() & self.ExcludeMinimum
             )
         return False
 

qwt/tests/test_issue115_porting_bugs.py

@@ -23,6 +23,7 @@
 
 import qwt.plot_renderer
 from qwt import (
+    QwtInterval,
     QwtLegend,
     QwtLinearScaleEngine,
     QwtPlot,
@@ -663,6 +664,78 @@ def fake_getsavefilename(*args, **kwargs):
     del app
 
 
+# ---------------------------------------------------------------------------
+# QwtInterval.intersect / QwtInterval.intersects
+# ---------------------------------------------------------------------------
+
+INC = QwtInterval.IncludeBorders
+EXC_MIN = QwtInterval.ExcludeMinimum
+EXC_MAX = QwtInterval.ExcludeMaximum
+
+# (interval 1, interval 2, expected intersection or None if invalid),
+# intervals being (min, max, border flags); expected values follow Qwt C++
+INTERSECT_CASES = (
+    ((0, 2, INC), (1, 3, INC), (1, 2, INC)),
+    ((1, 3, INC), (0, 2, INC), (1, 2, INC)),
+    ((0, 3, INC), (1, 2, INC), (1, 2, INC)),
+    ((0, 2, INC), (0, 2, INC), (0, 2, INC)),
+    ((0, 1, INC), (2, 3, INC), None),
+    ((0, 1, INC), (1, 2, INC), (1, 1, INC)),
+    ((0, 1, EXC_MAX), (1, 2, INC), None),
+    ((0, 1, INC), (1, 2, EXC_MIN), None),
+    ((0, 2, EXC_MIN), (1, 3, EXC_MAX), (1, 2, INC)),
+    ((0, 2, EXC_MAX), (1, 3, INC), (1, 2, EXC_MAX)),
+    ((0, 2, INC), (0, 1, EXC_MIN), (0, 1, EXC_MIN)),
+)
+
+
+def _interval(values):
+    return QwtInterval(*values)
+
+
+@pytest.mark.parametrize("values1, values2, expected", INTERSECT_CASES)
+def test_interval_intersect(values1, values2, expected):
+    """QwtInterval.intersect and `&` return the intersection of two intervals"""
+    interval1, interval2 = _interval(values1), _interval(values2)
+    for result in (interval1.intersect(interval2), interval1 & interval2):
+        if expected is None:
+            assert not result.isValid()
+        else:
+            assert result == _interval(expected)
+
+
+def test_interval_intersect_invalid():
+    """The intersection with an invalid interval is invalid"""
+    assert not QwtInterval().intersect(QwtInterval(0, 1)).isValid()
+    assert not QwtInterval(0, 1).intersect(QwtInterval()).isValid()
+
+
+@pytest.mark.parametrize(
+    "values1, values2, expected",
+    (
+        ((0, 2, INC), (1, 3, INC), True),
+        ((1, 3, INC), (0, 2, INC), True),
+        ((0, 3, INC), (1, 2, INC), True),
+        ((0, 1, INC), (2, 3, INC), False),
+        ((0, 1, INC), (1, 2, INC), True),
+        ((1, 2, INC), (0, 1, INC), True),
+        ((0, 1, EXC_MAX), (1, 2, INC), False),
+        ((0, 1, INC), (1, 2, EXC_MIN), False),
+        ((0, 1, EXC_MAX), (1, 2, EXC_MIN), False),
+    ),
+)
+def test_interval_intersects(values1, values2, expected):
+    """QwtInterval.intersects tells whether two intervals overlap"""
+    result = _interval(values1).intersects(_interval(values2))
+    assert result is expected
+
+
+def test_interval_intersects_invalid():
+    """An invalid interval does not intersect any interval"""
+    assert QwtInterval().intersects(QwtInterval(0, 1)) is False
+    assert QwtInterval(0, 1).intersects(QwtInterval()) is False
+
+
 if __name__ == "__main__":
     for name in ("toPixmap", "toImage"):
         test_graphic_conversion_default_size(name)
@@ -686,4 +759,8 @@ def fake_getsavefilename(*args, **kwargs):
     for sheet in ROUNDED_STYLE_SHEETS:
         for backing in (False, True):
             test_canvas_rounded_style_sheet(sheet, backing)
+    for values1, values2, expected in INTERSECT_CASES:
+        test_interval_intersect(values1, values2, expected)
+    test_interval_intersect_invalid()
+    test_interval_intersects_invalid()
     print("OK")