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

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

'LogFormatterExponent', 'LogFormatterMathtext',

'LogFormatterSciNotation',

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

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

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

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

__name__ = "dummy"

def __init__(self, minpos=0):

self._data_interval = (0, 1)

self._view_interval = (0, 1)

self._minpos = minpos

def get_view_interval(self):

return self._view_interval

def set_view_interval(self, vmin, vmax):

self._view_interval = (vmin, vmax)

def get_minpos(self):

return self._minpos

def get_data_interval(self):

return self._data_interval

def set_data_interval(self, vmin, vmax):

self._data_interval = (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:

"""

# 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."""

"""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 __init__(self, useOffset=None, useMathText=None, useLocale=None):

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']

self.set_useMathText(useMathText)

self.orderOfMagnitude = 0

self.format = ''

self._scientific = True

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

self.set_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 _format_maybe_minus_and_locale(self, fmt, arg):

"""

return self.fix_minus(locale.format_string(fmt, (arg,), True)

if self._useLocale else fmt % arg)

def get_useMathText(self):

"""

return self._useMathText

def set_useMathText(self, val):

r"""

if val is None:

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

if self._useMathText is False:

try:

from matplotlib import font_manager

ufont = font_manager.findfont(

font_manager.FontProperties(

mpl.rcParams["font.family"]

),

fallback_to_default=False,

)

except ValueError:

ufont = None

if ufont == str(cbook._get_data_path("fonts/ttf/cmr10.ttf")):

_api.warn_external(

"cmr10 font should ideally be used with "

"mathtext, set axes.formatter.use_mathtext to True"

)

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

return self._format_maybe_minus_and_locale(self.format, xp)

def set_scientific(self, b):

"""

self._scientific = bool(b)

def set_powerlimits(self, lims):

r"""

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 value is np.ma.masked:

return ""

if isinstance(value, Integral):

fmt = "%d"

else:

if getattr(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 divisions.

a, b = self.axis.get_view_interval()

delta = (b - a) / 1e4

fmt = f"%-#.{cbook._g_sig_digits(value, delta)}g"

return self._format_maybe_minus_and_locale(fmt, value)

def format_data(self, value):

# docstring inherited

e = math.floor(math.log10(abs(value)))

s = round(value / 10**e, 10)

exponent = self._format_maybe_minus_and_locale("%d", e)

significand = self._format_maybe_minus_and_locale(

"%d" if s % 1 == 0 else "%1.10g", s)

if e == 0:

return significand

elif self._useMathText or self._usetex:

exponent = "10^{%s}" % exponent

return (exponent if s == 1 # reformat 1x10^y as 10^y

else rf"{significand} \times {exponent}")

else:

return f"{significand}e{exponent}"

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 = fr'${sciNotStr}\mathdefault{{{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 a 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:

val = locs.max()

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 = f'%1.{sigfigs}f'

if self._usetex or self._useMathText:

"""

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

minor_thresholds=None,

linthresh=None):

self.set_base(base)

self.set_label_minor(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 set_base(self, base):

"""

self._base = float(base)

def set_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(b ** (fx - exponent))

if self.labelOnlyBase and not is_x_decade:

return ''

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

return ''

vmin, vmax = self.axis.get_view_interval()

vmin, vmax = mtransforms.nonsingular(vmin, vmax, expander=0.05)

s = self._num_to_string(x, vmin, vmax)

return self.fix_minus(s)

def format_data(self, value):

with cbook._setattr_cm(self, labelOnlyBase=False):

return cbook.strip_math(self.__call__(value))

def format_data_short(self, value):

# docstring inherited

return '%-12g' % value

def _pprint_val(self, x, d):

# 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