matplotlib · schtandard · Mar 15, 2026 · Mar 16, 2026 · Mar 16, 2026 · Mar 16, 2026
diff --git a/doc/api/next_api_changes/behavior/27310-BW.rst b/doc/api/next_api_changes/behavior/27310-BW.rst
@@ -0,0 +1,6 @@
+Improved ``symlog`` tick placement
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The tick placement for ``symlog`` axes has been improved. It now also supports
+minor ticks and `.SymmetricalLogScale` uses ``subs='auto'`` (minor ticks if
+appropriate) by default rather than ``subs=None`` (no minor ticks).
diff --git a/doc/missing-references.json b/doc/missing-references.json
@@ -74,6 +74,10 @@
       "lib/matplotlib/offsetbox.py:docstring of matplotlib.offsetbox.AnnotationBbox:1",
       "lib/matplotlib/text.py:docstring of matplotlib.text.Annotation:1"
     ],
+    "matplotlib.ticker._SymmetricalLogMixin": [
+      "lib/matplotlib/ticker.py:docstring of matplotlib.ticker.LogFormatter:1",
+      "lib/matplotlib/ticker.py:docstring of matplotlib.ticker.SymmetricalLogLocator:1"
+    ],
     "matplotlib.transforms._BlendedMixin": [
       "lib/matplotlib/transforms.py:docstring of matplotlib.transforms.BlendedAffine2D:1",
       "lib/matplotlib/transforms.py:docstring of matplotlib.transforms.BlendedGenericTransform:1"

diff --git a/doc/release/next_whats_new/improved_symlog_ticks.rst b/doc/release/next_whats_new/improved_symlog_ticks.rst
@@ -0,0 +1,21 @@
+Improved tick placement for ``symlog`` axes
+-------------------------------------------
+
+The placement of ticks for ``symlog`` axes has been improved. Ticks are now
+placed identically to ``log`` axes in the logarithmic part with a reasonable
+extension of this behavior to the linear part of the axis. Axes with too few
+ticks or spurious ticks are avoided by the new implementation.
+
+.. plot::
+    :include-source: true
+
+    fig, axs = plt.subplots(1, 2)
+    x = np.arange(201)
+
+    for ax, (ymin, ymax) in zip(axs, [(-30, 200), (0.6, 6)]):
+        y = np.linspace(ymin, ymax, x.size)
+        ax.set_yscale('symlog')
+        ax.grid(which='major')
+        ax.plot(x, y, '.')
+
+    fig.tight_layout()
diff --git a/lib/matplotlib/scale.py b/lib/matplotlib/scale.py
@@ -594,10 +594,17 @@ class SymmetricalLogScale(ScaleBase):
         Defines the range ``(-x, x)``, within which the plot is linear.
         This avoids having the plot go to infinity around zero.
 
-    subs : sequence of int
+    subs : None, 'auto', 'all' or sequence of int, default: 'auto'
         Where to place the subticks between each major tick.
         For example, in a log10 scale: ``[2, 3, 4, 5, 6, 7, 8, 9]`` will place
-        8 logarithmically spaced minor ticks between each major tick.
+        8 logarithmically spaced minor ticks between each major tick. Both ``'auto'``
+        and ``'all'`` use an algorithm based on the axis view limits to determine
+        whether and how to put ticks between integer powers of the base. With
+        ``'auto'``, minor ticks are placed only between integer powers; with ``'all'``,
+        the integer powers are included. With ``None``, minor ticks are suppressed.
+
+        .. versionchanged:: 3.12
+            The default value is now ``'auto'``.
 
     linscale : float, optional
         This allows the linear range ``(-linthresh, linthresh)`` to be
@@ -610,7 +617,7 @@ class SymmetricalLogScale(ScaleBase):
     name = 'symlog'
 
     @_make_axis_parameter_optional
-    def __init__(self, axis=None, *, base=10, linthresh=2, subs=None, linscale=1):
+    def __init__(self, axis=None, *, base=10, linthresh=2, subs='auto', linscale=1):
         self._transform = SymmetricalLogTransform(base, linthresh, linscale)
         self.subs = subs
 
@@ -620,11 +627,21 @@ def __init__(self, axis=None, *, base=10, linthresh=2, subs=None, linscale=1):
 
     def set_default_locators_and_formatters(self, axis):
         # docstring inherited
-        axis.set_major_locator(SymmetricalLogLocator(self.get_transform()))
-        axis.set_major_formatter(LogFormatterSciNotation(self.base))
-        axis.set_minor_locator(SymmetricalLogLocator(self.get_transform(),
-                                                     self.subs))
-        axis.set_minor_formatter(NullFormatter())
+        axis.set_major_locator(SymmetricalLogLocator(base=self.base,
+                                                     linthresh=self.linthresh,
+                                                     linscale=self.linscale))
+        axis.set_major_formatter(LogFormatterSciNotation(base=self.base,
+                                                         linthresh=self.linthresh,
+                                                         linscale=self.linscale))
+        axis.set_minor_locator(SymmetricalLogLocator(base=self.base,
+                                                     linthresh=self.linthresh,
+                                                     linscale=self.linscale,
+                                                     subs=self.subs))
+        axis.set_minor_formatter(
+            LogFormatterSciNotation(base=self.base,
+                                    linthresh=self.linthresh,
+                                    linscale=self.linscale,
+                                    labelOnlyBase=(self.subs != 'auto')))
 
     def get_transform(self):
         """Return the `.SymmetricalLogTransform` associated with this scale."""

diff --git a/lib/matplotlib/scale.pyi b/lib/matplotlib/scale.pyi
@@ -114,7 +114,7 @@ class SymmetricalLogScale(ScaleBase):
         *,
         base: float = ...,
         linthresh: float = ...,
-        subs: Iterable[int] | None = ...,
+        subs: Iterable[int] | Literal["auto", "all"] | None = ...,
         linscale: float = ...
     ) -> None: ...
     @property

diff --git a/lib/matplotlib/tests/baseline_images/test_axes/symlog.pdf b/lib/matplotlib/tests/baseline_images/test_axes/symlog.pdf
diff --git a/lib/matplotlib/tests/baseline_images/test_axes/symlog2.pdf b/lib/matplotlib/tests/baseline_images/test_axes/symlog2.pdf
diff --git a/lib/matplotlib/tests/test_axes.py b/lib/matplotlib/tests/test_axes.py
@@ -1377,22 +1377,25 @@ def test_fill_between_interpolate_nan():
                     interpolate=True, alpha=0.5)
 
 
-# test_symlog and test_symlog2 used to have baseline images in all three
-# formats, but the png and svg baselines got invalidated by the removal of
-# minor tick overstriking.
 @image_comparison(['symlog.pdf'], style='mpl20')
 def test_symlog():
+    fig, axs = plt.subplots(2, figsize=[6.4, 9.6])
+
     x = np.array([0, 1, 2, 4, 6, 9, 12, 24])
     y = np.array([1000000, 500000, 100000, 100, 5, 0, 0, 0])
+    axs[0].plot(x, y)
+    axs[0].set_yscale('symlog')
+    axs[0].set_xscale('linear')
+    axs[0].set_ylim(-1, 10000000)
 
-    fig, ax = plt.subplots()
-    ax.plot(x, y)
-    ax.set_yscale('symlog')
-    ax.set_xscale('linear')
-    ax.set_ylim(-1, 10000000)
+    x = np.linspace(-25, 25, 101)
+    y = np.linspace(0, 2500, 101)
+    axs[1].plot(x, y)
+    axs[1].set_xscale('symlog')
+    axs[1].set_yscale('symlog', linthresh=1, linscale=2)
 
 
-@image_comparison(['symlog2.pdf'], remove_text=True, style='_classic_test')
+@image_comparison(['symlog2.pdf'], remove_text=True, style='mpl20')
 def test_symlog2():
     # Numbers from -50 to 50, with 0.1 as step
     x = np.arange(-50, 50, 0.001)

diff --git a/lib/matplotlib/tests/test_ticker.py b/lib/matplotlib/tests/test_ticker.py
@@ -624,45 +624,81 @@ def test_tick_values_not_exceeding_vmax(self):
 class TestSymmetricalLogLocator:
     def test_set_params(self):
         """
-        Create symmetrical log locator with default subs =[1.0] numticks = 15,
+        Create symmetrical log locator with default subs=[1.0] numticks='auto',
         and change it to something else.
         See if change was successful.
         Should not exception.
         """
-        sym = mticker.SymmetricalLogLocator(base=10, linthresh=1)
+        sym = mticker.SymmetricalLogLocator(base=10, linthresh=1, linscale=1)
         sym.set_params(subs=[2.0], numticks=8)
         assert sym._subs == [2.0]
         assert sym.numticks == 8
 
+    def test_mixin(self):
+        sym = mticker.SymmetricalLogLocator(base=10, linthresh=20, linscale=3)
+
+        assert_almost_equal(sym._val2axpos(20), 3)
+        assert_almost_equal(sym._val2axpos(-200), -4)
+        assert_almost_equal(sym._val2axpos(20000000), 9)
+        assert_almost_equal(sym._val2axpos(0), 0)
+        assert_almost_equal(sym._val2axpos(1), 0.15)
+        assert_almost_equal(sym._val2axpos(-4), -0.6)
+
+        assert_almost_equal(sym._axpos2val(5), 2000)
+        assert_almost_equal(sym._axpos2val(-3.5), -63.2455532033676)
+        assert_almost_equal(sym._axpos2val(0.5), 3.3333333333333)
+
+        assert_almost_equal(sym._firsttickval(), 10)
+
+        assert_almost_equal(sym._val2decnum(0), 0)
+        assert_almost_equal(sym._val2decnum(-100), -2)
+        assert_almost_equal(sym._val2decnum(316.227766016838), 2.5)
+        assert_almost_equal(sym._val2decnum(5), 0.5)
+        assert_almost_equal(sym._val2decnum(20), 1.30102999566398)
+
+        assert_almost_equal(sym._decnum2val(-1), -10)
+        assert_almost_equal(sym._decnum2val(2), 100)
+        assert_almost_equal(sym._decnum2val(0.1), 1)
+        assert_almost_equal(sym._decnum2val(0), 0)
+        assert_almost_equal(sym._decnum2val(1.5), 31.6227766016838)
+
+        sym = mticker.SymmetricalLogLocator(base=10, linthresh=20, linscale=15)
+        assert_almost_equal(sym._firsttickval(), 1)
+
+        sym = mticker.SymmetricalLogLocator(base=10, linthresh=20, linscale=0.8)
+        assert_almost_equal(sym._firsttickval(), 100)
+
     @pytest.mark.parametrize(
             'vmin, vmax, expected',
             [
-                (0, 1, [0, 1]),
-                (-1, 1, [-1, 0, 1]),
+                (0, 1, [-1, 0, 1, 10]),
+                (-1, 1, [-10, -1, 0, 1, 10]),
             ],
     )
     def test_values(self, vmin, vmax, expected):
         # https://github.com/matplotlib/matplotlib/issues/25945
-        sym = mticker.SymmetricalLogLocator(base=10, linthresh=1)
+        sym = mticker.SymmetricalLogLocator(base=10, linthresh=1, linscale=1)
         ticks = sym.tick_values(vmin=vmin, vmax=vmax)
         assert_array_equal(ticks, expected)
 
     def test_subs(self):
-        sym = mticker.SymmetricalLogLocator(base=10, linthresh=1, subs=[2.0, 4.0])
+        sym = mticker.SymmetricalLogLocator(base=10, linthresh=1, linscale=1,
+                                            subs=[2.0, 4.0])
         sym.create_dummy_axis()
         sym.axis.set_view_interval(-10, 10)
-        assert_array_equal(sym(), [-20, -40, -2, -4, 0, 2, 4, 20, 40])
+        assert_array_equal(sym(), [-400, -200, -40, -20, -4, -2, -0.4, -0.2, -0.1,
+                                   0.1, 0.2, 0.4, 2, 4, 20, 40, 200, 400])
 
     def test_extending(self):
-        sym = mticker.SymmetricalLogLocator(base=10, linthresh=1)
+        sym = mticker.SymmetricalLogLocator(base=10, linthresh=1, linscale=1)
         sym.create_dummy_axis()
         sym.axis.set_view_interval(8, 9)
-        assert (sym() == [1.0]).all()
+        assert_array_equal(sym(), [1, 10])
         sym.axis.set_view_interval(8, 12)
-        assert (sym() == [1.0, 10.0]).all()
+        assert_array_equal(sym(), [1, 10, 100])
         assert sym.view_limits(10, 10) == (1, 100)
         assert sym.view_limits(-10, -10) == (-100, -1)
-        assert sym.view_limits(0, 0) == (-0.001, 0.001)
+        assert sym.view_limits(0, 0) == (-1, 1)
 
 
 class TestAsinhLocator: