Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Appearance settings

Commit b35786f

Browse filesBrowse files
anntzeranntzer
committed
Improve tick subsampling in LogLocator.
Rewrite the logic for subsampling log-scale ticks, so that 1) there's as many ticks as possible without going over numticks (don't draw a single tick when two would fit), and 2) the ticks are spaced as much as possible (when two ticks are drawn, put them on the lowest and highest decade, not somewhere in the middle). See comments in implementation for details. For the backcompat-oriented "classic-mode", remove the "stride >= numdec" check (which is a much later addition). Test changes: - TestLogLocator changes because tick_values() no longer returns major ticks outside of the (vmin, vmax) range. - test_small_range_loglocator was likely previously wrong (the assert did not cover the values of ticks, and all iterations of the loop ended up testing the same condition). Rewrite it fully.
1 parent 0b7a88a commit b35786f
Copy full SHA for b35786f

File tree

Expand file treeCollapse file tree

2 files changed

+98
-48
lines changed
Filter options
Expand file treeCollapse file tree

2 files changed

+98
-48
lines changed

‎lib/matplotlib/tests/test_ticker.py

Copy file name to clipboardExpand all lines: lib/matplotlib/tests/test_ticker.py
+26-15Lines changed: 26 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -332,13 +332,11 @@ def test_basic(self):
332332
with pytest.raises(ValueError):
333333
loc.tick_values(0, 1000)
334334

335-
test_value = np.array([1.00000000e-05, 1.00000000e-03, 1.00000000e-01,
336-
1.00000000e+01, 1.00000000e+03, 1.00000000e+05,
337-
1.00000000e+07, 1.000000000e+09])
335+
test_value = np.array([1e-3, 1e-1, 1e+1, 1e+3, 1e+5])
338336
assert_almost_equal(loc.tick_values(0.001, 1.1e5), test_value)
339337

340338
loc = mticker.LogLocator(base=2)
341-
test_value = np.array([0.5, 1., 2., 4., 8., 16., 32., 64., 128., 256.])
339+
test_value = np.array([1., 2., 4., 8., 16., 32., 64.])
342340
assert_almost_equal(loc.tick_values(1, 100), test_value)
343341

344342
def test_polar_axes(self):
@@ -348,7 +346,7 @@ def test_polar_axes(self):
348346
fig, ax = plt.subplots(subplot_kw={'projection': 'polar'})
349347
ax.set_yscale('log')
350348
ax.set_ylim(1, 100)
351-
assert_array_equal(ax.get_yticks(), [10, 100, 1000])
349+
assert_array_equal(ax.get_yticks(), [10, 100])
352350

353351
def test_switch_to_autolocator(self):
354352
loc = mticker.LogLocator(subs="all")
@@ -377,7 +375,7 @@ def test_tick_values_correct(self):
377375
1.e+01, 2.e+01, 5.e+01, 1.e+02, 2.e+02, 5.e+02,
378376
1.e+03, 2.e+03, 5.e+03, 1.e+04, 2.e+04, 5.e+04,
379377
1.e+05, 2.e+05, 5.e+05, 1.e+06, 2.e+06, 5.e+06,
380-
1.e+07, 2.e+07, 5.e+07, 1.e+08, 2.e+08, 5.e+08])
378+
1.e+07, 2.e+07, 5.e+07])
381379
assert_almost_equal(ll.tick_values(1, 1e7), test_value)
382380

383381
def test_tick_values_not_empty(self):
@@ -387,8 +385,7 @@ def test_tick_values_not_empty(self):
387385
1.e+01, 2.e+01, 5.e+01, 1.e+02, 2.e+02, 5.e+02,
388386
1.e+03, 2.e+03, 5.e+03, 1.e+04, 2.e+04, 5.e+04,
389387
1.e+05, 2.e+05, 5.e+05, 1.e+06, 2.e+06, 5.e+06,
390-
1.e+07, 2.e+07, 5.e+07, 1.e+08, 2.e+08, 5.e+08,
391-
1.e+09, 2.e+09, 5.e+09])
388+
1.e+07, 2.e+07, 5.e+07, 1.e+08, 2.e+08, 5.e+08])
392389
assert_almost_equal(ll.tick_values(1, 1e8), test_value)
393390

394391
def test_multiple_shared_axes(self):
@@ -1913,14 +1910,28 @@ def test_bad_locator_subs(sub):
19131910
ll.set_params(subs=sub)
19141911

19151912

1916-
@pytest.mark.parametrize('numticks', [1, 2, 3, 9])
1913+
@pytest.mark.parametrize("numticks, lims, ticks", [
1914+
(1, (.5, 5), [1]),
1915+
(2, (.5, 5), [1]),
1916+
(3, (.5, 5), [1]),
1917+
(9, (.5, 5), [1]),
1918+
(1, (.5, 50), [10]),
1919+
(2, (.5, 50), [1, 10]),
1920+
(3, (.5, 50), [1, 10]),
1921+
(9, (.5, 50), [1, 10]),
1922+
(1, (.5, 500), [10]),
1923+
(2, (.5, 500), [1, 100]),
1924+
(3, (.5, 500), [1, 10, 100]),
1925+
(9, (.5, 500), [1, 10, 100]),
1926+
(1, (.5, 5000), [100]),
1927+
(2, (.5, 5000), [1, 1000]),
1928+
(3, (.5, 5000), [1, 1000]),
1929+
(9, (.5, 5000), [1, 10, 100, 1000]),
1930+
])
19171931
@mpl.style.context('default')
1918-
def test_small_range_loglocator(numticks):
1919-
ll = mticker.LogLocator()
1920-
ll.set_params(numticks=numticks)
1921-
for top in [5, 7, 9, 11, 15, 50, 100, 1000]:
1922-
ticks = ll.tick_values(.5, top)
1923-
assert (np.diff(np.log10(ll.tick_values(6, 150))) == 1).all()
1932+
def test_small_range_loglocator(numticks, lims, ticks):
1933+
ll = mticker.LogLocator(numticks=numticks)
1934+
assert_array_equal(ll.tick_values(*lims), ticks)
19241935

19251936

19261937
def test_NullFormatter():

‎lib/matplotlib/ticker.py

Copy file name to clipboardExpand all lines: lib/matplotlib/ticker.py
+72-33Lines changed: 72 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -2403,14 +2403,22 @@ def __call__(self):
24032403
vmin, vmax = self.axis.get_view_interval()
24042404
return self.tick_values(vmin, vmax)
24052405

2406+
def _log_b(self, x):
2407+
# Use specialized logs if possible, as they can be more accurate; e.g.
2408+
# log(.001) / log(10) = -2.999... (whether math.log or np.log) due to
2409+
# floating point error.
2410+
return (np.log10(x) if self._base == 10 else
2411+
np.log2(x) if self._base == 2 else
2412+
np.log(x) / self._base)
2413+
24062414
def tick_values(self, vmin, vmax):
24072415
if self.numticks == 'auto':
24082416
if self.axis is not None:
2409-
numticks = np.clip(self.axis.get_tick_space(), 2, 9)
2417+
nt = np.clip(self.axis.get_tick_space(), 2, 9)
24102418
else:
2411-
numticks = 9
2419+
nt = 9
24122420
else:
2413-
numticks = self.numticks
2421+
nt = self.numticks
24142422

24152423
b = self._base
24162424
if vmin <= 0.0:
@@ -2421,17 +2429,16 @@ def tick_values(self, vmin, vmax):
24212429
raise ValueError(
24222430
"Data has no positive values, and therefore cannot be log-scaled.")
24232431

2424-
_log.debug('vmin %s vmax %s', vmin, vmax)
2425-
24262432
if vmax < vmin:
24272433
vmin, vmax = vmax, vmin
2428-
log_vmin = math.log(vmin) / math.log(b)
2429-
log_vmax = math.log(vmax) / math.log(b)
2430-
2431-
numdec = math.floor(log_vmax) - math.ceil(log_vmin)
2434+
# Min and max exponents -- float and int versions.
2435+
efmin, efmax = self._log_b([vmin, vmax])
2436+
emin = math.ceil(efmin)
2437+
emax = math.floor(efmax)
2438+
nd = emax - emin + 1 # Total number of decade ticks available.
24322439

24332440
if isinstance(self._subs, str):
2434-
if numdec > 10 or b < 3:
2441+
if nd >= 10 or b < 3:
24352442
if self._subs == 'auto':
24362443
return np.array([]) # no minor or major ticks
24372444
else:
@@ -2443,34 +2450,66 @@ def tick_values(self, vmin, vmax):
24432450
subs = self._subs
24442451

24452452
# Get decades between major ticks.
2446-
stride = (max(math.ceil(numdec / (numticks - 1)), 1)
2447-
if mpl.rcParams['_internal.classic_mode'] else
2448-
numdec // numticks + 1)
2449-
2450-
# if we have decided that the stride is as big or bigger than
2451-
# the range, clip the stride back to the available range - 1
2452-
# with a floor of 1. This prevents getting axis with only 1 tick
2453-
# visible.
2454-
if stride >= numdec:
2455-
stride = max(1, numdec - 1)
2456-
2457-
# Does subs include anything other than 1? Essentially a hack to know
2458-
# whether we're a major or a minor locator.
2459-
have_subs = len(subs) > 1 or (len(subs) == 1 and subs[0] != 1.0)
2460-
2461-
decades = np.arange(math.floor(log_vmin) - stride,
2462-
math.ceil(log_vmax) + 2 * stride, stride)
2463-
2464-
if have_subs:
2465-
if stride == 1:
2466-
ticklocs = np.concatenate(
2467-
[subs * decade_start for decade_start in b ** decades])
2453+
if mpl.rcParams["_internal.classic_mode"]: # keep historic formulas
2454+
stride = max(math.ceil((nd - 1) / (nt - 1)), 1)
2455+
decades = np.arange(emin, emax + 1, stride)
2456+
else:
2457+
# Find the largest number of ticks, no more than the requested
2458+
# number, that can actually be drawn (e.g., with 9 decades ticks,
2459+
# no stride yields 7 ticks). For a given value of the stride *s*,
2460+
# there are either floor(nd/s) or ceil(nd/s) ticks depending on the
2461+
# offset. Pick the smallest stride such that floor(nd/s) < nt,
2462+
# i.e. nd/s < nt+1, then re-set nt to ceil(...) if acceptable, else
2463+
# to floor(...) (which must then equal the original nt, i.e. nt is
2464+
# kept unchanged).
2465+
stride = nd // (nt + 1) + 1
2466+
nt1 = math.ceil(nd / stride)
2467+
if nt1 <= nt:
2468+
nt = nt1
2469+
else:
2470+
assert nt1 == nt + 1
2471+
if nt == 0:
2472+
stride = None
2473+
decades = np.array([])
2474+
elif nt == 1: # Draw single tick close to center.
2475+
stride = None
2476+
decades = np.array([round((efmin + efmax) / 2)])
2477+
else:
2478+
# Pick the largest s that yields this actual nt (e.g., with 15
2479+
# decades, strides of 5, 6, or 7 *can* yield 3 ticks; picking a
2480+
# larger stride minimizes unticked space at the ends). First
2481+
# try for
2482+
# ceil(nd/s) == nt, i.e. nd/nt <= s < nd/(nt-1),
2483+
# else fallback to
2484+
# floor(nd/s) == nt, i.e. nd/(nt+1) < s <= nd/nt.
2485+
# One of these cases must have an integer solution (given the
2486+
# choice of nt above).
2487+
# In the second case, an offset must be added to that only nt
2488+
# ticks are drawn (e.g. with 19 decades (0 to 18 incl.) and 6
2489+
# ticks, they should must be drawn at exponents 1, 4, 7, 10,
2490+
# 13, and 16).
2491+
stride = (nd - 1) // (nt - 1)
2492+
if stride < nd / nt: # fallback to second case
2493+
stride = nd // nt
2494+
assert stride > nd / (nt + 1)
2495+
offset = nd % stride
2496+
else:
2497+
offset = 0
2498+
decades = np.arange(emin + offset, emax + 1, stride)
2499+
2500+
# Guess whether we're a minor locator, based on whether subs include
2501+
# anything other than 1.
2502+
is_minor = len(subs) > 1 or (len(subs) == 1 and subs[0] != 1.0)
2503+
if is_minor:
2504+
if stride == 1 or nd <= 1:
2505+
# Minor ticks start in the decade preceding the first major tick.
2506+
ticklocs = np.concatenate([
2507+
subs * b**decade for decade in range(emin - 1, emax + 1)])
24682508
else:
24692509
ticklocs = np.array([])
24702510
else:
24712511
ticklocs = b ** decades
24722512

2473-
_log.debug('ticklocs %r', ticklocs)
24742513
if (len(subs) > 1
24752514
and stride == 1
24762515
and ((vmin <= ticklocs) & (ticklocs <= vmax)).sum() <= 1):

0 commit comments

Comments
0 (0)
Morty Proxy This is a proxified and sanitized view of the page, visit original site.