PERF: Speed up log and symlog scale transforms (matplotlib#30993)

scottshambaugh · web-flow · commit 2b8103b1e4f3 · 2026-02-05T05:52:31.000-05:00
* speed up symlog transforms

* speed up log transform

* Privatize log and symlog transform attrs, expose via properties

* Deprecate InvertedSymmetricalLogTransform._invlinthresh

* Setters for log and symlog properties

* Update stub file

* Switch to lambda functions for logscale

* Fix pickling of log transforms

* Simplify log symlog structure

* Deprecation decorator

---------

Co-authored-by: Scott Shambaugh &lt;scottshambaugh@users.noreply.github.com&gt;
diff --git a/doc/api/next_api_changes/deprecations/30993-SS.rst b/doc/api/next_api_changes/deprecations/30993-SS.rst
@@ -0,0 +1,5 @@
+``InvertedSymmetricalLogTransform.invlinthresh``
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The ``invlinthresh`` attribute of `.InvertedSymmetricalLogTransform` is
+deprecated. Use the ``.inverted().transform(linthresh)`` method instead.
diff --git a/lib/matplotlib/scale.py b/lib/matplotlib/scale.py
@@ -292,6 +292,7 @@ def __init__(self, base, nonpositive='clip'):
         self.base = base
         self._clip = _api.getitem_checked(
             {"clip": True, "mask": False}, nonpositive=nonpositive)
+        self._log_funcs = {np.e: np.log, 2: np.log2, 10: np.log10}
 
     def __str__(self):
         return "{}(base={}, nonpositive={!r})".format(
@@ -300,12 +301,11 @@ def __str__(self):
     def transform_non_affine(self, values):
         # Ignore invalid values due to nans being passed to the transform.
         with np.errstate(divide="ignore", invalid="ignore"):
-            log = {np.e: np.log, 2: np.log2, 10: np.log10}.get(self.base)
-            if log:  # If possible, do everything in a single call to NumPy.
-                out = log(values)
+            log_func = self._log_funcs.get(self.base)
+            if log_func:
+                out = log_func(values)
             else:
-                out = np.log(values)
-                out /= np.log(self.base)
+                out = np.log(values) / np.log(self.base)
             if self._clip:
                 # SVG spec says that conforming viewers must support values up
                 # to 3.4e38 (C float); however experiments suggest that
@@ -329,12 +329,17 @@ class InvertedLogTransform(Transform):
     def __init__(self, base):
         super().__init__()
         self.base = base
+        self._exp_funcs = {np.e: np.exp, 2: np.exp2}
 
     def __str__(self):
         return f"{type(self).__name__}(base={self.base})"
 
     def transform_non_affine(self, values):
-        return np.power(self.base, values)
+        exp_func = self._exp_funcs.get(self.base)
+        if exp_func:
+            return exp_func(values)
+        else:
+            return np.exp(values * np.log(self.base))
 
     def inverted(self):
         return LogTransform(self.base)
@@ -449,17 +454,20 @@ def __init__(self, base, linthresh, linscale):
         self.base = base
         self.linthresh = linthresh
         self.linscale = linscale
-        self._linscale_adj = (linscale / (1.0 - self.base ** -1))
-        self._log_base = np.log(base)
 
     def transform_non_affine(self, values):
+        linscale_adj = self.linscale / (1.0 - 1.0 / self.base)
+        log_base = np.log(self.base)
+
         abs_a = np.abs(values)
+        inside = abs_a <= self.linthresh
+        if np.all(inside):  # Fast path: all values in linear region
+            return values * linscale_adj
         with np.errstate(divide="ignore", invalid="ignore"):
             out = np.sign(values) * self.linthresh * (
-                self._linscale_adj +
-                np.log(abs_a / self.linthresh) / self._log_base)
-            inside = abs_a <= self.linthresh
-        out[inside] = values[inside] * self._linscale_adj
+                linscale_adj - np.log(self.linthresh) / log_base +
+                np.log(abs_a) / log_base)
+        out[inside] = values[inside] * linscale_adj
         return out
 
     def inverted(self):
@@ -472,21 +480,35 @@ class InvertedSymmetricalLogTransform(Transform):
 
     def __init__(self, base, linthresh, linscale):
         super().__init__()
-        symlog = SymmetricalLogTransform(base, linthresh, linscale)
+        if base <= 1.0:
+            raise ValueError("'base' must be larger than 1")
+        if linthresh <= 0.0:
+            raise ValueError("'linthresh' must be positive")
+        if linscale <= 0.0:
+            raise ValueError("'linscale' must be positive")
         self.base = base
         self.linthresh = linthresh
-        self.invlinthresh = symlog.transform(linthresh)
         self.linscale = linscale
-        self._linscale_adj = (linscale / (1.0 - self.base ** -1))
+
+    @_api.deprecated("3.11", name="invlinthresh", obj_type="attribute",
+                     alternative=".inverted().transform(linthresh)")
+    @property
+    def invlinthresh(self):
+        invlinthresh = self.inverted().transform(self.linthresh)
+        return invlinthresh
 
     def transform_non_affine(self, values):
+        linscale_adj = self.linscale / (1.0 - 1.0 / self.base)
+        invlinthresh = self.inverted().transform(self.linthresh)
+
         abs_a = np.abs(values)
+        inside = abs_a <= invlinthresh
+        if np.all(inside):  # Fast path: all values in linear region
+            return values / linscale_adj
         with np.errstate(divide="ignore", invalid="ignore"):
-            out = np.sign(values) * self.linthresh * (
-                np.power(self.base,
-                         abs_a / self.linthresh - self._linscale_adj))
-            inside = abs_a <= self.invlinthresh
-        out[inside] = values[inside] / self._linscale_adj
+            out = np.sign(values) * self.linthresh * np.exp(
+                (abs_a / self.linthresh - linscale_adj) * np.log(self.base))
+        out[inside] = values[inside] / linscale_adj
         return out
 
     def inverted(self):
diff --git a/lib/matplotlib/scale.pyi b/lib/matplotlib/scale.pyi
@@ -98,8 +98,9 @@ class InvertedSymmetricalLogTransform(Transform):
     output_dims: int
     base: float
     linthresh: float
-    invlinthresh: float
     linscale: float
+    @property
+    def invlinthresh(self) -> float: ...
     def __init__(self, base: float, linthresh: float, linscale: float) -> None: ...
     def inverted(self) -> SymmetricalLogTransform: ...
 
diff --git a/lib/matplotlib/tests/test_axes.py b/lib/matplotlib/tests/test_axes.py
@@ -7378,7 +7378,7 @@ def test_loglog():
 
 
 @image_comparison(["test_loglog_nonpos.png"], remove_text=True, style='mpl20',
-                  tol=0 if platform.machine() == 'x86_64' else 0.029)
+                  tol=0.029)
 def test_loglog_nonpos():
     fig, axs = plt.subplots(3, 3)
     x = np.arange(1, 11)
diff --git a/lib/matplotlib/tests/test_colors.py b/lib/matplotlib/tests/test_colors.py
@@ -632,8 +632,9 @@ def inverse(x):
     norm = mcolors.FuncNorm((forward, inverse), vmin=0.1, vmax=10)
     lognorm = mcolors.LogNorm(vmin=0.1, vmax=10)
     assert_array_almost_equal(norm([0.2, 5, 10]), lognorm([0.2, 5, 10]))
-    assert_array_almost_equal(norm.inverse([0.2, 5, 10]),
-                              lognorm.inverse([0.2, 5, 10]))
+    # use assert_allclose here for rtol on large numbers
+    np.testing.assert_allclose(norm.inverse([0.2, 5, 10]),
+                               lognorm.inverse([0.2, 5, 10]))
 
 
 def test_TwoSlopeNorm_autoscale():
