Improve tick subsampling in LogLocator.

anntzer · anntzer · commit 34fa95b5b1b8 · 2025-03-03T14:34:26.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), and 2) the ticks are spaced as much as
possible (when two ticks are drawn, put them on the lowest and highest
decade, not somewhere in the middle).  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.
test_axes, test_scale: expected image changes?
diff --git a/lib/matplotlib/tests/test_axes.py b/lib/matplotlib/tests/test_axes.py
@@ -7132,8 +7132,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_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,28 @@ 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)
 
 
 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,16 @@ 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.
+        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 +2449,70 @@ 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.  Always return 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) - stride)
+                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).
+                # In the second case, an offset must be added to that only nt
+                # ticks are drawn (e.g. with 19 decades (0 to 18 incl.) and 6
+                # ticks, they should must be drawn at exponents 1, 4, 7, 10,
+                # 13, and 16).
+                stride = (nd - 1) // (nt - 1)
+                if stride < nd / nt:  # fallback to second case
+                    stride = nd // nt
+                    assert stride > nd / (nt + 1)
+                    offset = nd % stride
+                else:
+                    offset = 0
+                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):
