basic_data = [

(20, 100, np.array([20., 40., 60., 80., 100.])),

(0.001, 0.0001, np.array([0., 0.0002, 0.0004, 0.0006, 0.0008, 0.001])),

(-1e15, 1e15, np.array([-1.0e+15, -5.0e+14, 0e+00, 5e+14, 1.0e+15])),

(0, 0.85e-50, np.arange(6) * 2e-51),

(-0.85e-50, 0, np.arange(-5, 1) * 2e-51),

]

integer_data = [

(-0.1, 1.1, None, np.array([-1, 0, 1, 2])),

(-0.1, 0.95, None, np.array([-0.25, 0, 0.25, 0.5, 0.75, 1.0])),

(1, 55, [1, 1.5, 5, 6, 10], np.array([0, 15, 30, 45, 60])),

]

@pytest.mark.parametrize('vmin, vmax, expected', basic_data)

def test_basic(self, vmin, vmax, expected):

loc = mticker.MaxNLocator(nbins=5)

assert_almost_equal(loc.tick_values(vmin, vmax), expected)

@pytest.mark.parametrize('vmin, vmax, steps, expected', integer_data)

def test_integer(self, vmin, vmax, steps, expected):

loc = mticker.MaxNLocator(nbins=5, integer=True, steps=steps)

def test_basic(self):

loc = mticker.LinearLocator(numticks=3)

test_value = np.array([-0.8, -0.3, 0.2])

assert_almost_equal(loc.tick_values(-0.8, 0.2), test_value)

def test_set_params(self):

"""

loc = mticker.LinearLocator(numticks=2)

loc.set_params(numticks=8, presets={(0, 1): []})

assert loc.numticks == 8

def test_basic(self):

loc = mticker.MultipleLocator(base=3.147)

test_value = np.array([-9.441, -6.294, -3.147, 0., 3.147, 6.294,

9.441, 12.588])

assert_almost_equal(loc.tick_values(-7, 10), test_value)

def test_view_limits(self):

"""

with mpl.rc_context({'axes.autolimit_mode': 'data'}):

loc = mticker.MultipleLocator(base=3.147)

assert_almost_equal(loc.view_limits(-5, 5), (-5, 5))

def test_view_limits_round_numbers(self):

"""

with mpl.rc_context({'axes.autolimit_mode': 'round_numbers'}):

loc = mticker.MultipleLocator(base=3.147)

assert_almost_equal(loc.view_limits(-4, 4), (-6.294, 6.294))

def test_set_params(self):

"""

mult = mticker.MultipleLocator(base=0.7)

mult.set_params(base=1.7)

def test_basic(self):

fig, ax = plt.subplots()

ax.set_xlim(0, 1.39)

ax.minorticks_on()

test_value = np.array([0.05, 0.1, 0.15, 0.25, 0.3, 0.35, 0.45,

0.5, 0.55, 0.65, 0.7, 0.75, 0.85, 0.9,

0.95, 1.05, 1.1, 1.15, 1.25, 1.3, 1.35])

assert_almost_equal(ax.xaxis.get_ticklocs(minor=True), test_value)

# NB: the following values are assuming that *xlim* is [0, 5]

params = [

(0, 0), # no major tick => no minor tick either

(1, 0) # a single major tick => no minor tick

]

@pytest.mark.parametrize('nb_majorticks, expected_nb_minorticks', params)

def test_low_number_of_majorticks(

self, nb_majorticks, expected_nb_minorticks):

# This test is related to issue #8804

fig, ax = plt.subplots()

xlims = (0, 5) # easier to test the different code paths

ax.set_xlim(*xlims)

ax.set_xticks(np.linspace(xlims[0], xlims[1], nb_majorticks))

ax.minorticks_on()

ax.xaxis.set_minor_locator(mticker.AutoMinorLocator())

assert len(ax.xaxis.get_minorticklocs()) == expected_nb_minorticks

majorstep_minordivisions = [(1, 5),

(2, 4),

(2.5, 5),

(5, 5),

(10, 5)]

# This test is meant to verify the parameterization for

# test_number_of_minor_ticks

def test_using_all_default_major_steps(self):

with mpl.rc_context({'_internal.classic_mode': False}):

majorsteps = [x[0] for x in self.majorstep_minordivisions]

np.testing.assert_allclose(majorsteps,

mticker.AutoLocator()._steps)

@pytest.mark.parametrize('major_step, expected_nb_minordivisions',

def test_number_of_minor_ticks(

self, major_step, expected_nb_minordivisions):

fig, ax = plt.subplots()

xlims = (0, major_step)

ax.set_xlim(*xlims)

ax.set_xticks(xlims)

ax.minorticks_on()

ax.xaxis.set_minor_locator(mticker.AutoMinorLocator())

nb_minor_divisions = len(ax.xaxis.get_minorticklocs()) + 1

assert nb_minor_divisions == expected_nb_minordivisions

limits = [(0, 1.39), (0, 0.139),

(0, 0.11e-19), (0, 0.112e-12),

(-2.0e-07, -3.3e-08), (1.20e-06, 1.42e-06),

(-1.34e-06, -1.44e-06), (-8.76e-07, -1.51e-06)]

reference = [

[0.05, 0.1, 0.15, 0.25, 0.3, 0.35, 0.45, 0.5, 0.55, 0.65, 0.7,

0.75, 0.85, 0.9, 0.95, 1.05, 1.1, 1.15, 1.25, 1.3, 1.35],

[0.005, 0.01, 0.015, 0.025, 0.03, 0.035, 0.045, 0.05, 0.055, 0.065,

0.07, 0.075, 0.085, 0.09, 0.095, 0.105, 0.11, 0.115, 0.125, 0.13,

0.135],

[5.00e-22, 1.00e-21, 1.50e-21, 2.50e-21, 3.00e-21, 3.50e-21, 4.50e-21,

5.00e-21, 5.50e-21, 6.50e-21, 7.00e-21, 7.50e-21, 8.50e-21, 9.00e-21,

9.50e-21, 1.05e-20, 1.10e-20],

[5.00e-15, 1.00e-14, 1.50e-14, 2.50e-14, 3.00e-14, 3.50e-14, 4.50e-14,

5.00e-14, 5.50e-14, 6.50e-14, 7.00e-14, 7.50e-14, 8.50e-14, 9.00e-14,

9.50e-14, 1.05e-13, 1.10e-13],

[-1.95e-07, -1.90e-07, -1.85e-07, -1.75e-07, -1.70e-07, -1.65e-07,

-1.55e-07, -1.50e-07, -1.45e-07, -1.35e-07, -1.30e-07, -1.25e-07,

-1.15e-07, -1.10e-07, -1.05e-07, -9.50e-08, -9.00e-08, -8.50e-08,

-7.50e-08, -7.00e-08, -6.50e-08, -5.50e-08, -5.00e-08, -4.50e-08,

-3.50e-08],

[1.21e-06, 1.22e-06, 1.23e-06, 1.24e-06, 1.26e-06, 1.27e-06, 1.28e-06,

1.29e-06, 1.31e-06, 1.32e-06, 1.33e-06, 1.34e-06, 1.36e-06, 1.37e-06,

1.38e-06, 1.39e-06, 1.41e-06, 1.42e-06],

[-1.435e-06, -1.430e-06, -1.425e-06, -1.415e-06, -1.410e-06,

-1.405e-06, -1.395e-06, -1.390e-06, -1.385e-06, -1.375e-06,

-1.370e-06, -1.365e-06, -1.355e-06, -1.350e-06, -1.345e-06],

[-1.48e-06, -1.46e-06, -1.44e-06, -1.42e-06, -1.38e-06, -1.36e-06,

-1.34e-06, -1.32e-06, -1.28e-06, -1.26e-06, -1.24e-06, -1.22e-06,

-1.18e-06, -1.16e-06, -1.14e-06, -1.12e-06, -1.08e-06, -1.06e-06,

-1.04e-06, -1.02e-06, -9.80e-07, -9.60e-07, -9.40e-07, -9.20e-07,

-8.80e-07]]

additional_data = list(zip(limits, reference))

@pytest.mark.parametrize('lim, ref', additional_data)

def test_additional(self, lim, ref):

fig, ax = plt.subplots()

ax.minorticks_on()

ax.grid(True, 'minor', 'y', linewidth=1)

ax.grid(True, 'major', color='k', linewidth=1)

ax.set_ylim(lim)

def test_basic(self):

loc = mticker.LogLocator(numticks=5)

with pytest.raises(ValueError):

loc.tick_values(0, 1000)

test_value = np.array([1.00000000e-05, 1.00000000e-03, 1.00000000e-01,

1.00000000e+01, 1.00000000e+03, 1.00000000e+05,

1.00000000e+07, 1.000000000e+09])

assert_almost_equal(loc.tick_values(0.001, 1.1e5), test_value)

loc = mticker.LogLocator(base=2)

test_value = np.array([0.5, 1., 2., 4., 8., 16., 32., 64., 128., 256.])

assert_almost_equal(loc.tick_values(1, 100), test_value)

def test_switch_to_autolocator(self):

loc = mticker.LogLocator(subs="all")

assert_array_equal(loc.tick_values(0.45, 0.55),

[0.44, 0.46, 0.48, 0.5, 0.52, 0.54, 0.56])

# check that we *skip* 1.0, and 10, because this is a minor locator

loc = mticker.LogLocator(subs=np.arange(2, 10))

assert 1.0 not in loc.tick_values(0.9, 20.)

assert 10.0 not in loc.tick_values(0.9, 20.)

def test_set_params(self):

"""

loc = mticker.LogLocator()

loc.set_params(numticks=7, numdecs=8, subs=[2.0], base=4)

assert loc.numticks == 7

assert loc.numdecs == 8

assert loc._base == 4

def test_set_params(self):

"""

loc = mticker.NullLocator()

with pytest.warns(UserWarning):

@staticmethod

def isclose(x, y):

return (np.isclose(-np.log(1/x-1), -np.log(1/y-1))

if 0 < x < 1 and 0 < y < 1 else False)

@staticmethod

def assert_almost_equal(x, y):

ax = np.array(x)

ay = np.array(y)

assert np.all(ax > 0) and np.all(ax < 1)

assert np.all(ay > 0) and np.all(ay < 1)

lx = -np.log(1/ax-1)

ly = -np.log(1/ay-1)

ref_basic_limits = [

(5e-2, 1 - 5e-2),

(5e-3, 1 - 5e-3),

(5e-4, 1 - 5e-4),

(5e-5, 1 - 5e-5),

(5e-6, 1 - 5e-6),

(5e-7, 1 - 5e-7),

(5e-8, 1 - 5e-8),

(5e-9, 1 - 5e-9),

]

ref_basic_major_ticks = [

1 / (10 ** np.arange(1, 3)),

1 / (10 ** np.arange(1, 4)),

1 / (10 ** np.arange(1, 5)),

1 / (10 ** np.arange(1, 6)),

1 / (10 ** np.arange(1, 7)),

1 / (10 ** np.arange(1, 8)),

1 / (10 ** np.arange(1, 9)),

1 / (10 ** np.arange(1, 10)),

]

ref_maxn_limits = [(0.4, 0.6), (5e-2, 2e-1), (1 - 2e-1, 1 - 5e-2)]

@pytest.mark.parametrize(

def test_basic_major(self, lims, expected_low_ticks):

"""

expected_ticks = sorted(

[*expected_low_ticks, 0.5, *(1 - expected_low_ticks)]

)

loc = mticker.LogitLocator(nbins=100)

_LogitHelper.assert_almost_equal(

loc.tick_values(*lims),

expected_ticks

)

@pytest.mark.parametrize("lims", ref_maxn_limits)

def test_maxn_major(self, lims):

"""

loc = mticker.LogitLocator(nbins=100)

maxn_loc = mticker.MaxNLocator(nbins=100, steps=[1, 2, 5, 10])

for nbins in (4, 8, 16):

loc.set_params(nbins=nbins)

maxn_loc.set_params(nbins=nbins)

ticks = loc.tick_values(*lims)

maxn_ticks = maxn_loc.tick_values(*lims)

assert ticks.shape == maxn_ticks.shape

assert (ticks == maxn_ticks).all()

@pytest.mark.parametrize("lims", ref_basic_limits + ref_maxn_limits)

def test_nbins_major(self, lims):

"""

basic_needed = int(-np.floor(np.log10(lims[0]))) * 2 + 1

loc = mticker.LogitLocator(nbins=100)

for nbins in range(basic_needed, 2, -1):

loc.set_params(nbins=nbins)

assert len(loc.tick_values(*lims)) <= nbins + 2

@pytest.mark.parametrize(

def test_minor(self, lims, expected_low_ticks):

"""

expected_ticks = sorted(

[*expected_low_ticks, 0.5, *(1 - expected_low_ticks)]

)

basic_needed = len(expected_ticks)

loc = mticker.LogitLocator(nbins=100)

minor_loc = mticker.LogitLocator(nbins=100, minor=True)

for nbins in range(basic_needed, 2, -1):

loc.set_params(nbins=nbins)

minor_loc.set_params(nbins=nbins)

major_ticks = loc.tick_values(*lims)

minor_ticks = minor_loc.tick_values(*lims)

if len(major_ticks) >= len(expected_ticks):

# no subsample, we must have a lot of minors ticks

assert (len(major_ticks) - 1) * 5 < len(minor_ticks)

else:

# subsample

_LogitHelper.assert_almost_equal(

sorted([*major_ticks, *minor_ticks]), expected_ticks)

def test_minor_attr(self):

loc = mticker.LogitLocator(nbins=100)

assert not loc.minor

loc.minor = True

assert loc.minor

loc.set_params(minor=False)

assert not loc.minor

acceptable_vmin_vmax = [

*(2.5 ** np.arange(-3, 0)),

*(1 - 2.5 ** np.arange(-3, 0)),

]

@pytest.mark.parametrize(

def test_nonsingular_ok(self, lims):

"""

loc = mticker.LogitLocator()

lims2 = loc.nonsingular(*lims)

assert sorted(lims) == sorted(lims2)

@pytest.mark.parametrize("okval", acceptable_vmin_vmax)

def test_nonsingular_nok(self, okval):

"""

loc = mticker.LogitLocator()

vmin, vmax = (-1, okval)

vmin2, vmax2 = loc.nonsingular(vmin, vmax)

assert vmax2 == vmax

assert 0 < vmin2 < vmax2

vmin, vmax = (okval, 2)

vmin2, vmax2 = loc.nonsingular(vmin, vmax)

assert vmin2 == vmin

def test_set_params(self):

"""

fixed = mticker.FixedLocator(range(0, 24), nbins=5)

fixed.set_params(nbins=7)

def test_set_params(self):

"""

index = mticker.IndexLocator(base=3, offset=4)

index.set_params(base=7, offset=7)

assert index._base == 7

def test_set_params(self):

"""

sym = mticker.SymmetricalLogLocator(base=10, linthresh=1)

sym.set_params(subs=[2.0], numticks=8)

assert sym._subs == [2.0]

@pytest.mark.parametrize('x, label', [(-2, ''),

def test_formatting(self, x, label):

with cbook._suppress_matplotlib_deprecation_warning():

formatter = mticker.IndexFormatter(['label0', 'label1', 'label2'])

offset_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, 0),

# 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),

]

use_offset_data = [True, False]

# (sci_type, scilimits, lim, orderOfMag, fewticks)

scilimits_data = [

(False, (0, 0), (10.0, 20.0), 0, False),

(True, (-2, 2), (-10, 20), 0, False),

(True, (-2, 2), (-20, 10), 0, False),

(True, (-2, 2), (-110, 120), 2, False),

(True, (-2, 2), (-120, 110), 2, False),

(True, (-2, 2), (-.001, 0.002), -3, False),

(True, (-7, 7), (0.18e10, 0.83e10), 9, True),

(True, (0, 0), (-1e5, 1e5), 5, False),

(True, (6, 6), (-1e5, 1e5), 6, False),

]

cursor_data = [

[0., "0.000"],

[0.0123, "0.012"],

[0.123, "0.123"],

[1.23, "1.230"],

[12.3, "12.300"],

]

@pytest.mark.parametrize('unicode_minus, result',

def test_unicode_minus(self, unicode_minus, result):

mpl.rcParams['axes.unicode_minus'] = unicode_minus

assert (

plt.gca().xaxis.get_major_formatter().format_data_short(-1).strip()

== result)

@pytest.mark.parametrize('left, right, offset', offset_data)

def test_offset_value(self, left, right, offset):

fig, ax = plt.subplots()

formatter = ax.xaxis.get_major_formatter()

with (pytest.warns(UserWarning, match='Attempting to set identical')

if left == right else nullcontext()):

ax.set_xlim(left, right)

ax.xaxis._update_ticks()

assert formatter.offset == offset

with (pytest.warns(UserWarning, match='Attempting to set identical')

if left == right else nullcontext()):

ax.set_xlim(right, left)

ax.xaxis._update_ticks()

assert formatter.offset == offset

@pytest.mark.parametrize('use_offset', use_offset_data)

def test_use_offset(self, use_offset):

with mpl.rc_context({'axes.formatter.useoffset': use_offset}):

tmp_form = mticker.ScalarFormatter()

assert use_offset == tmp_form.get_useOffset()

def test_use_locale(self):

conv = locale.localeconv()

sep = conv['thousands_sep']

if not sep or conv['grouping'][-1:] in ([], [locale.CHAR_MAX]):

pytest.skip('Locale does not apply grouping') # pragma: no cover

with mpl.rc_context({'axes.formatter.use_locale': True}):

tmp_form = mticker.ScalarFormatter()

assert tmp_form.get_useLocale()

tmp_form.create_dummy_axis()

tmp_form.set_bounds(0, 10)

tmp_form.set_locs([1, 2, 3])

assert sep in tmp_form(1e9)

@pytest.mark.parametrize(

def test_scilimits(self, sci_type, scilimits, lim, orderOfMag, fewticks):

tmp_form = mticker.ScalarFormatter()

tmp_form.set_scientific(sci_type)

tmp_form.set_powerlimits(scilimits)

fig, ax = plt.subplots()

ax.yaxis.set_major_formatter(tmp_form)

ax.set_ylim(*lim)

if fewticks:

ax.yaxis.set_major_locator(mticker.MaxNLocator(4))

tmp_form.set_locs(ax.yaxis.get_majorticklocs())

assert orderOfMag == tmp_form.orderOfMagnitude

@pytest.mark.parametrize('data, expected', cursor_data)

def test_cursor_precision(self, data, expected):

fig, ax = plt.subplots()

ax.set_xlim(-1, 1) # Pointing precision of 0.001.

fmt = ax.xaxis.get_major_formatter().format_data_short

assert fmt(data) == expected

@pytest.mark.parametrize('data, expected', cursor_data)

def test_cursor_dummy_axis(self, data, expected):

# Issue #17624

sf = mticker.ScalarFormatter()

sf.create_dummy_axis()

sf.set_bounds(0, 10)

fmt = sf.format_data_short

"""Allow Formatter to be called without having a "full" plot set up."""

def __init__(self, vmin=1, vmax=10):

self.vmin = vmin

self.vmax = vmax

def get_view_interval(self):

param_data = [

(True, 4, np.arange(-3, 4.0), np.arange(-3, 4.0),

['-3', '-2', '-1', '0', '1', '2', '3']),

# With labelOnlyBase=False, non-integer powers should be nicely

# formatted.

(False, 10, np.array([0.1, 0.00001, np.pi, 0.2, -0.2, -0.00001]),

range(6), ['0.1', '1e-05', '3.14', '0.2', '-0.2', '-1e-05']),

(False, 50, np.array([3, 5, 12, 42], dtype=float), range(6),

['3', '5', '12', '42']),

]

base_data = [2.0, 5.0, 10.0, np.pi, np.e]

@pytest.mark.parametrize(

@pytest.mark.parametrize('base', base_data)

def test_basic(self, labelOnlyBase, base, exponent, locs, positions,

expected):

formatter = mticker.LogFormatterExponent(base=base,

labelOnlyBase=labelOnlyBase)

formatter.axis = FakeAxis(1, base**exponent)

vals = base**locs

labels = [formatter(x, pos) for (x, pos) in zip(vals, positions)]

assert labels == expected

def test_blank(self):

# Should be a blank string for non-integer powers if labelOnlyBase=True

formatter = mticker.LogFormatterExponent(base=10, labelOnlyBase=True)

formatter.axis = FakeAxis()

fmt = mticker.LogFormatterMathtext()

test_data = [

(0, 1, '$\\mathdefault{10^{0}}$'),

(0, 1e-2, '$\\mathdefault{10^{-2}}$'),

(0, 1e2, '$\\mathdefault{10^{2}}$'),

(3, 1, '$\\mathdefault{1}$'),

(3, 1e-2, '$\\mathdefault{0.01}$'),

(3, 1e2, '$\\mathdefault{100}$'),

(3, 1e-3, '$\\mathdefault{10^{-3}}$'),

(3, 1e3, '$\\mathdefault{10^{3}}$'),

]

@pytest.mark.parametrize('min_exponent, value, expected', test_data)

def test_min_exponent(self, min_exponent, value, expected):

with mpl.rc_context({'axes.formatter.min_exponent': min_exponent}):

test_data = [

(2, 0.03125, '$\\mathdefault{2^{-5}}$'),

(2, 1, '$\\mathdefault{2^{0}}$'),

(2, 32, '$\\mathdefault{2^{5}}$'),

(2, 0.0375, '$\\mathdefault{1.2\\times2^{-5}}$'),

(2, 1.2, '$\\mathdefault{1.2\\times2^{0}}$'),

(2, 38.4, '$\\mathdefault{1.2\\times2^{5}}$'),

(10, -1, '$\\mathdefault{-10^{0}}$'),

(10, 1e-05, '$\\mathdefault{10^{-5}}$'),

(10, 1, '$\\mathdefault{10^{0}}$'),

(10, 100000, '$\\mathdefault{10^{5}}$'),

(10, 2e-05, '$\\mathdefault{2\\times10^{-5}}$'),

(10, 2, '$\\mathdefault{2\\times10^{0}}$'),

(10, 200000, '$\\mathdefault{2\\times10^{5}}$'),

(10, 5e-05, '$\\mathdefault{5\\times10^{-5}}$'),

(10, 5, '$\\mathdefault{5\\times10^{0}}$'),

(10, 500000, '$\\mathdefault{5\\times10^{5}}$'),

]

@pytest.mark.style('default')

@pytest.mark.parametrize('base, value, expected', test_data)

def test_basic(self, base, value, expected):

formatter = mticker.LogFormatterSciNotation(base=base)

formatter.sublabel = {1, 2, 5, 1.2}

with mpl.rc_context({'text.usetex': False}):

pprint_data = [

(3.141592654e-05, 0.001, '3.142e-5'),

(0.0003141592654, 0.001, '3.142e-4'),

(0.003141592654, 0.001, '3.142e-3'),

(0.03141592654, 0.001, '3.142e-2'),

(0.3141592654, 0.001, '3.142e-1'),

(3.141592654, 0.001, '3.142'),

(31.41592654, 0.001, '3.142e1'),

(314.1592654, 0.001, '3.142e2'),

(3141.592654, 0.001, '3.142e3'),

(31415.92654, 0.001, '3.142e4'),

(314159.2654, 0.001, '3.142e5'),

(1e-05, 0.001, '1e-5'),

(0.0001, 0.001, '1e-4'),

(0.001, 0.001, '1e-3'),

(0.01, 0.001, '1e-2'),

(0.1, 0.001, '1e-1'),

(1, 0.001, '1'),

(10, 0.001, '10'),

(100, 0.001, '100'),

(1000, 0.001, '1000'),

(10000, 0.001, '1e4'),

(100000, 0.001, '1e5'),

(3.141592654e-05, 0.015, '0'),

(0.0003141592654, 0.015, '0'),

(0.003141592654, 0.015, '0.003'),

(0.03141592654, 0.015, '0.031'),

(0.3141592654, 0.015, '0.314'),

(3.141592654, 0.015, '3.142'),

(31.41592654, 0.015, '31.416'),

(314.1592654, 0.015, '314.159'),

(3141.592654, 0.015, '3141.593'),

(31415.92654, 0.015, '31415.927'),

(314159.2654, 0.015, '314159.265'),

(1e-05, 0.015, '0'),

(0.0001, 0.015, '0'),

(0.001, 0.015, '0.001'),

(0.01, 0.015, '0.01'),

(0.1, 0.015, '0.1'),

(1, 0.015, '1'),

(10, 0.015, '10'),

(100, 0.015, '100'),

(1000, 0.015, '1000'),

(10000, 0.015, '10000'),

(100000, 0.015, '100000'),

(3.141592654e-05, 0.5, '0'),

(0.0003141592654, 0.5, '0'),

(0.003141592654, 0.5, '0.003'),

(0.03141592654, 0.5, '0.031'),

(0.3141592654, 0.5, '0.314'),

(3.141592654, 0.5, '3.142'),

(31.41592654, 0.5, '31.416'),

(314.1592654, 0.5, '314.159'),

(3141.592654, 0.5, '3141.593'),

(31415.92654, 0.5, '31415.927'),

(314159.2654, 0.5, '314159.265'),

(1e-05, 0.5, '0'),

(0.0001, 0.5, '0'),

(0.001, 0.5, '0.001'),

(0.01, 0.5, '0.01'),

(0.1, 0.5, '0.1'),

(1, 0.5, '1'),

(10, 0.5, '10'),

(100, 0.5, '100'),

(1000, 0.5, '1000'),

(10000, 0.5, '10000'),

(100000, 0.5, '100000'),

(3.141592654e-05, 5, '0'),

(0.0003141592654, 5, '0'),

(0.003141592654, 5, '0'),

(0.03141592654, 5, '0.03'),

(0.3141592654, 5, '0.31'),

(3.141592654, 5, '3.14'),

(31.41592654, 5, '31.42'),

(314.1592654, 5, '314.16'),

(3141.592654, 5, '3141.59'),

(31415.92654, 5, '31415.93'),

(314159.2654, 5, '314159.27'),

(1e-05, 5, '0'),

(0.0001, 5, '0'),

(0.001, 5, '0'),

(0.01, 5, '0.01'),

(0.1, 5, '0.1'),

(1, 5, '1'),

(10, 5, '10'),

(100, 5, '100'),

(1000, 5, '1000'),

(10000, 5, '10000'),

(100000, 5, '100000'),

(3.141592654e-05, 100, '0'),

(0.0003141592654, 100, '0'),

(0.003141592654, 100, '0'),

(0.03141592654, 100, '0'),

(0.3141592654, 100, '0.3'),

(3.141592654, 100, '3.1'),

(31.41592654, 100, '31.4'),

(314.1592654, 100, '314.2'),

(3141.592654, 100, '3141.6'),

(31415.92654, 100, '31415.9'),

(314159.2654, 100, '314159.3'),

(1e-05, 100, '0'),

(0.0001, 100, '0'),

(0.001, 100, '0'),

(0.01, 100, '0'),

(0.1, 100, '0.1'),

(1, 100, '1'),

(10, 100, '10'),

(100, 100, '100'),

(1000, 100, '1000'),

(10000, 100, '10000'),

(100000, 100, '100000'),

(3.141592654e-05, 1000000.0, '3.1e-5'),

(0.0003141592654, 1000000.0, '3.1e-4'),

(0.003141592654, 1000000.0, '3.1e-3'),

(0.03141592654, 1000000.0, '3.1e-2'),

(0.3141592654, 1000000.0, '3.1e-1'),

(3.141592654, 1000000.0, '3.1'),

(31.41592654, 1000000.0, '3.1e1'),

(314.1592654, 1000000.0, '3.1e2'),

(3141.592654, 1000000.0, '3.1e3'),

(31415.92654, 1000000.0, '3.1e4'),

(314159.2654, 1000000.0, '3.1e5'),

(1e-05, 1000000.0, '1e-5'),

(0.0001, 1000000.0, '1e-4'),

(0.001, 1000000.0, '1e-3'),

(0.01, 1000000.0, '1e-2'),

(0.1, 1000000.0, '1e-1'),

(1, 1000000.0, '1'),

(10, 1000000.0, '10'),

(100, 1000000.0, '100'),

(1000, 1000000.0, '1000'),

(10000, 1000000.0, '1e4'),

(100000, 1000000.0, '1e5'),

]

@pytest.mark.parametrize('value, domain, expected', pprint_data)

def test_pprint(self, value, domain, expected):

fmt = mticker.LogFormatter()

label = fmt._pprint_val(value, domain)

assert label == expected

def _sub_labels(self, axis, subs=()):

"""Test whether locator marks subs to be labeled."""

fmt = axis.get_minor_formatter()

minor_tlocs = axis.get_minorticklocs()

fmt.set_locs(minor_tlocs)

coefs = minor_tlocs / 10**(np.floor(np.log10(minor_tlocs)))

label_expected = [round(c) in subs for c in coefs]

label_test = [fmt(x) != '' for x in minor_tlocs]

assert label_test == label_expected

@pytest.mark.style('default')

def test_sublabel(self):

# test label locator

fig, ax = plt.subplots()

ax.set_xscale('log')

ax.xaxis.set_major_locator(mticker.LogLocator(base=10, subs=[]))

ax.xaxis.set_minor_locator(mticker.LogLocator(base=10,

subs=np.arange(2, 10)))

ax.xaxis.set_major_formatter(mticker.LogFormatter(labelOnlyBase=True))

ax.xaxis.set_minor_formatter(mticker.LogFormatter(labelOnlyBase=False))

# axis range above 3 decades, only bases are labeled

ax.set_xlim(1, 1e4)

fmt = ax.xaxis.get_major_formatter()

fmt.set_locs(ax.xaxis.get_majorticklocs())

show_major_labels = [fmt(x) != ''

for x in ax.xaxis.get_majorticklocs()]

assert np.all(show_major_labels)

self._sub_labels(ax.xaxis, subs=[])

# For the next two, if the numdec threshold in LogFormatter.set_locs

# were 3, then the label sub would be 3 for 2-3 decades and (2, 5)

# for 1-2 decades. With a threshold of 1, subs are not labeled.

# axis range at 2 to 3 decades

ax.set_xlim(1, 800)

self._sub_labels(ax.xaxis, subs=[])

# axis range at 1 to 2 decades

ax.set_xlim(1, 80)

self._sub_labels(ax.xaxis, subs=[])

# axis range at 0.4 to 1 decades, label subs 2, 3, 4, 6

ax.set_xlim(1, 8)

self._sub_labels(ax.xaxis, subs=[2, 3, 4, 6])

# axis range at 0 to 0.4 decades, label all

ax.set_xlim(0.5, 0.9)

self._sub_labels(ax.xaxis, subs=np.arange(2, 10, dtype=int))

@pytest.mark.parametrize('val', [1, 10, 100, 1000])

def test_LogFormatter_call(self, val):

# test _num_to_string method used in __call__

temp_lf = mticker.LogFormatter()

temp_lf.axis = FakeAxis()

assert temp_lf(val) == str(val)

@pytest.mark.parametrize('val', [1e-323, 2e-323, 10e-323, 11e-323])

def test_LogFormatter_call_tiny(self, val):

# test coeff computation in __call__

temp_lf = mticker.LogFormatter()

temp_lf.axis = FakeAxis()

@staticmethod

def logit_deformatter(string):

r"""

match = re.match(

r"[^\d]*"

r"(?P<comp>1-)?"

r"(?P<mant>\d*\.?\d*)?"

r"(?:\\cdot)?"

r"(?:10\^\{(?P<expo>-?\d*)})?"

r"[^\d]*$",

string,

)

if match:

comp = match["comp"] is not None

mantissa = float(match["mant"]) if match["mant"] else 1

expo = int(match["expo"]) if match["expo"] is not None else 0

value = mantissa * 10 ** expo

if match["mant"] or match["expo"] is not None:

if comp:

return 1 - value

return value

match = re.match(

r"[^\d]*\\frac\{(?P<num>\d+)\}\{(?P<deno>\d+)\}[^\d]*$", string

)

if match:

num, deno = float(match["num"]), float(match["deno"])

return num / deno

raise ValueError("Not formatted by LogitFormatter")

@pytest.mark.parametrize(

def test_logit_deformater(self, fx, x):

if x is None:

with pytest.raises(ValueError):

TestLogitFormatter.logit_deformatter(fx)

else:

y = TestLogitFormatter.logit_deformatter(fx)

assert _LogitHelper.isclose(x, y)

decade_test = sorted(