Slightly more efficient impl.; more tests.

anntzer · anntzer · commit 39efb991b234 · 2016-02-17T23:53:51.000-08:00
diff --git a/lib/matplotlib/tests/test_ticker.py b/lib/matplotlib/tests/test_ticker.py
@@ -201,6 +201,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
@@ -155,6 +155,7 @@
 from matplotlib.externals import six
 
 import decimal
+import itertools
 import locale
 import math
 import numpy as np
@@ -565,36 +566,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
