Improved minor-tick location for common number bases and widened test coverage

Author: rwpenney

examples/scales/asinh_demo.py

@@ -64,12 +64,12 @@
 # Compare "asinh" graphs with different scale parameter "linear_width":
 fig2 = plt.figure(constrained_layout=True)
 axs = fig2.subplots(1, 3, sharex=True)
-for ax, a0 in zip(axs, (0.2, 1.0, 5.0)):
+for ax, (a0, base) in zip(axs, ((0.2, 2), (1.0, 0), (5.0, 3))):
     ax.set_title('linear_width={:.3g}'.format(a0))
     ax.plot(x, x, label='y=x')
     ax.plot(x, 10*x, label='y=10x')
     ax.plot(x, 100*x, label='y=100x')
-    ax.set_yscale('asinh', linear_width=a0)
+    ax.set_yscale('asinh', linear_width=a0, base=base)
     ax.grid()
     ax.legend(loc='best', fontsize='small')
 

lib/matplotlib/scale.py

@@ -511,8 +511,18 @@ class AsinhScale(ScaleBase):
 
     name = 'asinh'
 
+    auto_tick_multipliers = {
+        3: (2, ),
+        4: (2, ),
+        5: (2, ),
+        8: (2, 4),
+        10: (2, 5),
+        16: (2, 4, 8),
+        64: (4, 16),
+        1024: (256, 512) }
+
     def __init__(self, axis, *, linear_width=1.0,
-                 base=10, subs=(2, 5), **kwargs):
+                 base=10, subs='auto', **kwargs):
         """
         Parameters
         ----------
@@ -521,11 +531,23 @@ def __init__(self, axis, *, linear_width=1.0,
             defining the extent of the quasi-linear region,
             and the coordinate values beyond which the transformation
             becomes asympotically logarithmic.
+        base : int, default: 10
+            The number base used for rounding tick locations
+            on a logarithmic scale. If this is less than one,
+            then rounding is to the nearest integer multiple
+            of powers of ten.
+        subs : sequence of int
+            Multiples of the number base used for minor ticks.
+            If set to 'auto', this will use built-in defaults,
+            e.g. (2, 5) for base=10.
         """
         super().__init__(axis)
         self._transform = AsinhTransform(linear_width)
         self._base = int(base)
-        self._subs = subs
+        if subs == 'auto':
+            self._subs = self.auto_tick_multipliers.get(self._base)
+        else:
+            self._subs = subs
 
     linear_width = property(lambda self: self._transform.linear_width)
 

lib/matplotlib/tests/test_scale.py

@@ -243,11 +243,24 @@ def test_init(self):
 
         s = AsinhScale(axis=None, linear_width=23.0)
         assert s.linear_width == 23
+        assert s._base == 10
+        assert s._subs == (2, 5)
 
         tx = s.get_transform()
         assert isinstance(tx, AsinhTransform)
         assert tx.linear_width == s.linear_width
 
+    def test_base_init(self):
+        fig, ax = plt.subplots()
+
+        s3 = AsinhScale(axis=None, base=3)
+        assert s3._base == 3
+        assert s3._subs == (2,)
+
+        s7 = AsinhScale(axis=None, base=7)
+        assert s7._base == 7
+        assert s7._subs == (2, 5)
+
     def test_bad_scale(self):
         fig, ax = plt.subplots()
 

lib/matplotlib/tests/test_ticker.py

@@ -448,12 +448,16 @@ def test_init(self):
         lctr = mticker.AsinhLocator(linear_width=2.718, numticks=19)
         assert lctr.linear_width == 2.718
         assert lctr.numticks == 19
+        assert lctr.base == 0
 
     def test_set_params(self):
         lctr = mticker.AsinhLocator(linear_width=5,
-                                    numticks=17, symthresh=0.125)
+                                    numticks=17, symthresh=0.125,
+                                    base=4, subs=(2.5, 3.25))
         assert lctr.numticks == 17
         assert lctr.symthresh == 0.125
+        assert lctr.base == 4
+        assert lctr.subs == (2.5, 3.25)
 
         lctr.set_params(numticks=23)
         assert lctr.numticks == 23
@@ -465,8 +469,20 @@ def test_set_params(self):
         lctr.set_params(symthresh=None)
         assert lctr.symthresh == 0.5
 
+        lctr.set_params(base=7)
+        assert lctr.base == 7
+        lctr.set_params(base=None)
+        assert lctr.base == 7
+
+        lctr.set_params(subs=(2, 4.125))
+        assert lctr.subs == (2, 4.125)
+        lctr.set_params(subs=None)
+        assert lctr.subs == (2, 4.125)
+        lctr.set_params(subs=[])
+        assert lctr.subs is None
+
     def test_linear_values(self):
-        lctr = mticker.AsinhLocator(linear_width=100, numticks=11)
+        lctr = mticker.AsinhLocator(linear_width=100, numticks=11, base=0)
 
         assert_almost_equal(lctr.tick_values(-1, 1),
                             np.arange(-1, 1.01, 0.2))
@@ -476,7 +492,7 @@ def test_linear_values(self):
                             np.arange(-0.01, 0.0101, 0.002))
 
     def test_wide_values(self):
-        lctr = mticker.AsinhLocator(linear_width=0.1, numticks=11)
+        lctr = mticker.AsinhLocator(linear_width=0.1, numticks=11, base=0)
 
         assert_almost_equal(lctr.tick_values(-100, 100),
                             [-100, -20, -5, -1, -0.2,
@@ -487,7 +503,7 @@ def test_wide_values(self):
 
     def test_near_zero(self):
         """Check that manually injected zero will supersede nearby tick"""
-        lctr = mticker.AsinhLocator(linear_width=100, numticks=3)
+        lctr = mticker.AsinhLocator(linear_width=100, numticks=3, base=0)
 
         assert_almost_equal(lctr.tick_values(-1.1, 0.9), [-1.0, 0.0, 0.9])
 
@@ -504,7 +520,7 @@ class DummyAxis:
             def get_data_interval(cls): return cls.bounds
 
         lctr = mticker.AsinhLocator(linear_width=1, numticks=3,
-                                    symthresh=0.25)
+                                    symthresh=0.25, base=0)
         lctr.axis = DummyAxis
 
         DummyAxis.bounds = (-1, 2)
@@ -519,6 +535,20 @@ def get_data_interval(cls): return cls.bounds
         DummyAxis.bounds = (1, 1.1)
         assert_almost_equal(lctr(), [1, 1.05, 1.1])
 
+    def test_base_rounding(self):
+        lctr10 = mticker.AsinhLocator(linear_width=1, numticks=8,
+                                      base=10, subs=(1, 3, 5))
+        assert_almost_equal(lctr10.tick_values(-110, 110),
+                            [-500, -300, -100, -50, -30, -10, -5, -3, -1,
+                             -0.5, -0.3, -0.1, 0, 0.1, 0.3, 0.5,
+                             1, 3, 5, 10, 30, 50, 100, 300, 500])
+
+        lctr5 = mticker.AsinhLocator(linear_width=1, numticks=20, base=5)
+        assert_almost_equal(lctr5.tick_values(-1050, 1050),
+                            [-625, -125, -25, -5, -1, -0.2, 0,
+                             0.2, 1, 5, 25, 125, 625])
+
+
 
 class TestScalarFormatter:
     offset_data = [

lib/matplotlib/ticker.py

@@ -2607,6 +2607,14 @@ def __init__(self, linear_width, numticks=11, symthresh=0.2,
             The fractional threshold beneath which data which covers
             a range that is approximately symmetric about zero
             will have ticks that are exactly symmetric.
+        base : int, default: 0
+            The number base used for rounding tick locations
+            on a logarithmic scale. If this is less than one,
+            then rounding is to the nearest integer multiple
+            of powers of ten.
+        subs : tuple, default: None
+            Multiples of the number base, typically used
+            for the minor ticks, e.g. (2, 5) when base=10.
         """
         super().__init__()
         self.linear_width = linear_width
@@ -2615,12 +2623,17 @@ def __init__(self, linear_width, numticks=11, symthresh=0.2,
         self.base = base
         self.subs = subs
 
-    def set_params(self, numticks=None, symthresh=None):
+    def set_params(self, numticks=None, symthresh=None,
+                   base=None, subs=None):
         """Set parameters within this locator."""
         if numticks is not None:
             self.numticks = numticks
         if symthresh is not None:
             self.symthresh = symthresh
+        if base is not None:
+            self.base = base
+        if subs is not None:
+            self.subs = subs if len(subs) > 0 else None
 
     def __call__(self):
         dmin, dmax = self.axis.get_data_interval()