gh-150318: Fix quantiles(method='exclusive') returning unsorted cut points for duplicate floats

Lib/statistics.py

@@ -1206,7 +1206,13 @@ def quantiles(data, *, n=4, method='exclusive'):
         result = []
         for i in range(1, n):
             j, delta = divmod(i * m, n)
-            interpolated = (data[j] * (n - delta) + data[j + 1] * delta) / n
+            a, b = data[j], data[j + 1]
+            if a == b and type(a) is type(b):
+                interpolated = a / 1
+            elif 2 * delta <= n:
+                interpolated = a + (b - a) * delta / n
+            else:
+                interpolated = b - (b - a) * (n - delta) / n
             result.append(interpolated)
         return result
 
@@ -1217,7 +1223,13 @@ def quantiles(data, *, n=4, method='exclusive'):
             j = i * m // n                               # rescale i to m/n
             j = 1 if j < 1 else ld-1 if j > ld-1 else j  # clamp to 1 .. ld-1
             delta = i*m - j*n                            # exact integer math
-            interpolated = (data[j - 1] * (n - delta) + data[j] * delta) / n
+            a, b = data[j - 1], data[j]
+            if a == b and type(a) is type(b):
+                interpolated = a / 1
+            elif 2 * delta <= n:
+                interpolated = a + (b - a) * delta / n
+            else:
+                interpolated = b - (b - a) * (n - delta) / n
             result.append(interpolated)
         return result
 

Lib/test/test_statistics.py

@@ -2647,6 +2647,42 @@ def test_equal_inputs(self):
             self.assertEqual(quantiles(data, method='inclusive'),
                             [10.0, 10.0, 10.0])
 
+    def test_monotonic_with_duplicate_floats(self):
+        quantiles = statistics.quantiles
+        for x in (3.141592653589793,  # irrational-ish
+                  1/3,                # repeating binary fraction
+                  0.1,                # non-exact decimal
+                  2.0,                # exact power of two
+                  1e300,              # large magnitude
+                  1e-300,             # small magnitude
+                  float.fromhex('0x1.fffffffffffffp+1023'),  # near max float
+                  sys.float_info.min, # smallest normal
+                  float('inf'),
+                  float('-inf'),
+                  ):
+            for method in ('exclusive', 'inclusive'):
+                for n in range(2, 20):
+                    with self.subTest(x=x, n=n, method=method):
+                        result = quantiles([x, x], n=n, method=method)
+                        self.assertEqual(result, sorted(result))
+                        self.assertTrue(all(v == x for v in result))
+
+        result = quantiles([0.09999999999999999, 0.1, 0.1],
+                           n=9, method='inclusive')
+        self.assertEqual(result, sorted(result))
+
+    def test_mixed_types(self):
+        data = [Fraction(1, 2), 0.5, 2.0]
+        for method, expected in [
+            ('inclusive', [0.5, 0.5, 0.8, 1.4]),
+            ('exclusive', [0.5, 0.5, 1.1, 2.3]),
+        ]:
+            with self.subTest(method=method):
+                self.assertEqual(
+                    statistics.quantiles(data, n=5, method=method),
+                    expected,
+                )
+
     def test_equal_sized_groups(self):
         quantiles = statistics.quantiles
         total = 10_000

Misc/NEWS.d/next/Library/2026-05-23-23-14-26.gh-issue-150318.Utah1I.rst

@@ -0,0 +1,2 @@
+Fix :func:`statistics.quantiles` returning unsorted cut points for duplicate
+floats.