Moved AsinhLocator into ticker.py and extracted AsinhScale nested transform classes

rwpenney · rwpenney · commit 2b0d58836f1b · 2021-10-21T16:57:45.000+01:00
diff --git a/lib/matplotlib/scale.py b/lib/matplotlib/scale.py
@@ -23,7 +23,7 @@
 from matplotlib.ticker import (
     NullFormatter, ScalarFormatter, LogFormatterSciNotation, LogitFormatter,
     Locator, NullLocator, LogLocator, AutoLocator, AutoMinorLocator,
-    SymmetricalLogLocator, LogitLocator)
+    SymmetricalLogLocator, AsinhLocator, LogitLocator)
 from matplotlib.transforms import Transform, IdentityTransform
 
 
@@ -458,6 +458,34 @@ def get_transform(self):
         return self._transform
 
 
+class AsinhTransform(Transform):
+    input_dims = output_dims = 1
+
+    def __init__(self, linear_width):
+        super().__init__()
+        self.linear_width = linear_width
+
+    def transform_non_affine(self, a):
+        return self.linear_width * np.arcsinh(a / self.linear_width)
+
+    def inverted(self):
+        return InvertedAsinhTransform(self.linear_width)
+
+
+class InvertedAsinhTransform(Transform):
+    input_dims = output_dims = 1
+
+    def __init__(self, linear_width):
+        super().__init__()
+        self.linear_width = linear_width
+
+    def transform_non_affine(self, a):
+        return self.linear_width * np.sinh(a / self.linear_width)
+
+    def inverted(self):
+        return AsinhTransform(self.linear_width)
+
+
 class AsinhScale(ScaleBase):
     """
     A quasi-logarithmic scale based on the inverse hyperbolic sine (asinh)
@@ -494,89 +522,12 @@ def __init__(self, axis, *, linear_width=1.0, **kwargs):
         self.linear_width = linear_width
 
     def get_transform(self):
-        return self.AsinhTransform(self.linear_width)
+        return AsinhTransform(self.linear_width)
 
     def set_default_locators_and_formatters(self, axis):
-        axis.set(major_locator=AsinhScale.AsinhLocator(self.linear_width),
+        axis.set(major_locator=AsinhLocator(self.linear_width),
                  major_formatter='{x:.3g}')
 
-    class AsinhTransform(Transform):
-        input_dims = output_dims = 1
-
-        def __init__(self, linear_width):
-            super().__init__()
-            self.linear_width = linear_width
-
-        def transform_non_affine(self, a):
-            return self.linear_width * np.arcsinh(a / self.linear_width)
-
-        def inverted(self):
-            return AsinhScale.InvertedAsinhTransform(self.linear_width)
-
-    class InvertedAsinhTransform(Transform):
-        input_dims = output_dims = 1
-
-        def __init__(self, linear_width):
-            super().__init__()
-            self.linear_width = linear_width
-
-        def transform_non_affine(self, a):
-            return self.linear_width * np.sinh(a / self.linear_width)
-
-        def inverted(self):
-            return AsinhScale.AsinhTransform(self.linear_width)
-
-    class AsinhLocator(Locator):
-        """
-        An axis tick locator specialized for the arcsinh scale
-
-        This is very unlikely to have any use beyond the AsinhScale class.
-        """
-        def __init__(self, linear_width, numticks=12):
-            """
-            Parameters
-            ----------
-            linear_width : float
-                The scale parameter defining the extent
-                of the quasi-linear region.
-            numticks : int, default: 12
-                The approximate number of major ticks that will fit
-                along the entire axis
-            """
-            super().__init__()
-            self.linear_width = linear_width
-            self.numticks = numticks
-
-        def __call__(self):
-            dmin, dmax = self.axis.get_data_interval()
-            return self.tick_values(dmin, dmax)
-
-        def tick_values(self, vmin, vmax):
-            # Construct a set of "on-screen" locations
-            # that are uniformly spaced:
-            ymin, ymax = self.linear_width * np.arcsinh(np.array([vmin, vmax]) / self.linear_width)
-            ys = np.linspace(ymin, ymax, self.numticks)
-            if (ymin * ymax) < 0:
-                # Ensure that the zero tick-mark is included,
-                # if the axis stradles zero
-                ys = np.hstack([ys, 0.0])
-
-            # 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, 1.0,
-                                      np.floor(np.log10(np.abs(xs)
-                                                        + zero_xs*1e-6))))
-            )
-            qs = decades * np.round(xs / decades)
-
-            return np.array(sorted(set(qs)))
-
-
 class LogitTransform(Transform):
     input_dims = output_dims = 1
 
diff --git a/lib/matplotlib/tests/test_scale.py b/lib/matplotlib/tests/test_scale.py
@@ -2,6 +2,7 @@
 
 import matplotlib.pyplot as plt
 from matplotlib.scale import (
+    AsinhTransform,
     LogTransform, InvertedLogTransform,
     SymmetricalLogTransform)
 import matplotlib.scale as mscale
@@ -222,5 +223,16 @@ def test_scale_deepcopy():
 
 
 def test_asinh_transforms():
-    # FIXME - more here soon
-    pass
+    a0 = 17.0
+    a = np.linspace(-50, 50, 100)
+
+    forward = AsinhTransform(a0)
+    inverse = forward.inverted()
+    invinv = inverse.inverted()
+
+    a_forward = forward.transform_non_affine(a)
+    a_inverted = inverse.transform_non_affine(a_forward)
+    assert_allclose(a_inverted, a)
+
+    a_invinv = invinv.transform_non_affine(a)
+    assert_allclose(a_invinv, a0 * numpy.asinh(a / a0))
diff --git a/lib/matplotlib/ticker.py b/lib/matplotlib/ticker.py
@@ -36,6 +36,8 @@
 `SymmetricalLogLocator` Locator for use with with the symlog norm; works like
                         `LogLocator` for the part outside of the threshold and
                         adds 0 if inside the limits.
+`AsinhLocator`          Locator for use with the asinh norm, attempting to
+                        space ticks approximately uniformly.
 `LogitLocator`          Locator for logit scaling.
 `AutoMinorLocator`      Locator for minor ticks when the axis is linear and the
                         major ticks are uniformly spaced. Subdivides the major
@@ -2583,6 +2585,57 @@ def view_limits(self, vmin, vmax):
         return result
 
 
+class AsinhLocator(Locator):
+    """
+    An axis tick locator specialized for the inverse-sinh scale
+
+    This is very unlikely to have any use beyond the AsinhScale class.
+    """
+    def __init__(self, linear_width, numticks=12):
+        """
+        Parameters
+        ----------
+        linear_width : float
+            The scale parameter defining the extent
+            of the quasi-linear region.
+        numticks : int, default: 12
+            The approximate number of major ticks that will fit
+            along the entire axis
+        """
+        super().__init__()
+        self.linear_width = linear_width
+        self.numticks = numticks
+
+    def __call__(self):
+        dmin, dmax = self.axis.get_data_interval()
+        return self.tick_values(dmin, dmax)
+
+    def tick_values(self, vmin, vmax):
+        # Construct a set of "on-screen" locations
+        # that are uniformly spaced:
+        ymin, ymax = self.linear_width * np.arcsinh(np.array([vmin, vmax]) / self.linear_width)
+        ys = np.linspace(ymin, ymax, self.numticks)
+        if (ymin * ymax) < 0:
+            # Ensure that the zero tick-mark is included,
+            # if the axis stradles zero
+            ys = np.hstack([ys, 0.0])
+
+        # 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, 1.0,
+                                  np.floor(np.log10(np.abs(xs)
+                                                    + zero_xs*1e-6))))
+        )
+        qs = decades * np.round(xs / decades)
+
+        return np.array(sorted(set(qs)))
+
+
 class LogitLocator(MaxNLocator):
     """
     Determine the tick locations for logit axes
