'NullFormatter', 'FuncFormatter', 'FormatStrFormatter',

'StrMethodFormatter', 'ScalarFormatter', 'LogFormatter',

'LogFormatterExponent', 'LogFormatterMathtext',

'IndexFormatter', 'LogFormatterSciNotation',

'LogitFormatter', 'EngFormatter', 'PercentFormatter',

'OldScalarFormatter',

'Locator', 'IndexLocator', 'FixedLocator', 'NullLocator',

'LinearLocator', 'LogLocator', 'AutoLocator',

'MultipleLocator', 'MaxNLocator', 'AutoMinorLocator',

def __init__(self, minpos=0):

self.dataLim = mtransforms.Bbox.unit()

self.viewLim = mtransforms.Bbox.unit()

self._minpos = minpos

def get_view_interval(self):

return self.viewLim.intervalx

def set_view_interval(self, vmin, vmax):

self.viewLim.intervalx = vmin, vmax

def get_minpos(self):

return self._minpos

def get_data_interval(self):

return self.dataLim.intervalx

def set_data_interval(self, vmin, vmax):

self.dataLim.intervalx = vmin, vmax

def get_tick_space(self):

# Just use the long-standing default of nbins==9

axis = None

def set_axis(self, axis):

self.axis = axis

def create_dummy_axis(self, **kwargs):

if self.axis is None:

self.axis = _DummyAxis(**kwargs)

def set_view_interval(self, vmin, vmax):

self.axis.set_view_interval(vmin, vmax)

def set_data_interval(self, vmin, vmax):

self.axis.set_data_interval(vmin, vmax)

def set_bounds(self, vmin, vmax):

self.set_view_interval(vmin, vmax)

"""

# some classes want to see all the locs to help format

# individual ones

locs = []

def __call__(self, x, pos=None):

"""

raise NotImplementedError('Derived must override')

def format_ticks(self, values):

"""Return the tick labels for all the ticks at once."""

self.set_locs(values)

return [self(value, i) for i, value in enumerate(values)]

def format_data(self, value):

"""

return self.__call__(value)

def format_data_short(self, value):

"""

return self.format_data(value)

def get_offset(self):

return ''

def set_locs(self, locs):

"""

self.locs = locs

@staticmethod

def fix_minus(s):

"""

return (s.replace('-', '\N{MINUS SIGN}')

if mpl.rcParams['axes.unicode_minus']

else s)

def _set_locator(self, locator):

"""Subclasses may want to override this to set a locator."""

"""

def __init__(self, labels):

self.labels = labels

self.n = len(labels)

def __call__(self, x, pos=None):

"""

i = int(x + 0.5)

if i < 0 or i >= self.n:

return ''

else:

"""Always return the empty string."""

def __call__(self, x, pos=None):

# docstring inherited

"""

def __init__(self, seq):

"""Set the sequence *seq* of strings that will be used for labels."""

self.seq = seq

self.offset_string = ''

def __call__(self, x, pos=None):

"""

if pos is None or pos >= len(self.seq):

return ''

else:

return self.seq[pos]

def get_offset(self):

return self.offset_string

def set_offset_string(self, ofs):

"""

def __init__(self, func):

self.func = func

self.offset_string = ""

def __call__(self, x, pos=None):

"""

return self.func(x, pos)

def get_offset(self):

return self.offset_string

def set_offset_string(self, ofs):

"""

def __init__(self, fmt):

self.fmt = fmt

def __call__(self, x, pos=None):

"""

"""

def __init__(self, fmt):

self.fmt = fmt

def __call__(self, x, pos=None):

"""

"""

def __call__(self, x, pos=None):

"""

xmin, xmax = self.axis.get_view_interval()

# If the number is not too big and it's an int, format it as an int.

if abs(x) < 1e4 and x == int(x):

return '%d' % x

d = abs(xmax - xmin)

fmt = ('%1.3e' if d < 1e-2 else

'%1.3f' if d <= 1 else

'%1.2f' if d <= 10 else

'%1.1f' if d <= 1e5 else

'%1.1e')

s = fmt % x

tup = s.split('e')

if len(tup) == 2:

mantissa = tup[0].rstrip('0').rstrip('.')

sign = tup[1][0].replace('+', '')

exponent = tup[1][1:].lstrip('0')

s = '%se%s%s' % (mantissa, sign, exponent)

else:

s = s.rstrip('0').rstrip('.')

"""

def __init__(self, useOffset=None, useMathText=None, useLocale=None):

# useOffset allows plotting small data ranges with large offsets: for

# example: [1+1e-9, 1+2e-9, 1+3e-9] useMathText will render the offset

# and scientific notation in mathtext

if useOffset is None:

useOffset = mpl.rcParams['axes.formatter.useoffset']

self._offset_threshold = \

mpl.rcParams['axes.formatter.offset_threshold']

self.set_useOffset(useOffset)

self._usetex = mpl.rcParams['text.usetex']

if useMathText is None:

useMathText = mpl.rcParams['axes.formatter.use_mathtext']

self.set_useMathText(useMathText)

self.orderOfMagnitude = 0

self.format = ''

self._scientific = True

self._powerlimits = mpl.rcParams['axes.formatter.limits']

if useLocale is None:

useLocale = mpl.rcParams['axes.formatter.use_locale']

self._useLocale = useLocale

def get_useOffset(self):

return self._useOffset

def set_useOffset(self, val):

if val in [True, False]:

self.offset = 0

self._useOffset = val

else:

self._useOffset = False

self.offset = val

useOffset = property(fget=get_useOffset, fset=set_useOffset)

def get_useLocale(self):

return self._useLocale

def set_useLocale(self, val):

if val is None:

self._useLocale = mpl.rcParams['axes.formatter.use_locale']

else:

self._useLocale = val

useLocale = property(fget=get_useLocale, fset=set_useLocale)

def get_useMathText(self):

return self._useMathText

def set_useMathText(self, val):

if val is None:

self._useMathText = mpl.rcParams['axes.formatter.use_mathtext']

else:

self._useMathText = val

useMathText = property(fget=get_useMathText, fset=set_useMathText)

def __call__(self, x, pos=None):

"""

if len(self.locs) == 0:

return ''

else:

xp = (x - self.offset) / (10. ** self.orderOfMagnitude)

if abs(xp) < 1e-8:

xp = 0

if self._useLocale:

s = locale.format_string(self.format, (xp,))

else:

s = self.format % xp

return self.fix_minus(s)

def set_scientific(self, b):

"""

self._scientific = bool(b)

def set_powerlimits(self, lims):

"""

if len(lims) != 2:

raise ValueError("'lims' must be a sequence of length 2")

self._powerlimits = lims

def format_data_short(self, value):

# docstring inherited

if isinstance(value, np.ma.MaskedArray) and value.mask:

return ""

if isinstance(value, Integral):

fmt = "%d"

else:

if self.axis.__name__ in ["xaxis", "yaxis"]:

if self.axis.__name__ == "xaxis":

axis_trf = self.axis.axes.get_xaxis_transform()

axis_inv_trf = axis_trf.inverted()

screen_xy = axis_trf.transform((value, 0))

neighbor_values = axis_inv_trf.transform(

screen_xy + [[-1, 0], [+1, 0]])[:, 0]

else: # yaxis:

axis_trf = self.axis.axes.get_yaxis_transform()

axis_inv_trf = axis_trf.inverted()

screen_xy = axis_trf.transform((0, value))

neighbor_values = axis_inv_trf.transform(

screen_xy + [[0, -1], [0, +1]])[:, 1]

delta = abs(neighbor_values - value).max()

else:

# Rough approximation: no more than 1e4 pixels.

delta = self.axis.get_view_interval() / 1e4

# If e.g. value = 45.67 and delta = 0.02, then we want to round to

# 2 digits after the decimal point (floor(log10(0.02)) = -2);

# 45.67 contributes 2 digits before the decimal point

# (floor(log10(45.67)) + 1 = 2): the total is 4 significant digits.

# A value of 0 contributes 1 "digit" before the decimal point.

sig_digits = max(

0,

(math.floor(math.log10(abs(value))) + 1 if value else 1)

- math.floor(math.log10(delta)))

fmt = f"%-#.{sig_digits}g"

return (

self.fix_minus(

locale.format_string(fmt, (value,)) if self._useLocale else

fmt % value))

def format_data(self, value):

# docstring inherited

if self._useLocale:

s = locale.format_string('%1.10e', (value,))

else:

s = '%1.10e' % value

s = self._formatSciNotation(s)

return self.fix_minus(s)

def get_offset(self):

"""

if len(self.locs) == 0:

return ''

s = ''

if self.orderOfMagnitude or self.offset:

offsetStr = ''

sciNotStr = ''

if self.offset:

offsetStr = self.format_data(self.offset)

if self.offset > 0:

offsetStr = '+' + offsetStr

if self.orderOfMagnitude:

if self._usetex or self._useMathText:

sciNotStr = self.format_data(10 ** self.orderOfMagnitude)

else:

sciNotStr = '1e%d' % self.orderOfMagnitude

if self._useMathText or self._usetex:

if sciNotStr != '':

sciNotStr = r'\times\mathdefault{%s}' % sciNotStr

s = r'$%s\mathdefault{%s}$' % (sciNotStr, offsetStr)

else:

s = ''.join((sciNotStr, offsetStr))

return self.fix_minus(s)

def set_locs(self, locs):

# docstring inherited

self.locs = locs

if len(self.locs) > 0:

if self._useOffset:

self._compute_offset()

self._set_order_of_magnitude()

self._set_format()

def _compute_offset(self):

locs = self.locs

# Restrict to visible ticks.

vmin, vmax = sorted(self.axis.get_view_interval())

locs = np.asarray(locs)

locs = locs[(vmin <= locs) & (locs <= vmax)]

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 = np.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 _offset_threshold digits.

n = self._offset_threshold - 1

self.offset = (sign * (abs_max // 10 ** oom) * 10 ** oom

if abs_max // 10 ** oom >= 10**n

else 0)

def _set_order_of_magnitude(self):

# if scientific notation is to be used, find the appropriate exponent

# if using an numerical offset, find the exponent after applying the

# offset. When lower power limit = upper <> 0, use provided exponent.

if not self._scientific:

self.orderOfMagnitude = 0

return

if self._powerlimits[0] == self._powerlimits[1] != 0:

# fixed scaling when lower power limit = upper <> 0.

self.orderOfMagnitude = self._powerlimits[0]

return

# restrict to visible ticks

vmin, vmax = sorted(self.axis.get_view_interval())

locs = np.asarray(self.locs)

locs = locs[(vmin <= locs) & (locs <= vmax)]

locs = np.abs(locs)

if not len(locs):

self.orderOfMagnitude = 0

return

if self.offset:

oom = math.floor(math.log10(vmax - vmin))

else:

if locs[0] > locs[-1]:

val = locs[0]

else:

val = locs[-1]

if val == 0:

oom = 0

else:

oom = math.floor(math.log10(val))

if oom <= self._powerlimits[0]:

self.orderOfMagnitude = oom

elif oom >= self._powerlimits[1]:

self.orderOfMagnitude = oom

else:

self.orderOfMagnitude = 0

def _set_format(self):

# set the format string to format all the ticklabels

if len(self.locs) < 2:

# Temporarily augment the locations with the axis end points.

_locs = [*self.locs, *self.axis.get_view_interval()]

else:

_locs = self.locs

locs = (np.asarray(_locs) - self.offset) / 10. ** self.orderOfMagnitude

loc_range = np.ptp(locs)

# Curvilinear coordinates can yield two identical points.

if loc_range == 0:

loc_range = np.max(np.abs(locs))

# Both points might be zero.

if loc_range == 0:

loc_range = 1

if len(self.locs) < 2:

# We needed the end points only for the loc_range calculation.

locs = locs[:-2]

loc_range_oom = int(math.floor(math.log10(loc_range)))

# first estimate:

sigfigs = max(0, 3 - loc_range_oom)

# refined estimate:

thresh = 1e-3 * 10 ** loc_range_oom

while sigfigs >= 0:

if np.abs(locs - np.round(locs, decimals=sigfigs)).max() < thresh:

sigfigs -= 1

else:

break

sigfigs += 1

self.format = '%1.' + str(sigfigs) + 'f'

if self._usetex or self._useMathText:

self.format = r'$\mathdefault{%s}$' % self.format

def _formatSciNotation(self, s):

# transform 1e+004 into 1e4, for example

if self._useLocale:

decimal_point = locale.localeconv()['decimal_point']

positive_sign = locale.localeconv()['positive_sign']

else:

decimal_point = '.'

positive_sign = '+'

tup = s.split('e')

try:

significand = tup[0].rstrip('0').rstrip(decimal_point)

sign = tup[1][0].replace(positive_sign, '')

exponent = tup[1][1:].lstrip('0')

if self._useMathText or self._usetex:

if significand == '1' and exponent != '':

# reformat 1x10^y as 10^y

significand = ''

if exponent:

exponent = '10^{%s%s}' % (sign, exponent)

if significand and exponent:

return r'%s{\times}%s' % (significand, exponent)

else:

return r'%s%s' % (significand, exponent)

else:

s = ('%se%s%s' % (significand, sign, exponent)).rstrip('e')

return s

except IndexError:

"""

def __init__(self, base=10.0, labelOnlyBase=False,

minor_thresholds=None,

linthresh=None):

self._base = float(base)

self.labelOnlyBase = labelOnlyBase

if minor_thresholds is None:

if mpl.rcParams['_internal.classic_mode']:

minor_thresholds = (0, 0)

else:

minor_thresholds = (1, 0.4)

self.minor_thresholds = minor_thresholds

self._sublabels = None

self._linthresh = linthresh

def base(self, base):

"""

self._base = base

def label_minor(self, labelOnlyBase):

"""

self.labelOnlyBase = labelOnlyBase

def set_locs(self, locs=None):

"""

if np.isinf(self.minor_thresholds[0]):

self._sublabels = None

return

# Handle symlog case:

linthresh = self._linthresh

if linthresh is None:

try:

linthresh = self.axis.get_transform().linthresh

except AttributeError:

pass

vmin, vmax = self.axis.get_view_interval()

if vmin > vmax:

vmin, vmax = vmax, vmin

if linthresh is None and vmin <= 0:

# It's probably a colorbar with

# a format kwarg setting a LogFormatter in the manner

# that worked with 1.5.x, but that doesn't work now.

self._sublabels = {1} # label powers of base

return

b = self._base

if linthresh is not None: # symlog

# Only compute the number of decades in the logarithmic part of the

# axis

numdec = 0

if vmin < -linthresh:

rhs = min(vmax, -linthresh)

numdec += math.log(vmin / rhs) / math.log(b)

if vmax > linthresh:

lhs = max(vmin, linthresh)

numdec += math.log(vmax / lhs) / math.log(b)

else:

vmin = math.log(vmin) / math.log(b)

vmax = math.log(vmax) / math.log(b)

numdec = abs(vmax - vmin)

if numdec > self.minor_thresholds[0]:

# Label only bases

self._sublabels = {1}

elif numdec > self.minor_thresholds[1]:

# Add labels between bases at log-spaced coefficients;

# include base powers in case the locations include

# "major" and "minor" points, as in colorbar.

c = np.geomspace(1, b, int(b)//2 + 1)

self._sublabels = set(np.round(c))

# For base 10, this yields (1, 2, 3, 4, 6, 10).

else:

# Label all integer multiples of base**n.

self._sublabels = set(np.arange(1, b + 1))

def _num_to_string(self, x, vmin, vmax):

if x > 10000:

s = '%1.0e' % x

elif x < 1:

s = '%1.0e' % x

else:

s = self._pprint_val(x, vmax - vmin)

return s

def __call__(self, x, pos=None):

# docstring inherited

if x == 0.0: # Symlog

return '0'

x = abs(x)

b = self._base

# only label the decades

fx = math.log(x) / math.log(b)

is_x_decade = is_close_to_int(fx)

exponent = round(fx) if is_x_decade else np.floor(fx)

coeff = round(x / b ** exponent)

if self.labelOnlyBase and not is_x_decade:

return ''

if self._sublabels is not None and coeff not in self._sublabels: