Improve tick subsampling in LogLocator.

anntzer · anntzer · commit 667abd1fb936 · 2025-03-07T17:46:31.000+01:00
Rewrite the logic for subsampling log-scale ticks, so that

1) there's as many ticks as possible without going over numticks (don't
   draw a single tick when two would fit);

2) the ticks are spaced as much as possible (when two ticks are drawn,
   put them on the lowest and highest decade, not somewhere midway);

3) if possible, draw ticks on integer multiples of the stride (0, 3, 9
   is better than 1, 4, 7).

See comments in implementation for details.

For the backcompat-oriented "classic-mode", remove the "stride &gt;=
numdec" check (which is a much later addition).

Test changes:

- changes because tick_values() now returns exactly one major ticks
  outside of the (vmin, vmax) range on both sides: TestLogLocator,
  test_axes::test_auto_numticks_log, test_colorbar::test_colorbar_renorm.
- test_small_range_loglocator was likely previously wrong (the assert
  did not cover the values of ticks, and all iterations of the loop
  ended up testing the same condition).  Rewrite it fully (in particular
  to cover the new implementation).

to be handled:

test_colorbar::test_colorbar_autotickslog: test is weird, values change
after triggering a draw anyways...
test_contour::test_contourf_log_extension: edge bins can now be wider
to respect stride, due to not starting at floor(log(vmin)) anymore...
diff --git a/lib/matplotlib/tests/test_axes.py b/lib/matplotlib/tests/test_axes.py
@@ -7003,6 +7003,7 @@ def test_loglog_nonpos():
                 ax.set_xscale("log", nonpositive=mcx)
             if mcy:
                 ax.set_yscale("log", nonpositive=mcy)
+        ax.set_yticks([1e3, 1e7])  # Backcompat tick selection.
 
 
 @mpl.style.context('default')
@@ -7132,8 +7133,8 @@ def test_auto_numticks_log():
     fig, ax = plt.subplots()
     mpl.rcParams['axes.autolimit_mode'] = 'round_numbers'
     ax.loglog([1e-20, 1e5], [1e-16, 10])
-    assert (np.log10(ax.get_xticks()) == np.arange(-26, 18, 4)).all()
-    assert (np.log10(ax.get_yticks()) == np.arange(-20, 10, 3)).all()
+    assert_array_equal(np.log10(ax.get_xticks()), np.arange(-26, 11, 4))
+    assert_array_equal(np.log10(ax.get_yticks()), np.arange(-20, 5, 3))
 
 
 def test_broken_barh_empty():
diff --git a/lib/matplotlib/tests/test_colorbar.py b/lib/matplotlib/tests/test_colorbar.py
@@ -597,7 +597,7 @@ def test_colorbar_renorm():
     norm = LogNorm(z.min(), z.max())
     im.set_norm(norm)
     np.testing.assert_allclose(cbar.ax.yaxis.get_majorticklocs(),
-                               np.logspace(-10, 7, 18))
+                               np.logspace(-9, 6, 16))
     # note that set_norm removes the FixedLocator...
     assert np.isclose(cbar.vmin, z.min())
     cbar.set_ticks([1, 2, 3])
diff --git a/lib/matplotlib/tests/test_scale.py b/lib/matplotlib/tests/test_scale.py
@@ -107,7 +107,8 @@ def test_logscale_mask():
     fig, ax = plt.subplots()
     ax.plot(np.exp(-xs**2))
     fig.canvas.draw()
-    ax.set(yscale="log")
+    ax.set(yscale="log",
+           yticks=10.**np.arange(-300, 0, 24))  # Backcompat tick selection.
 
 
 def test_extra_kwargs_raise():
@@ -162,6 +163,7 @@ def test_logscale_nonpos_values():
 
     ax4.set_yscale('log')
     ax4.set_xscale('log')
+    ax4.set_yticks([1e-2, 1, 1e+2])  # Backcompat tick selection.
 
 
 def test_invalid_log_lims():
diff --git a/lib/matplotlib/tests/test_ticker.py b/lib/matplotlib/tests/test_ticker.py
@@ -332,13 +332,11 @@ def test_basic(self):
         with pytest.raises(ValueError):
             loc.tick_values(0, 1000)
 
-        test_value = np.array([1.00000000e-05, 1.00000000e-03, 1.00000000e-01,
-                               1.00000000e+01, 1.00000000e+03, 1.00000000e+05,
-                               1.00000000e+07, 1.000000000e+09])
+        test_value = np.array([1e-5, 1e-3, 1e-1, 1e+1, 1e+3, 1e+5, 1e+7])
         assert_almost_equal(loc.tick_values(0.001, 1.1e5), test_value)
 
         loc = mticker.LogLocator(base=2)
-        test_value = np.array([0.5, 1., 2., 4., 8., 16., 32., 64., 128., 256.])
+        test_value = np.array([.5, 1., 2., 4., 8., 16., 32., 64., 128.])
         assert_almost_equal(loc.tick_values(1, 100), test_value)
 
     def test_polar_axes(self):
@@ -377,7 +375,7 @@ def test_tick_values_correct(self):
                                1.e+01, 2.e+01, 5.e+01, 1.e+02, 2.e+02, 5.e+02,
                                1.e+03, 2.e+03, 5.e+03, 1.e+04, 2.e+04, 5.e+04,
                                1.e+05, 2.e+05, 5.e+05, 1.e+06, 2.e+06, 5.e+06,
-                               1.e+07, 2.e+07, 5.e+07, 1.e+08, 2.e+08, 5.e+08])
+                               1.e+07, 2.e+07, 5.e+07])
         assert_almost_equal(ll.tick_values(1, 1e7), test_value)
 
     def test_tick_values_not_empty(self):
@@ -387,8 +385,7 @@ def test_tick_values_not_empty(self):
                                1.e+01, 2.e+01, 5.e+01, 1.e+02, 2.e+02, 5.e+02,
                                1.e+03, 2.e+03, 5.e+03, 1.e+04, 2.e+04, 5.e+04,
                                1.e+05, 2.e+05, 5.e+05, 1.e+06, 2.e+06, 5.e+06,
-                               1.e+07, 2.e+07, 5.e+07, 1.e+08, 2.e+08, 5.e+08,
-                               1.e+09, 2.e+09, 5.e+09])
+                               1.e+07, 2.e+07, 5.e+07, 1.e+08, 2.e+08, 5.e+08])
         assert_almost_equal(ll.tick_values(1, 1e8), test_value)
 
     def test_multiple_shared_axes(self):
@@ -1913,14 +1910,47 @@ def test_bad_locator_subs(sub):
         ll.set_params(subs=sub)
 
 
-@pytest.mark.parametrize('numticks', [1, 2, 3, 9])
+@pytest.mark.parametrize("numticks, lims, ticks", [
+    (1, (.5, 5), [.1, 1, 10]),
+    (2, (.5, 5), [.1, 1, 10]),
+    (3, (.5, 5), [.1, 1, 10]),
+    (9, (.5, 5), [.1, 1, 10]),
+    (1, (.5, 50), [.1, 10, 1_000]),
+    (2, (.5, 50), [.1, 1, 10, 100]),
+    (3, (.5, 50), [.1, 1, 10, 100]),
+    (9, (.5, 50), [.1, 1, 10, 100]),
+    (1, (.5, 500), [.1, 10, 1_000]),
+    (2, (.5, 500), [.01, 1, 100, 10_000]),
+    (3, (.5, 500), [.1, 1, 10, 100, 1_000]),
+    (9, (.5, 500), [.1, 1, 10, 100, 1_000]),
+    (1, (.5, 5000), [.1, 100, 100_000]),
+    (2, (.5, 5000), [.001, 1, 1_000, 1_000_000]),
+    (3, (.5, 5000), [.001, 1, 1_000, 1_000_000]),
+    (9, (.5, 5000), [.1, 1, 10, 100, 1_000, 10_000]),
+])
 @mpl.style.context('default')
-def test_small_range_loglocator(numticks):
-    ll = mticker.LogLocator()
-    ll.set_params(numticks=numticks)
-    for top in [5, 7, 9, 11, 15, 50, 100, 1000]:
-        ticks = ll.tick_values(.5, top)
-        assert (np.diff(np.log10(ll.tick_values(6, 150))) == 1).all()
+def test_small_range_loglocator(numticks, lims, ticks):
+    ll = mticker.LogLocator(numticks=numticks)
+    assert_array_equal(ll.tick_values(*lims), ticks)
+
+
+@mpl.style.context('default')
+def test_loglocator_properties():
+    max_numticks = 8
+    pow_end = 20
+    for numticks, (lo, hi) in itertools.product(
+            range(1, max_numticks + 1), itertools.combinations(range(pow_end), 2)):
+        ll = mticker.LogLocator(numticks=numticks)
+        decades = np.log10(ll.tick_values(10**lo, 10**hi)).round().astype(int)
+        assert len(decades) <= numticks + 2  # 1 extra tick on each side.
+        assert decades[0] < lo <= decades[1]
+        assert decades[-2] <= hi < decades[-1]
+        stride, = {*np.diff(decades)}  # Constant stride.
+        # Either aligned on stride integer multiples, or no solution.
+        if not (decades % stride == 0).all():
+            for offset in range(0, stride):
+                alt_decades = range(lo + offset, hi + 1, stride)
+                assert len(alt_decades) < len(decades) or len(alt_decades) > numticks
 
 
 def test_NullFormatter():
diff --git a/lib/matplotlib/ticker.py b/lib/matplotlib/ticker.py
@@ -2403,14 +2403,22 @@ def __call__(self):
         vmin, vmax = self.axis.get_view_interval()
         return self.tick_values(vmin, vmax)
 
+    def _log_b(self, x):
+        # Use specialized logs if possible, as they can be more accurate; e.g.
+        # log(.001) / log(10) = -2.999... (whether math.log or np.log) due to
+        # floating point error.
+        return (np.log10(x) if self._base == 10 else
+                np.log2(x) if self._base == 2 else
+                np.log(x) / np.log(self._base))
+
     def tick_values(self, vmin, vmax):
         if self.numticks == 'auto':
             if self.axis is not None:
-                numticks = np.clip(self.axis.get_tick_space(), 2, 9)
+                nt = np.clip(self.axis.get_tick_space(), 2, 9)
             else:
-                numticks = 9
+                nt = 9
         else:
-            numticks = self.numticks
+            nt = self.numticks
 
         b = self._base
         if vmin <= 0.0:
@@ -2421,17 +2429,17 @@ def tick_values(self, vmin, vmax):
                 raise ValueError(
                     "Data has no positive values, and therefore cannot be log-scaled.")
 
-        _log.debug('vmin %s vmax %s', vmin, vmax)
-
         if vmax < vmin:
             vmin, vmax = vmax, vmin
-        log_vmin = math.log(vmin) / math.log(b)
-        log_vmax = math.log(vmax) / math.log(b)
-
-        numdec = math.floor(log_vmax) - math.ceil(log_vmin)
+        # Min and max exponents, float and int versions; e.g., if vmin=10^0.3
+        # and vmax=10^6.9, then efmin=0.3, emin=1, emax=6, efmax=6.9, and nd=6.
+        efmin, efmax = self._log_b([vmin, vmax])
+        emin = math.ceil(efmin)
+        emax = math.floor(efmax)
+        nd = emax - emin + 1  # Total number of decade ticks available.
 
         if isinstance(self._subs, str):
-            if numdec > 10 or b < 3:
+            if nd >= 10 or b < 3:
                 if self._subs == 'auto':
                     return np.array([])  # no minor or major ticks
                 else:
@@ -2442,35 +2450,73 @@ def tick_values(self, vmin, vmax):
         else:
             subs = self._subs
 
-        # Get decades between major ticks.
-        stride = (max(math.ceil(numdec / (numticks - 1)), 1)
-                  if mpl.rcParams['_internal.classic_mode'] else
-                  numdec // numticks + 1)
-
-        # if we have decided that the stride is as big or bigger than
-        # the range, clip the stride back to the available range - 1
-        # with a floor of 1.  This prevents getting axis with only 1 tick
-        # visible.
-        if stride >= numdec:
-            stride = max(1, numdec - 1)
-
-        # Does subs include anything other than 1?  Essentially a hack to know
-        # whether we're a major or a minor locator.
-        have_subs = len(subs) > 1 or (len(subs) == 1 and subs[0] != 1.0)
-
-        decades = np.arange(math.floor(log_vmin) - stride,
-                            math.ceil(log_vmax) + 2 * stride, stride)
-
-        if have_subs:
-            if stride == 1:
-                ticklocs = np.concatenate(
-                    [subs * decade_start for decade_start in b ** decades])
+        # Get decades between major ticks.  Include an extra tick outside the
+        # lower and the upper limit: QuadContourSet._autolev relies on this.
+        if mpl.rcParams["_internal.classic_mode"]:  # keep historic formulas
+            stride = max(math.ceil((nd - 1) / (nt - 1)), 1)
+            decades = np.arange(emin - stride, emax + stride + 1, stride)
+        else:
+            # Find the largest number of ticks, no more than the requested
+            # number, that can actually be drawn (e.g., with 9 decades ticks,
+            # no stride yields 7 ticks).  For a given value of the stride *s*,
+            # there are either floor(nd/s) or ceil(nd/s) ticks depending on the
+            # offset.  Pick the smallest stride such that floor(nd/s) < nt,
+            # i.e. nd/s < nt+1, then re-set nt to ceil(...) if acceptable, else
+            # to floor(...) (which must then equal the original nt, i.e. nt is
+            # kept unchanged).
+            stride = nd // (nt + 1) + 1
+            nt1 = math.ceil(nd / stride)
+            if nt1 <= nt:
+                nt = nt1
+            else:
+                assert nt1 == nt + 1
+            if nt == 0:
+                decades = [emin - 1, emax + 1]
+                stride = decades[1] - decades[0]
+            elif nt == 1:  # Draw single tick close to center.
+                mid = round((efmin + efmax) / 2)
+                stride = max(mid - (emin - 1), (emax + 1) - mid)
+                decades = [mid - stride, mid, mid + stride]
+            else:
+                # Pick the largest s that yields this actual nt (e.g., with 15
+                # decades, strides of 5, 6, or 7 *can* yield 3 ticks; picking a
+                # larger stride minimizes unticked space at the ends).  First
+                # try for
+                #     ceil(nd/s) == nt, i.e. nd/nt <= s < nd/(nt-1),
+                # else fallback to
+                #     floor(nd/s) == nt, i.e. nd/(nt+1) < s <= nd/nt.
+                # One of these cases must have an integer solution (given the
+                # choice of nt above).
+                stride = (nd - 1) // (nt - 1)
+                if stride < nd / nt:  # fallback to second case
+                    stride = nd // nt
+                # For a given s, once including an offset off (0 <= off < s),
+                # the actual number of ticks is ceil((nd - off) / s), which
+                # must be equal to nt.  This leads to olo <= off < ohi, with
+                # the values defined below.
+                olo = max(nd - stride * nt, 0)
+                ohi = min(nd - stride * (nt - 1), stride)
+                # Try to see if we can pick an offset so that ticks are at
+                # integer multiples of the stride while satisfying the bounds
+                # above; if not, fallback to the smallest acceptable offset.
+                offset = (-emin) % stride
+                if not olo <= offset < ohi:
+                    offset = olo
+                decades = range(emin + offset - stride, emax + stride + 1, stride)
+
+        # Guess whether we're a minor locator, based on whether subs include
+        # anything other than 1.
+        is_minor = len(subs) > 1 or (len(subs) == 1 and subs[0] != 1.0)
+        if is_minor:
+            if stride == 1 or nd <= 1:
+                # Minor ticks start in the decade preceding the first major tick.
+                ticklocs = np.concatenate([
+                    subs * b**decade for decade in range(emin - 1, emax + 1)])
             else:
                 ticklocs = np.array([])
         else:
-            ticklocs = b ** decades
+            ticklocs = b ** np.array(decades)
 
-        _log.debug('ticklocs %r', ticklocs)
         if (len(subs) > 1
                 and stride == 1
                 and ((vmin <= ticklocs) & (ticklocs <= vmax)).sum() <= 1):
