Moved the string function parser to its own class in cbook. Added tes…

…ts. Since now parametrized is not used in test_colors.py anymore, the file has been readded in __init__.py for testing with nose
matplotlib · alvarosg · Oct 17, 2016 · Oct 18, 2016 · Oct 18, 2016 · Oct 18, 2016
commit 96871733250e10df87766bb9d8a496b4dc62ef5c
diff --git a/lib/matplotlib/__init__.py b/lib/matplotlib/__init__.py
@@ -1484,6 +1484,7 @@ def _jupyter_nbextension_paths():
     'matplotlib.tests.test_coding_standards',
     'matplotlib.tests.test_collections',
     'matplotlib.tests.test_colorbar',
+    'matplotlib.tests.test_colors',
     'matplotlib.tests.test_compare_images',
     'matplotlib.tests.test_container',
     'matplotlib.tests.test_contour',

diff --git a/lib/matplotlib/cbook.py b/lib/matplotlib/cbook.py
@@ -2696,3 +2696,80 @@ def __exit__(self, exc_type, exc_value, traceback):
                     os.rmdir(path)
                 except OSError:
                     pass
+
+
+class _StringFuncParser(object):
+    # Each element has:
+    #     -The direct function,
+    #     -The inverse function,
+    #     -A boolean indicating whether the function
+    #      is bounded in the interval 0-1
+
+    funcs = {'linear': (lambda x: x, lambda x: x, True),
+             'quadratic': (lambda x: x**2, lambda x: x**(1. / 2), True),
+             'cubic': (lambda x: x**3, lambda x: x**(1. / 3), True),
+             'sqrt': (lambda x: x**(1. / 2), lambda x: x**2, True),
+             'crt': (lambda x: x**(1. / 3), lambda x: x**3, True),
+             'log10': (lambda x: np.log10(x), lambda x: (10**(x)), False),
+             'log': (lambda x: np.log(x), lambda x: (np.exp(x)), False),
+             'power{a}': (lambda x, a: x**a,
+                          lambda x, a: x**(1. / a), True),
+             'root{a}': (lambda x, a: x**(1. / a),
+                         lambda x, a: x**a, True),
+             'log10(x+{a})': (lambda x, a: np.log10(x + a),
+                              lambda x, a: 10**x - a, True),
+             'log(x+{a})': (lambda x, a: np.log(x + a),
+                            lambda x, a: np.exp(x) - a, True)}
+
+    def __init__(self, str_func):
+        self.str_func = str_func
+
+    def is_string(self):
+        return not hasattr(self.str_func, '__call__')
+
+    def get_func(self):
+        return self._get_element(0)
+
+    def get_invfunc(self):
+        return self._get_element(1)
+
+    def is_bounded_0_1(self):
+        return self._get_element(2)
+
+    def _get_element(self, ind):
+        if not self.is_string():
+            raise ValueError("The argument passed is not a string.")
+
+        str_func = six.text_type(self.str_func)
+        # Checking if it comes with a parameter
+        param = None
+        regex = '\{(.*?)\}'
+        search = re.search(regex, str_func)
+        if search is not None:
+            parstring = search.group(1)
+
+            try:
+                param = float(parstring)
+            except:
+                raise ValueError("'a' in parametric function strings must be "
+                                 "replaced by a number different than 0, "
+                                 "e.g. 'log10(x+{0.1})'.")
+            if param == 0:
+                raise ValueError("'a' in parametric function strings must be "
+                                 "replaced by a number different than 0.")
+            str_func = re.sub(regex, '{a}', str_func)
+
+        try:
+            output = self.funcs[str_func][ind]
+            if param is not None:
+                output = (lambda x, output=output: output(x, param))
+
+            return output
+        except KeyError:
+            raise ValueError("%s: invalid function. The only strings "
+                             "recognized as functions are %s." %
+                             (str_func, self.funcs.keys()))
+        except:
+            raise ValueError("Invalid function. The only strings recognized "
+                             "as functions are %s." %
+                             (self.funcs.keys()))
diff --git a/lib/matplotlib/colors.py b/lib/matplotlib/colors.py
@@ -968,15 +968,15 @@ class FuncNorm(Normalize):
 
     def __init__(self, f, finv=None, **normalize_kw):
         """
-        Specify the function to be used (and its inverse), as well as other
+        Specify the function to be used, and its inverse, as well as other
         parameters to be passed to `Normalize`. The normalization will be
         calculated as (f(x)-f(vmin))/(f(max)-f(vmin)).
 
         Parameters
         ----------
         f : callable or string
             Function to be used for the normalization receiving a single
-            parameter, compatible with scalar values, and ndarrays.
+            parameter, compatible with scalar values and ndarrays.
             Alternatively a string from the list ['linear', 'quadratic',
             'cubic', 'sqrt', 'crt','log', 'log10', 'power{a}', 'root{a}',
             'log(x+{a})', 'log10(x+{a})'] can be used, replacing 'a' by a
@@ -1004,7 +1004,11 @@ def __init__(self, f, finv=None, **normalize_kw):
 
         """
 
-        f, finv = FuncNorm._func_parser([f, finv])
+        func_parser = cbook._StringFuncParser(f)
+        if func_parser.is_string():
+            f = func_parser.get_func()
+            finv = func_parser.get_invfunc()
+
         if finv is None:
             raise ValueError("Inverse function finv not provided")
 
@@ -1033,8 +1037,8 @@ def __call__(self, value, clip=None):
         -------
         result : masked array of floats
             Normalized data to the `[0.0, 1.0]` interval. If clip == False,
-            the values original below vmin or above vmax will be assigned to
-            -0.1 or 1.1, respectively.
+            the values original below vmin and above vmax will be assigned to
+            -0.1 and 1.1, respectively.
 
         """
         if clip is None:
@@ -1090,68 +1094,6 @@ def inverse(self, value):
             value * (self._f(vmax) - self._f(vmin)) + self._f(vmin))
         return value
 
-    @staticmethod
-    def _func_parser(funcsin, onlybounded=False):
-        if hasattr(funcsin[0], '__call__'):
-            return funcsin
-        # Each element has the direct, the inverse, and and interval indicating
-        # wether the function is bounded in the interval 0-1
-        funcs = {'linear': (lambda x: x, lambda x: x, True),
-                 'quadratic': (lambda x: x**2, lambda x: x**(1. / 2), True),
-                 'cubic': (lambda x: x**3, lambda x: x**(1. / 3), True),
-                 'sqrt': (lambda x: x**(1. / 2), lambda x: x**2, True),
-                 'crt': (lambda x: x**(1. / 3), lambda x: x**3, True),
-                 'log10': (lambda x: np.log10(x), lambda x: (10**(x)), False),
-                 'log': (lambda x: np.log(x), lambda x: (np.exp(x)), False),
-                 'power{a}': (lambda x, a: x**a,
-                              lambda x, a: x**(1. / a), True),
-                 'root{a}': (lambda x, a: x**(1. / a),
-                             lambda x, a: x**a, True),
-                 'log10(x+{a})': (lambda x, a: np.log10(x + a),
-                                  lambda x, a: 10**x - a, True),
-                 'log(x+{a})': (lambda x, a: np.log(x + a),
-                                lambda x, a: np.exp(x) - a, True)}
-
-        # Checking if it comes with a parameter
-        param = None
-        regex = '\{(.*?)\}'
-        search = re.search(regex, funcsin[0])
-        if search is not None:
-            parstring = search.group(1)
-
-            try:
-                param = float(parstring)
-            except:
-                raise ValueError("'a' in parametric function strings must be "
-                                 "replaced by a number different than 0, "
-                                 "e.g. 'log10(x+{0.1})'.")
-            if param == 0:
-                raise ValueError("'a' in parametric function strings must be "
-                                 "replaced by a number different than 0.")
-            funcsin[0] = re.sub(regex, '{a}', funcsin[0])
-
-        try:
-            output = funcs[six.text_type(funcsin[0])]
-            if onlybounded and not output[2]:
-                raise ValueError("Only functions bounded in the [0, 1]"
-                                 "domain are allowed: %s" %
-                                 [key for key in funcs.keys() if funcs[key][2]]
-                                 )
-
-            if param is not None:
-                output = (lambda x, output=output: output[0](x, param),
-                          lambda x, output=output: output[1](x, param),
-                          output[2])
-            return output[0:2]
-        except KeyError:
-            raise ValueError("%s: invalid function. The only strings "
-                             "recognized as functions are %s." %
-                             (funcsin[0], funcs.keys()))
-        except:
-            raise ValueError("Invalid function. The only strings recognized "
-                             "as functions are %s." %
-                             (funcs.keys()))
-
     @staticmethod
     def _fun_normalizer(fun):
         if fun(0.) == 0. and fun(1.) == 1.:
@@ -1246,10 +1188,10 @@ def __init__(self, flist,
                  refpoints_cm=[None],
                  **normalize_kw):
         """
-        Specify a series of functions, as well as intervals to map the data
+        Specify a series of functions, as well as intervals, to map the data
         space into `[0,1]`. Each individual function may not diverge in the
         [0,1] interval, as they will be normalized as
-        fnorm(x)=(f(x)-f(0))/(f(1)-f(0)), to guarantee that fnorm(0)=0 and
+        fnorm(x)=(f(x)-f(0))/(f(1)-f(0)) to guarantee that fnorm(0)=0 and
         fnorm(1)=1. Then each function will be transformed to map a different
         data range [d0, d1] into colormap ranges [cm0, cm1] as
         ftrans=fnorm((x-d0)/(d1-d0))*(cm1-cm0)+cm0.
@@ -1270,8 +1212,9 @@ def __init__(self, flist,
             Reference points for the colorbar ranges which will go as
             `[0., refpoints_cm[0]]`,... ,
             `[refpoints_cm[i], refpoints_cm[i+1]]`,
-            `[refpoints_cm[-1], 0.]`, and for the data
-            ranges which will go as `[self.vmin, refpoints_data[0]]`,... ,
+            `[refpoints_cm[-1], 0.]`,
+            and for the data ranges which will go as
+            `[self.vmin, refpoints_data[0]]`,... ,
             `[refpoints_data[i], refpoints_data[i+1]]`,
             `[refpoints_cm[-1], self.vmax]`
             It must satisfy
@@ -1335,17 +1278,30 @@ def __init__(self, flist,
                 "The values for the reference points for the data "
                 "`refpoints_data` must be monotonically increasing")
 
-        # Parsing the function strings if any:
         self._flist = []
         self._finvlist = []
         for i in range(len(flist)):
-            funs = FuncNorm._func_parser((flist[i], finvlist[i]))
-            if funs[0] is None or funs[1] is None:
+            func_parser = cbook._StringFuncParser(flist[i])
+            if func_parser.is_string():
+                if not func_parser.is_bounded_0_1():
+                    raise ValueError("Only functions bounded in the "
+                                     "[0, 1] domain are allowed.")
+
+                f = func_parser.get_func()
+                finv = func_parser.get_invfunc()
+            else:
+                f = flist[i]
+                finv = finvlist[i]
+            if f is None:
+                raise ValueError(
+                    "Function not provided for %i range" % i)
+
+            if finv is None:
                 raise ValueError(
                     "Inverse function not provided for %i range" % i)
 
-            self._flist.append(FuncNorm._fun_normalizer(funs[0]))
-            self._finvlist.append(FuncNorm._fun_normalizer(funs[1]))
+            self._flist.append(FuncNorm._fun_normalizer(f))
+            self._finvlist.append(FuncNorm._fun_normalizer(finv))
 
         # We just say linear, becuase we cannot really make the function unless
         # We now vmin, and vmax, and that does happen till the object is called
@@ -1479,10 +1435,10 @@ def ticks(self, nticks=None):
 
 class MirrorPiecewiseNorm(PiecewiseNorm):
     """
-    Normalization alowing a dual `PiecewiseNorm` simmetrically around a point.
+    Normalization allowing a dual `PiecewiseNorm` symmetrically around a point.
 
     Data above `center_data` will be normalized independently that data below
-    it. If only one function is give, the normalization will be symmetric
+    it. If only one function is given, the normalization will be symmetric
     around that point.
     """
 
@@ -1492,13 +1448,8 @@ def __init__(self,
                  center_data=0.0, center_cm=.5,
                  **normalize_kw):
         """
-        Specify a series of functions, as well as intervals to map the data
-        space into `[0,1]`. Each individual function may not diverge in the
-        [0,1] interval, as they will be normalized as
-        fnorm(x)=(f(x)-f(0))/(f(1)-f(0)), to guarantee that fnorm(0)=0 and
-        fnorm(1)=1. Then each function will be transformed to map a different
-        data range [d0, d1] into colormap ranges [cm0, cm1] as
-        ftrans=fnorm((x-d0)/(d1-d0))*(cm1-cm0)+cm0.
+        Specify two functions to normalize the data above and below a
+        provided reference point.
 
         Parameters
         ----------
@@ -1548,8 +1499,22 @@ def __init__(self,
             fneg = fpos
             fneginv = fposinv
 
-        fpos, fposinv = PiecewiseNorm._func_parser([fpos, fposinv])
-        fneg, fneginv = PiecewiseNorm._func_parser([fneg, fneginv])
        error_bounded = ("Only functions bounded in the "
+                         "[0, 1] domain are allowed.")
+
+        func_parser = cbook._StringFuncParser(fpos)
+        if func_parser.is_string():
+            if not func_parser.is_bounded_0_1():
+                raise ValueError(error_bounded)
+            fpos = func_parser.get_func()
+            fposinv = func_parser.get_invfunc()
+
+        func_parser = cbook._StringFuncParser(fneg)
+        if func_parser.is_string():
+            if not func_parser.is_bounded_0_1():
+                raise ValueError(error_bounded)
+            fneg = func_parser.get_func()
+            fneginv = func_parser.get_invfunc()
 
         if fposinv is None:
             raise ValueError(
@@ -1565,6 +1530,13 @@ def __init__(self,
         refpoints_cm = np.array([center_cm])
         refpoints_data = np.array([center_data])
 
+        # It is important to normalize the functions before
+        # applying the -fneg(-x + 1) + 1) transformation
+        fneg = FuncNorm._fun_normalizer(fneg)
+        fpos = FuncNorm._fun_normalizer(fpos)
+        fposinv = FuncNorm._fun_normalizer(fposinv)
+        fneginv = FuncNorm._fun_normalizer(fneginv)
+
         flist = [(lambda x:(-fneg(-x + 1) + 1)), fpos]
         finvlist = [(lambda x:(-fneginv(-x + 1) + 1)), fposinv]
 
@@ -1582,7 +1554,7 @@ class MirrorRootNorm(MirrorPiecewiseNorm):
     `MirrorPiecewiseNorm`.
 
     Data above `center_data` will be normalized with a root of the order
-    `orderpos` and data below it with a symmetric root of order `orderg neg`.
+    `orderpos` and data below it with a symmetric root of order `orderneg`.
     If only `orderpos` function is given, the normalization will be completely
     mirrored.
 
@@ -1611,7 +1583,7 @@ def __init__(self, orderpos=2, orderneg=None,
             below `center_data` using `MirrorPiecewiseNorm`. Default
             `orderpos`.
         center_data : float, optional
-            Value in the data that will separate range. Must be
+            Value in the data that will separate the ranges. Must be
             in the (vmin, vmax) range.
             Default 0.0.
         center_cm : float, optional

diff --git a/lib/matplotlib/tests/test_cbook.py b/lib/matplotlib/tests/test_cbook.py
@@ -521,3 +521,36 @@ def test_flatiter():
 
     assert 0 == next(it)
     assert 1 == next(it)
+
+
+class TestFuncParser(object):
+    x_test = np.linspace(0.01, 0.5, 3)
+    validstrings = ['linear', 'quadratic', 'cubic', 'sqrt', 'crt',
+                    'log', 'log10', 'power{1.5}', 'root{2.5}',
+                    'log(x+{0.5})', 'log10(x+{0.1})']
+    results = [(lambda x: x),
+               (lambda x: x**2),
+               (lambda x: x**3),
+               (lambda x: x**(1. / 2)),
+               (lambda x: x**(1. / 3)),
+               (lambda x: np.log(x)),
+               (lambda x: np.log10(x)),
+               (lambda x: x**1.5),
+               (lambda x: x**(1 / 2.5)),
+               (lambda x: np.log(x + 0.5)),
+               (lambda x: np.log10(x + 0.1))]
+
+    @pytest.mark.parametrize("string", validstrings, ids=validstrings)
+    def test_inverse(self, string):
+        func_parser = cbook._StringFuncParser(string)
+        f = func_parser.get_func()
+        finv = func_parser.get_invfunc()
+        assert_array_almost_equal(finv(f(self.x_test)), self.x_test)
+
+    @pytest.mark.parametrize("string, func",
+                             zip(validstrings, results),
+                             ids=validstrings)
+    def test_values(self, string, func):
+        func_parser = cbook._StringFuncParser(string)
+        f = func_parser.get_func()
+        assert_array_almost_equal(f(self.x_test), func(self.x_test))