Slightly more efficient impl.; more tests.

anntzer · anntzer · commit 0c39a78b040e · 2016-05-01T18:07:19.000-07:00
diff --git a/lib/matplotlib/tests/test_ticker.py b/lib/matplotlib/tests/test_ticker.py
@@ -180,6 +180,8 @@ def check_offset_for(left, right, offset):
                  (-100000.5, -99990.5, -100000),
                  (1233999, 1234001, 1234000),
                  (-1234001, -1233999, -1234000),
+                 (1, 1, 0),
+                 (123, 123, 123),
                  # Test cases courtesy of @WeatherGod
                  (.4538, .4578, .45),
                  (3789.12, 3783.1, 3780),
@@ -201,6 +203,7 @@ def check_offset_for(left, right, offset):
 
     for left, right, offset in test_data:
         yield check_offset_for, left, right, offset
+        yield check_offset_for, right, left, offset
 
 
 def _logfe_helper(formatter, base, locs, i, expected_result):
diff --git a/lib/matplotlib/ticker.py b/lib/matplotlib/ticker.py
@@ -164,6 +164,7 @@
 from matplotlib.externals import six
 
 import decimal
+import itertools
 import locale
 import math
 import numpy as np
@@ -680,36 +681,29 @@ def _compute_offset(self):
             self.offset = 0
             return
         lmin, lmax = locs.min(), locs.max()
-        # min, max comparing absolute values (we want division to round towards
-        # zero so we work on absolute values).
-        abs_min, abs_max = sorted([abs(float(lmin)), abs(float(lmax))])
         # Only use offset if there are at least two ticks and every tick has
         # the same sign.
         if lmin == lmax or lmin <= 0 <= lmax:
             self.offset = 0
             return
+        # min, max comparing absolute values (we want division to round towards
+        # zero so we work on absolute values).
+        abs_min, abs_max = sorted([abs(float(lmin)), abs(float(lmax))])
         sign = math.copysign(1, lmin)
         # What is the smallest power of ten such that abs_min and abs_max are
         # equal up to that precision?
         # Note: Internally using oom instead of 10 ** oom avoids some numerical
         # accuracy issues.
-        oom = math.ceil(math.log10(abs_max))
-        while True:
-            if abs_min // 10 ** oom != abs_max // 10 ** oom:
-                oom += 1
-                break
-            oom -= 1
+        oom_max = math.ceil(math.log10(abs_max))
+        oom = 1 + next(oom for oom in itertools.count(oom_max, -1)
+                       if abs_min // 10 ** oom != abs_max // 10 ** oom)
         if (abs_max - abs_min) / 10 ** oom <= 1e-2:
             # Handle the case of straddling a multiple of a large power of ten
             # (relative to the span).
             # What is the smallest power of ten such that abs_min and abs_max
-            # at most 1 apart?
-            oom = math.ceil(math.log10(abs_max))
-            while True:
-                if abs_max // 10 ** oom - abs_min // 10 ** oom > 1:
-                    oom += 1
-                    break
-                oom -= 1
+            # are no more than 1 apart at that precision?
+            oom = 1 + next(oom for oom in itertools.count(oom_max, -1)
+                           if abs_max // 10 ** oom - abs_min // 10 ** oom > 1)
         # Only use offset if it saves at least two significant digits.
         self.offset = (sign * (abs_max // 10 ** oom) * 10 ** oom
                        if abs_max // 10 ** oom >= 10
