BUG: Fixed bugs and addressed review comments

madphysicist · madphysicist · commit cc485ae9f25a · 2016-11-29T16:21:17.000-05:00
Made class attributes private
Using 4 inputs instead of two of variable type
Fixed docs and __all__ to correspond to actual PR
Fixed numpydoc formatting
diff --git a/lib/matplotlib/tests/test_ticker.py b/lib/matplotlib/tests/test_ticker.py
@@ -539,39 +539,44 @@ def test_percentformatter(xmax, decimals, symbol, x, display_range, expected):
     ('{x:b}', 8, False, -2, '-10'),
     ('{x:b}', 8, True, -2, '11111110'),
     ('{x:b}', 8, True, -700, '1000100'),
+    ('{x:b}', None, True, -500, '1000001100'),
     # Octal
     ('{x:o}', 8, False, 2, '2'),
     ('{x:o}', 8, True, 2, '2'),
     ('{x:o}', 8, False, -2, '-2'),
     ('{x:o}', 8, True, -2, '376'),
     ('{x:o}', 8, True, -700, '104'),
+    ('{x:o}', None, True, -500, '1014'),
     # Decimal
     ('{x:d}', 8, False, 2, '2'),
     ('{x:d}', 8, True, 2, '2'),
     ('{x:d}', 8, False, -2, '-2'),
     ('{x:d}', 8, True, -2, '254'),
     ('{x:d}', 8, True, -700, '68'),
+    ('{x:d}', None, True, -500, '524'),
     # n format omitted to avoid localization issues
     # Hexadecimal (lower)
     ('{x:x}', 8, False, 0xC, 'c'),
     ('{x:x}', 8, True, 0xC, 'c'),
     ('{x:x}', 8, False, -0xC, '-c'),
     ('{x:x}', 8, True, -0xC, 'f4'),
     ('{x:04x}', 8, True, -630, '008a'),
+    ('{x:x}', None, True, -500, '20c'),
     # Hexadecimal (upper)
     ('{x:X}', 8, False, 0xC, 'C'),
     ('{x:X}', 8, True, 0xC, 'C'),
     ('{x:X}', 8, False, -0xC, '-C'),
     ('{x:X}', 8, True, -0xC, 'F4'),
     ('{x:04X}', 8, True, -630, '008A'),
+    ('{x:X}', None, True, -500, '20C'),
 ])
 def test_IntegerFormatter(fmt, bits, unsigned, value, expected):
     """
     Verifies that numbers get converted to different bases correctly,
     and that floating point numbers get truncated.
     """
-    fmt = mticker.IntegerFormatter(fmt, bits, unsigned)
-    assert fmt(value) == expected
+    formatter = mticker.IntegerFormatter(fmt, unsigned=unsigned, bits=bits)
+    assert formatter(value) == expected
 
 
 def test_LinearScaleFormatter():
@@ -586,13 +591,15 @@ def baseFormatter(x, pos=None):
     outputs = ['{:0.2f}'.format(x) for x in np.arange(7.0)]
 
     # Check a simple case
-    fmt = mticker.LinearScaleFormatter(10, (1, 5), formatter=baseFormatter)
+    fmt = mticker.LinearScaleFormatter(in_end=10, out_start=1, out_end=5,
+                                       formatter=baseFormatter)
     for i, o in zip(inputs, outputs):
         print(i, fmt(i), o)
         assert fmt(i) == o
 
     # Check a reverse mapping
-    fmt = mticker.LinearScaleFormatter(10, (5, 1), formatter=baseFormatter)
+    fmt = mticker.LinearScaleFormatter(in_end=10, out_start=5, out_end=1,
+                                       formatter=baseFormatter)
     for i, o in zip(inputs, reversed(outputs)):
         print(i, fmt(i), o)
         assert fmt(i) == o
diff --git a/lib/matplotlib/ticker.py b/lib/matplotlib/ticker.py
@@ -154,11 +154,8 @@
 :class:`PercentFormatter`
     Format labels as a percentage
 
-:class:`BinaryIntFormatter`
-    Format labels as binary integers.
-
-:class:`HexIntFormatter`
-    Format labels as hexadecimal integers.
+:class:`IntegerFormatter`
+    Extension of :class:`StrMethodFormatter` to support integer formats.
 
 :class:`LinearScaleFormatter`
     Wrap another formatter to display transformed values.
@@ -204,9 +201,9 @@
            'LogFormatterExponent', 'LogFormatterMathtext',
            'IndexFormatter', 'LogFormatterSciNotation',
            'LogitFormatter', 'EngFormatter', 'PercentFormatter',
-           'LinearScaleFormatter', 'BinaryIntFormatter',
-           'HexIntFormatter', 'Locator', 'IndexLocator', 'FixedLocator',
-           'NullLocator', 'LinearLocator', 'LogLocator', 'AutoLocator',
+           'LinearScaleFormatter', 'IntegerFormatter', 'Locator',
+           'IndexLocator', 'FixedLocator', 'NullLocator',
+           'LinearLocator', 'LogLocator', 'AutoLocator',
            'MultipleLocator', 'MaxNLocator', 'AutoMinorLocator',
            'SymmetricalLogLocator', 'LogitLocator')
 
@@ -1335,21 +1332,21 @@ def transform(self, x):
         """
         Ensures that `x` is an integer.
 
-        If `self.unsigned` is `True`, then the integer is treated as a
-        positive number of size `self.bits`. If `self.bits` is `None`,
-        the number of bits is taken as `(-x).bit_length() - 1`.
+        If in unsigned mode, the integer is treated as a positive number
+        with the specified number of bits. The default number of bits is
+        taken as `(-x).bit_length() + 1`.
 
         Returns the transformed number.
         """
         x = int(x)
         if x < 0 and self._unsigned:
-            bits = (-x).bit_length() if self._bits is None else self._bits
+            bits = (-x).bit_length() + 1 if self._bits is None else self._bits
             x = x & ((1 << bits) - 1)
         return x
 
     def __call__(self, x, pos=None):
-        return super(IntegerFormatter, self).__call__(x=self.transform(x),
-                                                      pos=pos)
+        if x < 0: self.p = None
+        return super(IntegerFormatter, self).__call__(self.transform(x), pos)
 
 
 class LinearScaleFormatter(Formatter):
@@ -1360,67 +1357,67 @@ class LinearScaleFormatter(Formatter):
     This formatter can use any other formatter to actually render the
     ticks.
 
-    inRef: number or 2-element iterable
-        Bounds on the input range to match to the output range. These
-        numbers do not actually restrict the input in any way. They are
-        just reference points. If the range is a scalar, it will be
-        interpreted as ``(0, inRef)``.
-    outRef: number or 2-element iterable
-        Bounds on the output range to match to the input range. These
-        numbers do not actually restrict the output in any way. They are
-        just reference points. If the range is a scalar, it will be
-        interpreted as ``(0, outRef)``.
-    formatter: matplotlib.ticker.Formatter
+    in_start : number
+        Reference point on the input domain that matches `out_start` in
+        the output range. This number does not restrict the domain in
+        any way. Defaults to 0.0.
+    in_end : number
+        Reference point on the input domain that matches `out_end` in
+        the output range. This number does not restrict the domain in
+        any way. Defaults to 1.0.
+    out_start : number
+        Reference point on the output range that matches `in_start` in
+        the input domain. This number does not restrict the range in
+        any way. Defaults to 0.0.
+    out_end : number
+        Reference point on the output range that matches `in_end` in
+        the input domain. This number does not restrict the range in
+        any way. Defaults to 1.0.
+    formatter : matplotlib.ticker.Formatter
         The instance to delegate the actual formatting of the
         transformed value to. This does not have to be an instance of
         ``matplotlib.ticker.Formatter``. Any callable that accepts ``x``
-        and ``pos`` as arguments and returns a string will work.
+        and ``pos`` as arguments and returns a string will also work.
     """
-    def __init__(self, inRef=1.0, outRef=1.0, formatter=ScalarFormatter()):
-        def unpack(ref, name):
-            if np.iterable(ref):
-                ref = tuple(ref)
-                if len(ref) != 2:
-                    raise ValueError('Expected 2-element iterable for `{}`, '
-                                     'got {}.'.format(name, len(ref)))
-                return ref
-            return 0, ref
-
+    def __init__(self, in_start=0.0, in_end=1.0, out_start=0.0, out_end=1.0,
+                 formatter=ScalarFormatter()):
         # All these values are retained for debugging/extension.
-        # Only the minima are used explicitly.
-        self.iMin, self.iMax = unpack(inRef, 'in')
-        self.oMin, self.oMax = unpack(outRef, 'out')
-        self.formatter = formatter
+        # Only the starts are used explicitly.
+        self._in_start = in_start
+        self._in_end = in_end
+        self._out_start = out_start
+        self._out_end = out_end
+        self._formatter = formatter
 
-        # Precomputing the values that are used in addition to the minima
-        self.iRange = self.iMax - self.iMin
-        self.oRange = self.oMax - self.oMin
+        # Precomputing the values that are used in addition to the starts
+        self._in_range = self._in_end - self._in_start
+        self._out_range = self._out_end - self._out_start
 
     def transform(self, x):
         """
         Transforms a value from the input scale to the output scale.
         """
-        return (x - self.iMin) / self.iRange * self.oRange + self.oMin
+        return (x - self._in_start) / self._in_range * self._out_range + self._out_start
 
     def __call__(self, x, pos=None):
-        return self.formatter(self.transform(x), pos)
+        return self._formatter(self.transform(x), pos)
 
     def set_axis(self, ax):
-        if hasattr(self.formatter, 'set_axis'):
-            self.formatter.set_axis(ax)
+        if hasattr(self._formatter, 'set_axis'):
+            self._formatter.set_axis(ax)
 
     def get_offset(self):
-        if hasattr(self.formatter, 'get_axis'):
-            return self.formatter.get_offset()
+        if hasattr(self._formatter, 'get_axis'):
+            return self._formatter.get_offset()
         return super(LinearScaleFormatter, self).get_offset()
 
     def set_locs(self, locs):
-        if hasattr(self.formatter, 'set_locs'):
-            self.formatter.set_locs([self.transform(x) for x in locs])
+        if hasattr(self._formatter, 'set_locs'):
+            self._formatter.set_locs([self.transform(x) for x in locs])
 
     def fix_minus(self, s):
-        if hasattr(self.formatter, 'fix_minus'):
-            return self.formatter.fix_minus(s)
+        if hasattr(self._formatter, 'fix_minus'):
+            return self._formatter.fix_minus(s)
         return super(LinearScaleFormatter, self).fix_minus(s)
 
 
