Reworked AsinhLocator to allow rounding on arbitrary number base

Author: rwpenney

lib/matplotlib/scale.py

@@ -464,6 +464,8 @@ class AsinhTransform(Transform):
 
     def __init__(self, linear_width):
         super().__init__()
+        if linear_width <= 0.0:
+            raise ValueError("Scale parameter 'a0' must be strictly positive")
         self.linear_width = linear_width
 
     def transform_non_affine(self, a):
@@ -509,7 +511,8 @@ class AsinhScale(ScaleBase):
 
     name = 'asinh'
 
-    def __init__(self, axis, *, linear_width=1.0, **kwargs):
+    def __init__(self, axis, *, linear_width=1.0,
+                 base=10, subs=(2, 5), **kwargs):
         """
         Parameters
         ----------
@@ -520,18 +523,26 @@ def __init__(self, axis, *, linear_width=1.0, **kwargs):
             becomes asympotically logarithmic.
         """
         super().__init__(axis)
-        if linear_width <= 0.0:
-            raise ValueError("Scale parameter 'a0' must be strictly positive")
-        self.linear_width = linear_width
+        self._transform = AsinhTransform(linear_width)
+        self._base = int(base)
+        self._subs = subs
+
+    linear_width = property(lambda self: self._transform.linear_width)
 
     def get_transform(self):
-        return AsinhTransform(self.linear_width)
+        return self._transform
 
     def set_default_locators_and_formatters(self, axis):
-        axis.set(major_locator=AsinhLocator(self.linear_width),
-                 minor_locator=AutoLocator(),
-                 major_formatter='{x:.3g}',
+        axis.set(major_locator=AsinhLocator(self.linear_width,
+                                            base=self._base),
+                 minor_locator=AsinhLocator(self.linear_width,
+                                            base=self._base,
+                                            subs=self._subs),
                  minor_formatter=NullFormatter())
+        if self._base > 1:
+            axis.set_major_formatter(LogFormatterSciNotation(self._base))
+        else:
+            axis.set_major_formatter('{x:.3g}'),
 
 
 class LogitTransform(Transform):

lib/matplotlib/ticker.py

@@ -2592,7 +2592,8 @@ class AsinhLocator(Locator):
     This is very unlikely to have any use beyond
     the `~.scale.AsinhScale` class.
     """
-    def __init__(self, linear_width, numticks=11, symthresh=0.2):
+    def __init__(self, linear_width, numticks=11, symthresh=0.2,
+                 base=0, subs=None):
         """
         Parameters
         ----------
@@ -2611,6 +2612,8 @@ def __init__(self, linear_width, numticks=11, symthresh=0.2):
         self.linear_width = linear_width
         self.numticks = numticks
         self.symthresh = symthresh
+        self.base = base
+        self.subs = subs
 
     def set_params(self, numticks=None, symthresh=None):
         """Set parameters within this locator."""
@@ -2642,19 +2645,33 @@ def tick_values(self, vmin, vmax):
 
         # Transform the "on-screen" grid to the data space:
         xs = self.linear_width * np.sinh(ys / self.linear_width)
-        zero_xs = (xs == 0)
-
-        # Round the data-space values to be intuitive decimal numbers:
-        decades = (
-            np.where(xs >= 0, 1, -1) *
-            np.power(10, np.where(zero_xs, 0.0,
-                                  np.floor(np.log10(np.abs(xs)
-                                                    + zero_xs*1e-6))))
-        )
-        qs = decades * np.round(xs / decades)
+        zero_xs = (ys == 0)
+
+        # Round the data-space values to be intuitive base-n numbers:
+        if self.base > 1:
+            log_base = math.log(self.base)
+            powers = (
+                np.where(zero_xs, 0, np.where(xs >=0, 1, -1)) *
+                np.power(self.base,
+                         np.where(zero_xs, 0.0,
+                                  np.floor(np.log(np.abs(xs) + zero_xs*1e-6)
+                                                / log_base)))
+            )
+            if self.subs:
+                qs = np.outer(powers, self.subs).flatten()
+            else:
+                qs = powers
+        else:
+            powers = (
+                np.where(xs >= 0, 1, -1) *
+                np.power(10, np.where(zero_xs, 0.0,
+                                      np.floor(np.log10(np.abs(xs)
+                                                        + zero_xs*1e-6))))
+            )
+            qs = powers * np.round(xs / powers)
         ticks = np.array(sorted(set(qs)))
 
-        if len(ticks) > self.numticks // 2:
+        if len(ticks) >=  2:
             return ticks
         else:
             return np.linspace(vmin, vmax, self.numticks)