Improved offset text choice

The default offset-text choice was changed to only use significant digits that

are common to all ticks (e.g. 1231..1239 -> 1230, instead of 1231), except when

they straddle a relatively large multiple of a power of ten, in which case that

multiple is chosen (e.g. 1999..2001->2000).

from nose.tools import assert_equal, assert_raises

def test_ScalarFormatter_offset_value():

fig, ax = plt.subplots()

formatter = ax.get_xaxis().get_major_formatter()

def check_offset_for(left, right, offset):

ax.set_xlim(left, right)

# Update ticks.

next(ax.get_xaxis().iter_ticks())

assert_equal(formatter.offset, offset)

test_data = [(123, 189, 0),

(-189, -123, 0),

(12341, 12349, 12340),

(-12349, -12341, -12340),

(99999.5, 100010.5, 100000),

(-100010.5, -99999.5, -100000),

(99990.5, 100000.5, 100000),

(-100000.5, -99990.5, -100000),

(1233999, 1234001, 1234000),

(-1234001, -1233999, -1234000),

(1, 1, 1),

(123, 123, 120),

# Test cases courtesy of @WeatherGod

(.4538, .4578, .45),

(3789.12, 3783.1, 3780),

(45124.3, 45831.75, 45000),

(0.000721, 0.0007243, 0.00072),

(12592.82, 12591.43, 12590),

(9., 12., 0),

(900., 1200., 0),

(1900., 1200., 0),

(0.99, 1.01, 1),

(9.99, 10.01, 10),

(99.99, 100.01, 100),

(5.99, 6.01, 6),

(15.99, 16.01, 16),

(-0.452, 0.492, 0),

(-0.492, 0.492, 0),

(12331.4, 12350.5, 12300),

(-12335.3, 12335.3, 0)]

for left, right, offset in test_data:

yield check_offset_for, left, right, offset

yield check_offset_for, right, left, offset

import itertools

self._compute_offset()

def _compute_offset(self):

if locs is None or not len(locs):

# Restrict to visible ticks.

if not len(locs):

self.offset = 0

return

lmin, lmax = locs.min(), locs.max()

# 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_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

# 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

else 0)