matplotlib · efiring · Dec 15, 2016 · Nov 15, 2016 · Nov 15, 2016 · Nov 16, 2016
diff --git a/lib/matplotlib/cbook.py b/lib/matplotlib/cbook.py
@@ -2661,3 +2661,170 @@ def __exit__(self, exc_type, exc_value, traceback):
                     os.rmdir(path)
                 except OSError:
                     pass
+
+
+class _FuncInfo(object):
+    """
+    Class used to store a function
+
+    Each object has:
+    * The direct function (direct)
+    * The inverse function (inverse)
+    * A boolean indicating whether the function
+      is bounded in the interval 0-1 (bounded_0_1)
+
+    """
+    def __init__(self, direct, inverse, bounded_0_1):
+        self.direct = direct
+        self.inverse = inverse
+        self.bounded_0_1 = bounded_0_1
+
+    def copy(self):
+        return _FuncInfo(self.direct,
+                         self.inverse,
+                         self.bounded_0_1)
+
+
+class _StringFuncParser(object):
+    """
+    A class used to convert predefined strings into
+    _FuncInfo objects, or to directly obtain _FuncInfo
+    properties.
+
+    """
+
+    _funcs = {}
+    _funcs['linear'] = _FuncInfo(lambda x: x,
+                                 lambda x: x,
+                                 True)
+    _funcs['quadratic'] = _FuncInfo(lambda x: x**2,
+                                    lambda x: x**(1. / 2),
+                                    True)
+    _funcs['cubic'] = _FuncInfo(lambda x: x**3,
+                                lambda x: x**(1. / 3),
+                                True)
+    _funcs['sqrt'] = _FuncInfo(lambda x: x**(1. / 2),
+                               lambda x: x**2,
+                               True)
+    _funcs['cbrt'] = _FuncInfo(lambda x: x**(1. / 3),
+                               lambda x: x**3,
+                               True)
+    _funcs['log10'] = _FuncInfo(lambda x: np.log10(x),
+                                lambda x: (10**(x)),
+                                False)
+    _funcs['log'] = _FuncInfo(lambda x: np.log(x),
+                              lambda x: (np.exp(x)),
+                              False)
+    _funcs['x**{p}'] = _FuncInfo(lambda x, p: x**p[0],
+                                 lambda x, p: x**(1. / p[0]),
+                                 True)
+    _funcs['root{p}(x)'] = _FuncInfo(lambda x, p: x**(1. / p[0]),
+                                     lambda x, p: x**p,
+                                     True)
+    _funcs['log10(x+{p})'] = _FuncInfo(lambda x, p: np.log10(x + p[0]),
+                                       lambda x, p: 10**x - p[0],
+                                       True)
+    _funcs['log(x+{p})'] = _FuncInfo(lambda x, p: np.log(x + p[0]),
+                                     lambda x, p: np.exp(x) - p[0],
+                                     True)
+    _funcs['log{p}(x+{p})'] = _FuncInfo(lambda x, p: (np.log(x + p[1]) /
+                                                      np.log(p[0])),
+                                        lambda x, p: p[0]**(x) - p[1],
+                                        True)
+
+    def __init__(self, str_func):
+        """
+        Parameters
+        ----------
+        str_func : string
+            String to be parsed.
+
+        """
+        try:  # For python 2.7 and python 3+ compatibility
+            is_str = isinstance(str_func, basestring)
+        except NameError:
+            is_str = isinstance(str_func, str)
+
+        if not is_str:
+            raise ValueError("The argument passed is not a string.")
+        self._str_func = str_func
+        self._key, self._params = self._get_key_params()
+        self._func = self.get_func()
+
+    def get_func(self):
+        """
+        Returns the _FuncInfo object, replacing the relevant parameters if
+        necessary in the lambda functions.
+
+        """
+
+        func = self._funcs[self._key].copy()
+        if len(self._params) > 0:
+            m = func.direct
+            func.direct = (lambda x, m=m: m(x, self._params))
+            m = func.inverse
+            func.inverse = (lambda x, m=m: m(x, self._params))
+        return func
+
+    def get_directfunc(self):
+        """
+        Returns the callable for the direct function.
+
+        """
+        return self._func.direct
+
+    def get_invfunc(self):
+        """
+        Returns the callable for the inverse function.
+
+        """
+        return self._func.inverse
+
+    def is_bounded_0_1(self):
+        """
+        Returns a boolean indicating if the function is bounded
+        in the [0-1 interval].
+
+        """
+        return self._func.bounded_0_1
+
+    def _get_key_params(self):
+        str_func = six.text_type(self._str_func)
+        # Checking if it comes with parameters
+        regex = '\{(.*?)\}'
+        params = re.findall(regex, str_func)
+
+        if len(params) > 0:
+            for i in range(len(params)):
+                try:
+                    params[i] = float(params[i])
+                except:
+                    raise ValueError("'p' in parametric function strings must"
+                                     " be replaced by a number that is not "
+                                     "zero, e.g. 'log10(x+{0.1})'.")
+
+                if params[i] == 0:
+                    raise ValueError("'p' in parametric function strings must"
+                                     " be replaced by a number that is not "
+                                     "zero.")
+            str_func = re.sub(regex, '{p}', str_func)
+
+        try:
+            func = self._funcs[str_func]
+        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()))
+        if len(params) > 0:
+            func.direct(0.5, params)
+            try:
+                func.direct(0.5, params)
+            except:
+                raise ValueError("Invalid parameters set for '%s'." %
+                                 (str_func))
+
+        return str_func, params
diff --git a/lib/matplotlib/tests/test_cbook.py b/lib/matplotlib/tests/test_cbook.py
@@ -517,3 +517,57 @@ 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', 'cbrt',
+                    'log', 'log10', 'x**{1.5}', 'root{2.5}(x)',
+                    'log(x+{0.5})', 'log10(x+{0.1})', 'log{2}(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)),
+               (lambda x: np.log2(x + 0.1))]
+
+    bounded_list = [True, True, True, True, True,
+                    False, False, True, True,
+                    True, True, True]
+
+    @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_directfunc()
+        assert_array_almost_equal(f(self.x_test), func(self.x_test))
+
+    @pytest.mark.parametrize("string", validstrings, ids=validstrings)
+    def test_inverse(self, string):
+        func_parser = cbook._StringFuncParser(string)
+        f = func_parser.get_func()
+        fdir = f.direct
+        finv = f.inverse
+        assert_array_almost_equal(finv(fdir(self.x_test)), self.x_test)
+
+    @pytest.mark.parametrize("string", validstrings, ids=validstrings)
+    def test_get_invfunc(self, string):
+        func_parser = cbook._StringFuncParser(string)
+        finv1 = func_parser.get_invfunc()
+        finv2 = func_parser.get_func().inverse
+        assert_array_almost_equal(finv1(self.x_test), finv2(self.x_test))
+
+    @pytest.mark.parametrize("string, bounded",
+                             zip(validstrings, bounded_list),
+                             ids=validstrings)
+    def test_bounded(self, string, bounded):
+        func_parser = cbook._StringFuncParser(string)
+        b = func_parser.is_bounded_0_1()
+        assert_array_equal(b, bounded)