logitscale: add tests for LogitFormatter

jb-leger · jb-leger · commit cfbaeb903524 · 2019-06-10T12:10:17.000+02:00
diff --git a/lib/matplotlib/tests/test_ticker.py b/lib/matplotlib/tests/test_ticker.py
@@ -3,6 +3,7 @@
 import numpy as np
 from numpy.testing import assert_almost_equal, assert_array_equal
 import pytest
+import re
 
 import matplotlib
 import matplotlib.pyplot as plt
@@ -769,6 +770,143 @@ def test_LogFormatter_call(self, val):
         assert temp_lf(val) == str(val)
 
 
+class TestLogitFormatter:
+    @staticmethod
+    def logit_deformatter(string):
+        r"""
+        Parser to convert string as r'$\mathdefault{1.41\cdot10^{-4}}$' in
+        float 1.41e-4, as '0.5' or as r'$\mathdefault{\frac{1}{2}}$' in float
+        0.5,
+        """
+        match = re.match(
+            r"[^\d]*"
+            r"(?P<comp>1-)?"
+            r"(?P<mant>\d*\.?\d*)?"
+            r"(?:\\cdot)?"
+            r"(?:10\^\{(?P<expo>-?\d*)})?"
+            r"[^\d]*$",
+            string,
+        )
+        if match:
+            comp = match["comp"] is not None
+            mantissa = (
+                float(match["mant"])
+                if (match["mant"] is not None and len(match["mant"]) > 0)
+                else 1
+            )
+            expo = int(match["expo"]) if match["expo"] is not None else 0
+            value = mantissa * 10 ** expo
+            if comp:
+                return 1 - value
+            return value
+        match = re.match(
+            r"[^\d]*\\frac\{(?P<num>\d+)\}\{(?P<deno>\d+)\}[^\d]*$", string
+        )
+        if match:
+            num, deno = float(match["num"]), float(match["deno"])
+            return num / deno
+        raise ValueError("not formatted by LogitFormatter")
+
+    decade_test = (
+        [10 ** (-i) for i in range(1, 10)]
+        + [1 - 10 ** (-i) for i in range(1, 10)]
+        + [1 / 2]
+    )
+    decade_test.sort()
+
+    @pytest.mark.parametrize("x", decade_test)
+    def test_basic(self, x):
+        """
+        Test the formatted value correspond to the value for ideal ticks in
+        logit space.
+        """
+        formatter = mticker.LogitFormatter(use_overline=False)
+        formatter.set_locs(self.decade_test)
+        s = formatter(x)
+        x2 = TestLogitFormatter.logit_deformatter(s)
+        assert np.abs(x - x2) < 1e-10
+
+    @pytest.mark.parametrize("x", 1 / (1 + np.exp(-np.linspace(-7, 7, 10))))
+    def test_variablelength(self, x):
+        """
+        The format lenght should change depending on the neighbor labels.
+        """
+        formatter = mticker.LogitFormatter(use_overline=False)
+        for N in (10, 20, 50, 100, 200, 1000, 2000, 5000, 10000):
+            if x + 1 / N < 1:
+                formatter.set_locs([x - 1 / N, x, x + 1 / N])
+                sx = formatter(x)
+                sx1 = formatter(x + 1 / N)
+                d = TestLogitFormatter.logit_deformatter(
+                    sx1
+                ) - TestLogitFormatter.logit_deformatter(sx)
+                assert d > 0
+                assert d < 2 / N
+
+    lims_minor_major = [
+        ((5e-8, 1 - 5e-8), ((25, False), (75, False))),
+        ((5e-5, 1 - 5e-5), ((25, False), (75, True))),
+        ((5e-2, 1 - 5e-2), ((25, True), (75, True))),
+    ]
+
+    @pytest.mark.parametrize("lims, cases", lims_minor_major)
+    def test_minor_vs_major(self, lims, cases):
+        """
+        Test minor/major displays.
+        """
+
+        min_loc = mticker.LogitLocator(minor=True)
+        min_form = mticker.LogitFormatter(minor=True)
+        for threshold, has_minor in cases:
+            min_form.set_minor_threshold(threshold)
+            ticks = min_loc.tick_values(*lims)
+            formatted = min_form.format_ticks(ticks)
+            labelled = [f for f in formatted if len(f) > 0]
+            if has_minor:
+                assert len(labelled) > 0, (threshold, has_minor)
+            else:
+                assert len(labelled) == 0, (threshold, has_minor)
+
+    def test_minor_number(self):
+        """
+        Test the parameter minor_number
+        """
+        min_loc = mticker.LogitLocator(minor=True)
+        min_form = mticker.LogitFormatter(minor=True)
+        ticks = min_loc.tick_values(5e-2, 1 - 5e-2)
+        for minor_number in (2, 4, 8, 16):
+            min_form.set_minor_number(minor_number)
+            formatted = min_form.format_ticks(ticks)
+            labelled = [f for f in formatted if len(f) > 0]
+            assert len(labelled) == minor_number
+
+    def test_use_overline(self):
+        """
+        Test the parameter use_overline
+        """
+        x = 1 - 1e-2
+        fx1 = r"$\mathdefault{1-10^{-2}}$"
+        fx2 = r"$\mathdefault{\overline{10^{-2}}}$"
+        form = mticker.LogitFormatter(use_overline=False)
+        assert form(x) == fx1
+        form.use_overline(True)
+        assert form(x) == fx2
+        form.use_overline(False)
+        assert form(x) == fx1
+
+    @pytest.mark.parametrize("N", (100, 253, 754))
+    def test_format_data_short(self, N):
+        locs = np.linspace(0, 1, N)[1:-1]
+        form = mticker.LogitFormatter()
+        for x in locs:
+            fx = form.format_data_short(x)
+            if len(fx) > 2 and fx[0:2] == "1-":
+                x2 = 1 - float(fx[2:])
+            else:
+                x2 = float(fx)
+            assert np.abs(x - x2) < 1 / N
+
+
 class TestFormatStrFormatter:
     def test_basic(self):
         # test % style formatter
