Use nextafter to fuzz around floating point break points

Author: has2k1

plotnine/_utils/__init__.py

@@ -1207,3 +1207,24 @@ def has_alpha_channel(c: str | tuple) -> bool:
         return c.startswith("#") and len(c) == 9
     else:
         return color_utils.is_color_tuple(c) and len(c) == 4
+
+
+def nextafter_range(rng: tuple[float, float]) -> tuple[float, float]:
+    """
+    Expand floating-point range by a step to adjacent representable numbers
+
+    Parameters
+    ----------
+    rng :
+        A tuple (min, max) representing the range to expand.
+
+    Returns
+    -------
+    :
+        A new tuple (lower, upper) where,
+        - lower is moved 1 float toward -∞
+        - upper is moved 1 float toward +∞
+    """
+    from math import inf, nextafter
+
+    return (nextafter(rng[0], -inf), nextafter(rng[1], inf))

plotnine/stats/binning.py

@@ -82,13 +82,12 @@ def breaks_from_binwidth(
         if center is not None:
             boundary = center - boundary
 
-    epsilon = np.finfo(float).eps
     shift = np.floor((x_range[0] - boundary) / binwidth)
     origin = boundary + shift * binwidth
-    # The (1-epsilon) factor prevents numerical roundoff in the
+    # The nextafter reduction prevents numerical roundoff in the
     # binwidth from creating an extra break beyond the one that
     # includes x_range[1].
-    max_x = x_range[1] + binwidth * (1 - epsilon)
+    max_x = np.nextafter(x_range[1] + binwidth, -np.inf)
     breaks = np.arange(origin, max_x, binwidth)
     return breaks
 
@@ -303,48 +302,21 @@ def fuzzybreaks(
 
     # To minimise precision errors, we do not pass the boundary and
     # binwidth into np.arange as params. The resulting breaks
-    # can then be adjusted with finer(epsilon based rather than
-    # some arbitrary small number) precision.
+    # can then be adjusted to the next floating point number.
     breaks = np.arange(boundary, srange[1] + binwidth, binwidth)
     return _adjust_breaks(breaks, right)
 
 
 def _adjust_breaks(breaks: FloatArray, right: bool) -> FloatArray:
-    epsilon = np.finfo(float).eps
-    plus = 1 + epsilon
-    minus = 1 - epsilon
-
-    sign = np.sign(breaks)
-    pos_idx = np.where(sign == 1)[0]
-    neg_idx = np.where(sign == -1)[0]
-    zero_idx = np.where(sign == 0)[0]
-
-    fuzzy = breaks.copy()
-    if right:
-        # [_](_](_](_]
-        lbreak = breaks[0]
-        fuzzy[pos_idx] *= plus
-        fuzzy[neg_idx] *= minus
-        fuzzy[zero_idx] = epsilon
-        # Left closing break
-        if lbreak == 0:
-            fuzzy[0] = -epsilon
-        elif lbreak < 0:
-            fuzzy[0] = lbreak * plus
-        else:
-            fuzzy[0] = lbreak * minus
-    else:
-        # [_)[_)[_)[_]
-        rbreak = breaks[-1]
-        fuzzy[pos_idx] *= minus
-        fuzzy[neg_idx] *= plus
-        fuzzy[zero_idx] = -epsilon
-        # Right closing break
-        if rbreak == 0:
-            fuzzy[-1] = epsilon
-        elif rbreak > 0:
-            fuzzy[-1] = rbreak * plus
-        else:
-            fuzzy[-1] = rbreak * minus
+    """
+    Adjust breaks to include/exclude every right break
 
+    If right=True, the breaks create intervals closed on right
+    i.e. [_] (_] (_] (_]
+    If right=False, the breaks create intervals closed on the left
+    i.e. [_) [_) [_) [_]
+    """
+    limit, idx = (np.inf, 0) if right else (-np.inf, -1)
+    fuzzy = np.nextafter(breaks, limit)
+    fuzzy[idx] = np.nextafter(breaks[idx], -limit)
     return fuzzy

plotnine/stats/stat_sina.py

@@ -3,7 +3,7 @@
 import numpy as np
 import pandas as pd
 
-from .._utils import array_kind, jitter, resolution
+from .._utils import array_kind, jitter, nextafter_range, resolution
 from ..doctools import document
 from ..exceptions import PlotnineError
 from ..mapping.aes import has_groups
@@ -222,13 +222,11 @@ def compute_group(self, data, scales):
             data["density"] = densf(y)
             data["scaled"] = data["density"] / dens["density"].max()
         else:
-            y_dim = scales.y.dimension()
-            fuzz = 1e-8
-            y_dim_fuzzed = (y_dim[0] - fuzz, y_dim[1] + fuzz)
+            expanded_y_range = nextafter_range(scales.y.dimension())
             if binwidth is not None:
-                bins = breaks_from_binwidth(y_dim_fuzzed, binwidth)
+                bins = breaks_from_binwidth(expanded_y_range, binwidth)
             else:
-                bins = breaks_from_bins(y_dim_fuzzed, self.params["bins"])
+                bins = breaks_from_bins(expanded_y_range, self.params["bins"])
 
             # bin based estimation
             bin_index = pd.cut(y, bins, include_lowest=True, labels=False)  # pyright: ignore[reportCallIssue,reportArgumentType]