Rewrite SymmetricalLogLocator

schtandard · schtandard · commit 5717116dc41c · 2023-11-10T17:17:29.000+01:00
The new locator is based on LogLocator in such a way that it should give
identical results if the data is only in a logarithmic part of the axis.
It is extended to the linear part in a (hopefully) reasonable manner.
diff --git a/lib/matplotlib/ticker.py b/lib/matplotlib/ticker.py
@@ -2444,157 +2444,263 @@ def nonsingular(self, vmin, vmax):
 
 class SymmetricalLogLocator(Locator):
     """
+
     Determine the tick locations for symmetric log axes.
+
+    Place ticks on the locations : ``subs[j] * base**i``
+
+    Parameters
+    ----------
+    transform : `~.scale.SymmetricalLogTransform`, optional
+        If set, defines *base*, *linthresh* and *linscale* of the symlog transform.
+    subs : None or {'auto', 'all'} or sequence of float, default: None
+        Gives the multiples of integer powers of the base at which
+        to place ticks.  The default of ``None`` is equivalent to ``(1.0, )``,
+        i.e. it places ticks only at integer powers of the base.
+        Permitted string values are ``'auto'`` and ``'all'``.
+        Both of these 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'``, ticks are
+        placed only between integer powers; with ``'all'``, the
+        integer powers are included.
+    numticks : None or int, default: None
+        The maximum number of ticks to allow on a given axis. The default
+        of ``None`` will try to choose intelligently as long as this
+        Locator has already been assigned to an axis using
+        `~.axis.Axis.get_tick_space`, but otherwise falls back to 9.
+    base, linthresh, linscale : float, optional
+        The *base*, *linthresh* and *linscale* of the symlog transform, as
+        documented for `.SymmetricalLogScale`.  These parameters are only used
+        if *transform* is not set.
+
     """
 
-    def __init__(self, transform=None, subs=None, linthresh=None, base=None):
-        """
-        Parameters
-        ----------
-        transform : `~.scale.SymmetricalLogTransform`, optional
-            If set, defines the *base* and *linthresh* of the symlog transform.
-        base, linthresh : float, optional
-            The *base* and *linthresh* of the symlog transform, as documented
-            for `.SymmetricalLogScale`.  These parameters are only used if
-            *transform* is not set.
-        subs : sequence of float, default: [1]
-            The multiples of integer powers of the base where ticks are placed,
-            i.e., ticks are placed at
-            ``[sub * base**i for i in ... for sub in subs]``.
-
-        Notes
-        -----
-        Either *transform*, or both *base* and *linthresh*, must be given.
-        """
+    def __init__(self, transform=None, subs=None, numticks=None,
+                 base=None, linthresh=None, linscale=None):
+        """Place ticks on the locations : subs[j] * base**i."""
         if transform is not None:
             self._base = transform.base
             self._linthresh = transform.linthresh
-        elif linthresh is not None and base is not None:
+            self._linscale = transform.linscale
+        elif base is not None and linthresh is not None and linscale is not None:
             self._base = base
             self._linthresh = linthresh
+            self._linscale = linscale
         else:
-            raise ValueError("Either transform, or both linthresh "
-                             "and base, must be provided.")
-        if subs is None:
-            self._subs = [1.0]
-        else:
-            self._subs = subs
-        self.numticks = 15
+            raise ValueError("Either transform, or all of base, linthresh and "
+                             "linscale must be provided.")
+        self._set_subs(subs)
+        if numticks is None:
+            if mpl.rcParams['_internal.classic_mode']:
+                numticks = 15
+            else:
+                numticks = 'auto'
 
-    def set_params(self, subs=None, numticks=None):
+    def set_params(self, subs=None, numticks=None,
+                   base=None, linthresh=None, linscale=None):
         """Set parameters within this locator."""
+        if subs is not None:
+            self._set_subs(subs)
         if numticks is not None:
             self.numticks = numticks
-        if subs is not None:
+        if base is not None:
+            self._base = float(base)
+        if linthresh is not None:
+            self._linthresh = float(linthresh)
+        if linscale is not None:
+            self._linscale = float(linscale)
+
+    def _set_subs(self, subs):
+        """
+        Set the minor ticks for the log scaling every ``base**i*subs[j]``.
+        """
+        if subs is None:  # consistency with previous bad API
+            self._subs = np.array([1.0])
+        elif isinstance(subs, str):
+            _api.check_in_list(('all', 'auto'), subs=subs)
             self._subs = subs
+        else:
+            try:
+                self._subs = np.asarray(subs, dtype=float)
+            except ValueError as e:
+                raise ValueError("subs must be None, 'all', 'auto' or "
+                                 "a sequence of floats, not "
+                                 f"{subs}.") from e
+            if self._subs.ndim != 1:
+                raise ValueError("A sequence passed to subs must be "
+                                 "1-dimensional, not "
+                                 f"{self._subs.ndim}-dimensional.")
 
     def __call__(self):
         """Return the locations of the ticks."""
-        # Note, these are untransformed coordinates
         vmin, vmax = self.axis.get_view_interval()
         return self.tick_values(vmin, vmax)
 
     def tick_values(self, vmin, vmax):
-        linthresh = self._linthresh
+        if self.numticks == 'auto':
+            if self.axis is not None:
+                numticks = np.clip(self.axis.get_tick_space(), 2, 9)
+            else:
+                numticks = 9
+        else:
+            numticks = self.numticks
 
+        _log.debug('vmin %s vmax %s', vmin, vmax)
         if vmax < vmin:
             vmin, vmax = vmax, vmin
 
-        # The domain is divided into three sections, only some of
-        # which may actually be present.
-        #
-        # <======== -t ==0== t ========>
-        # aaaaaaaaa    bbbbb   ccccccccc
-        #
-        # a) and c) will have ticks at integral log positions.  The
-        # number of ticks needs to be reduced if there are more
-        # than self.numticks of them.
-        #
-        # b) has a tick at 0 and only 0 (we assume t is a small
-        # number, and the linear segment is just an implementation
-        # detail and not interesting.)
-        #
-        # We could also add ticks at t, but that seems to usually be
-        # uninteresting.
-        #
-        # "simple" mode is when the range falls entirely within [-t, t]
-        #  -- it should just display (vmin, 0, vmax)
-        if -linthresh <= vmin < vmax <= linthresh:
-            # only the linear range is present
-            return sorted({vmin, 0, vmax})
-
-        # Lower log range is present
-        has_a = (vmin < -linthresh)
-        # Upper log range is present
-        has_c = (vmax > linthresh)
-
-        # Check if linear range is present
-        has_b = (has_a and vmax > -linthresh) or (has_c and vmin < linthresh)
-
-        base = self._base
-
-        def get_log_range(lo, hi):
-            lo = np.floor(np.log(lo) / np.log(base))
-            hi = np.ceil(np.log(hi) / np.log(base))
-            return lo, hi
-
-        # Calculate all the ranges, so we can determine striding
-        a_lo, a_hi = (0, 0)
-        if has_a:
-            a_upper_lim = min(-linthresh, vmax)
-            a_lo, a_hi = get_log_range(abs(a_upper_lim), abs(vmin) + 1)
-
-        c_lo, c_hi = (0, 0)
-        if has_c:
-            c_lower_lim = max(linthresh, vmin)
-            c_lo, c_hi = get_log_range(c_lower_lim, vmax + 1)
-
-        # Calculate the total number of integer exponents in a and c ranges
-        total_ticks = (a_hi - a_lo) + (c_hi - c_lo)
-        if has_b:
-            total_ticks += 1
-        stride = max(total_ticks // (self.numticks - 1), 1)
-
-        decades = []
-        if has_a:
-            decades.extend(-1 * (base ** (np.arange(a_lo, a_hi,
-                                                    stride)[::-1])))
-
-        if has_b:
-            decades.append(0.0)
-
-        if has_c:
-            decades.extend(base ** (np.arange(c_lo, c_hi, stride)))
-
-        subs = np.asarray(self._subs)
-
-        if len(subs) > 1 or subs[0] != 1.0:
-            ticklocs = []
-            for decade in decades:
-                if decade == 0:
-                    ticklocs.append(decade)
+        haszero = vmin <= 0 <= vmax
+        firstdec = np.ceil(self._dec(vmin))
+        lastdec = np.floor(self._dec(vmax))
+        maxdec = max(abs(firstdec), abs(lastdec))
+        # Number of decades completely contained in the range.
+        numdec = lastdec - firstdec
+
+        # Calculate the subs immediately, as we may return early.
+        if isinstance(self._subs, str):
+            # Either 'auto' or 'all'.
+            if numdec > 10:
+                # No minor ticks.
+                if self._subs == 'auto':
+                    # No major ticks either.
+                    return np.array([])
                 else:
-                    ticklocs.extend(subs * decade)
+                    subs = np.array([1.0])
+            else:
+                _first = 2.0 if self._subs == 'auto' else 1.0
+                subs = np.arange(_first, self._base)
         else:
-            ticklocs = decades
+            subs = self._subs
 
-        return self.raise_if_exceeds(np.array(ticklocs))
+        # Get decades between major ticks.
+        stride = (max(math.ceil(numdec / (numticks - 1)), 1)
+                  if mpl.rcParams['_internal.classic_mode']
+                  else numdec // numticks + 1)
+        # Avoid axes with a single tick.
+        if haszero:
+            # Zero always gets a major tick.
+            if stride > maxdec:
+                stride = max(1, maxdec - 1)
+        else:
+            if stride >= numdec:
+                stride = max(1, numdec - 1)
+        # Determine the major ticks.
+        if haszero:
+            # Make sure 0 is ticked.
+            decades = np.concatenate(
+                (np.flip(np.arange(stride, -firstdec + 2 * stride, stride)),
+                 np.arange(0, lastdec + 2 * stride, stride))
+            )
+        else:
+            decades = np.arange(firstdec - stride, lastdec + 2 * stride, stride)
 
-    def view_limits(self, vmin, vmax):
-        """Try to choose the view limits intelligently."""
-        b = self._base
-        if vmax < vmin:
-            vmin, vmax = vmax, vmin
+        # Does subs include anything other than 1?  Essentially a hack to know
+        # whether we're a major or a minor locator.
+        if len(subs) > 1 or (len(subs) == 1 and subs[0] != 1.0):
+            # Minor locator.
+            if stride == 1:
+                ticklocs = []
+                for dec in decades:
+                    if dec > 0:
+                        ticklocs.append(subs * self._undec(dec))
+                    elif dec < 0:
+                        ticklocs.append(np.flip(subs * self._undec(dec)))
+                    else:
+                        if self._linscale < 0.5:
+                            # Don't add minor ticks around 0, it's too camped.
+                            zeroticks = np.array([])
+                        else:
+                            # We add the usual subs as well as the next lower decade.
+                            zeropow = self._undec(1) / self._base
+                            zeroticks = subs * zeropow
+                            if subs[0] != 1.0:
+                                zeroticks = np.concatenate(([zeropow], zeroticks))
+                        ticklocs.append(np.flip(-zeroticks))
+                        ticklocs.append([0.0])
+                        ticklocs.append(zeroticks)
+                ticklocs = np.concatenate(ticklocs)
+            else:
+                ticklocs = np.array([])
+        else:
+            # Major locator.
+            ticklocs = np.power(self._base, decades)
 
-        if mpl.rcParams['axes.autolimit_mode'] == 'round_numbers':
-            vmin = _decade_less_equal(vmin, b)
-            vmax = _decade_greater_equal(vmax, b)
-            if vmin == vmax:
-                vmin = _decade_less(vmin, b)
-                vmax = _decade_greater(vmax, b)
+        _log.debug('ticklocs %r', ticklocs)
+        if (len(subs) > 1
+                and stride == 1
+                and ((vmin <= ticklocs) & (ticklocs <= vmax)).sum() <= 1):
+            # If we're a minor locator *that expects at least two ticks per
+            # decade* and the major locator stride is 1 and there's no more
+            # than one minor tick, switch to AutoLocator.
+            return AutoLocator().tick_values(vmin, vmax)
+        else:
+            return self.raise_if_exceeds(ticklocs)
 
-        return mtransforms.nonsingular(vmin, vmax)
+    def _pos(self, val):
+        """
+        Calculate the normalized position of the value on the axis.
+        It is normalized such that the distance between two logarithmic decades
+        is 1 and the position of linthresh is linscale.
+        """
+        sign, val = np.sign(val), np.abs(val) / self._linthresh
+        if val > 1:
+            val = self._linscale + np.log(val) / np.log(self._base)
+        else:
+            val *= self._linscale
+        return sign * val
+
+    def _unpos(self, val):
+        """The inverse of _pos."""
+        sign, val = np.sign(val), np.abs(val)
+        if val > self._linscale:
+            val = np.power(self._base, val - self._linscale)
+        else:
+            val /= self._linscale
+        return sign * val * self._linthresh
+
+    def _firstdec(self):
+        """
+        Get the first decade (i.e. first positive major tick candidate).
+        It shall be at least half the width of a logarithmic decade from the
+        origin (i.e. its _pos shall be at least 0.5).
+        """
+        firstexp = np.ceil(np.log(self._unpos(0.5)) / np.log(self._base))
+        firstpow = np.power(self._base, firstexp)
+        return firstexp, firstpow
 
+    def _dec(self, val):
+        """
+        Calculate the decade number of the value. The first decade to have a
+        position (given by _pos) of at least 0.5 is given the number 1, the
+        value 0 is given the decade number 0.
+        """
+        firstexp, firstpow = self._firstdec()
+        sign, val = np.sign(val), np.abs(val)
+        if val > firstpow:
+            val = np.log(val) / np.log(self._base) - firstexp + 1
+        else:
+            # We scale linearly in order to get a monotonous mapping between
+            # 0 and 1, though the linear nature is arbitrary.
+            val /= firstpow
+        return sign * val
+
+    def _undec(self, val):
+        """The inverse of _dec."""
+        firstexp, firstpow = self._firstdec()
+        sign, val = np.sign(val), np.abs(val)
+        if val > 1:
+            val = np.power(self._base, val - 1 + firstexp)
+        else:
+            val *= firstpow
+        return sign * val
+
+    def view_limits(self, vmin, vmax):
+        """Try to choose the view limits intelligently."""
+        vmin, vmax = self.nonsingular(vmin, vmax)
+        if mpl.rcParams['axes.autolimit_mode'] == 'round_numbers':
+            vmin = self._undec(np.floor(self._dec(vmin)))
+            vmax = self._undec(np.ceil(self._dec(vmax)))
+        return vmin, vmax
 
 class AsinhLocator(Locator):
     """
