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

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

'LogFormatterExponent', 'LogFormatterMathtext',

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

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

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

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

if isinstance(x, np.generic):

x = x.item()

if isinstance(y, np.generic):

y = y.item()

"""

if rcParams['_internal.classic_mode']:

return '\\mathdefault{%s}' % s

else:

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

def fix_minus(self, s):

"""

"""

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:

"""

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

"""

"""

def __init__(self, seq):

"""

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

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

"""

"""

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()

d = abs(xmax - xmin)

return self.pprint_val(x, d)

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

if d < 1e-2:

fmt = '%1.3e'

elif d < 1e-1:

fmt = '%1.3f'

elif d > 1e5:

fmt = '%1.1e'

elif d > 10:

fmt = '%1.1f'

elif d > 1:

fmt = '%1.2f'

else:

fmt = '%1.3f'

s = fmt % x

#print d, x, fmt, s

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 = rcParams['axes.formatter.useoffset']

self.set_useOffset(useOffset)

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

if useMathText is None:

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

self.set_useMathText(useMathText)

self.orderOfMagnitude = 0

self.format = ''

self._scientific = True

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

if useLocale is None:

useLocale = 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 = 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 = rcParams['axes.formatter.use_mathtext']

else:

self._useMathText = val

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

def fix_minus(self, s):

"""

if rcParams['text.usetex'] or not rcParams['axes.unicode_minus']:

return s

else:

return s.replace('-', '\u2212')

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

"""

if len(self.locs) == 0:

return ''

else:

s = self.pprint_val(x)

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):

"""

if self._useLocale:

return locale.format_string('%-12g', (value,))

else:

return '%-12g' % value

def format_data(self, value):

"""

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:

if sciNotStr != '':

sciNotStr = r'\times%s' % _mathdefault(sciNotStr)

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

elif self._usetex:

if sciNotStr != '':

sciNotStr = r'\times%s' % sciNotStr

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

else:

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

return self.fix_minus(s)

def set_locs(self, locs):

"""

self.locs = locs

if len(self.locs) > 0:

vmin, vmax = self.axis.get_view_interval()

d = abs(vmax - vmin)

if self._useOffset:

self._compute_offset()

self._set_orderOfMagnitude(d)

self._set_format(vmin, vmax)

def _compute_offset(self):

locs = self.locs

if locs is None or not len(locs):

self.offset = 0

return

# 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 two significant digits.

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

if abs_max // 10 ** oom >= 10

else 0)

def _set_orderOfMagnitude(self, range):

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

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

# offset

if not self._scientific:

self.orderOfMagnitude = 0

return

locs = np.absolute(self.locs)

if self.offset:

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

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, vmin, vmax):

# set the format string to format all the ticklabels

if len(self.locs) < 2:

# Temporarily augment the locations with the axis end points.

_locs = list(self.locs) + [vmin, vmax]

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:

self.format = '$%s$' % self.format

elif self._useMathText:

self.format = '$%s$' % _mathdefault(self.format)

def pprint_val(self, x):

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

if np.absolute(xp) < 1e-8:

xp = 0

if self._useLocale:

return locale.format_string(self.format, (xp,))

else:

return self.format % xp

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=True):

"""

self._base = base + 0.0

self.labelOnlyBase = labelOnlyBase

def base(self, base):

"""

self._base = base

def label_minor(self, labelOnlyBase):

"""

self.labelOnlyBase = labelOnlyBase

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

"""

vmin, vmax = self.axis.get_view_interval()

d = abs(vmax - vmin)

b = self._base

if x == 0.0:

return '0'

sign = np.sign(x)

# only label the decades

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

isDecade = is_close_to_int(fx)

if not isDecade and self.labelOnlyBase:

s = ''

elif x > 10000:

s = '%1.0e' % x

elif x < 1:

s = '%1.0e' % x

else:

s = self.pprint_val(x, d)

if sign == -1:

s = '-%s' % s

return self.fix_minus(s)

def format_data(self, value):

b = self.labelOnlyBase

self.labelOnlyBase = False

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

self.labelOnlyBase = b

return value

def format_data_short(self, value):

"""

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

if d < 1e-2:

fmt = '%1.3e'

elif d < 1e-1:

fmt = '%1.3f'

elif d > 1e5:

fmt = '%1.1e'

elif d > 10:

fmt = '%1.1f'

elif d > 1:

fmt = '%1.2f'

else:

fmt = '%1.3f'

s = fmt % x

tup = s.split('e')

if len(tup) == 2:

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

exponent = int(tup[1])

if exponent:

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

else:

s = mantissa

else:

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

"""

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

"""

vmin, vmax = self.axis.get_view_interval()

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

d = abs(vmax - vmin)

b = self._base

if x == 0:

return '0'

sign = np.sign(x)

# only label the decades

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

isDecade = is_close_to_int(fx)

if not isDecade and self.labelOnlyBase:

s = ''

elif abs(fx) > 10000:

s = '%1.0g' % fx

elif abs(fx) < 1:

s = '%1.0g' % fx

else:

fd = math.log(abs(d)) / math.log(b)

s = self.pprint_val(fx, fd)

if sign == -1:

s = '-%s' % s

"""

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

"""

b = self._base

usetex = rcParams['text.usetex']

# only label the decades

if x == 0:

if usetex:

return '$0$'

else:

return '$%s$' % _mathdefault('0')

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

is_decade = is_close_to_int(fx)

sign_string = '-' if x < 0 else ''

# use string formatting of the base if it is not an integer

if b % 1 == 0.0:

base = '%d' % b

else:

base = '%s' % b

if not is_decade and self.labelOnlyBase:

return ''

elif not is_decade:

if usetex:

return (r'$%s%s^{%.2f}$') % \

(sign_string, base, fx)

else:

return ('$%s$' % _mathdefault(

'%s%s^{%.2f}' %

(sign_string, base, fx)))

else:

if usetex:

return (r'$%s%s^{%d}$') % (sign_string,

base,

nearest_long(fx))

else:

return ('$%s$' % _mathdefault(

'%s%s^{%d}' %