mrhavens/intellecton
1
0
Fork 0
mirror of http://forgejo.openclaw.svc.cluster.local:3000/mrhavens/intellecton.git synced 2026-06-18 01:22:57 +00:00
Code Issues Projects Packages Wiki Activity
intellecton/venv/lib/python3.12/site-packages/matplotlib/__pycache__/ticker.cpython-312.pyc

1294 lines
125 KiB
Text
Raw Normal View History

feat: rigorous physics revision for Paper 1 based on adversarial review
2026-06-01 22:22:35 +00:00
<EFBFBD>
<00>Rju<6A><00><00>|<00>dZddlZddlZddlZddlZddlmZddlZddlZ ddl
Z ddl
m Z m Z ddl
mZej e<11>ZdZGd<07>d<08>ZGd <09>d
<EFBFBD>ZGd <0B>d e<15>ZGd <0A>de<16>ZGd<0F>de<16>ZGd<11>de<16>ZGd<13>de<16>ZGd<15>dej,<00>ZGd<17>de<16>ZGd<19>de<16>ZGd<1B>de<16>ZGd<1D>de<1E>ZGd<1F>d e<1E>Z Gd!<21>d"e <20>Z!Gd#<23>d$e<16>Z"Gd%<25>d&e<1D>Z#Gd'<27>d(e<16>Z$Gd)<29>d*e<15>Z%Gd+<2B>d,e%<25>Z&Gd-<2D>d.e%<25>Z'Gd/<2F>d0e%<25>Z(Gd1<64>d2e%<25>Z)Gd3<64>d4e%<25>Z*dNd5<64>Z+Gd6<64>d7<64>Z,Gd8<64>d9e%<25>Z-d:dd;<3B>d<<3C>Z.d=<3D>Z/d><3E>Z0d?<3F>Z1d@<40>Z2dA<64>Z3GdB<64>dCe%<25>Z4GdD<64>dEe%<25>Z5GdF<64>dGe%<25>Z6GdH<64>dIe-<2D>Z7GdJ<64>dKe-<2D>Z8GdL<64>dMe%<25>Z9y)Oa
Tick locating and formatting
============================
This module contains classes for configuring tick locating and formatting.
Generic tick locators and formatters are provided, as well as domain specific
custom ones.
Although the locators know nothing about major or minor ticks, they are used
by the Axis class to support major and minor tick locating and formatting.
.. _tick_locating:
.. _locators:
Tick locating
-------------
The Locator class is the base class for all tick locators. The locators
handle autoscaling of the view limits based on the data limits, and the
choosing of tick locations. A useful semi-automatic tick locator is
`MultipleLocator`. It is initialized with a base, e.g., 10, and it picks
axis limits and ticks that are multiples of that base.
The Locator subclasses defined here are:
======================= =======================================================
`AutoLocator` `MaxNLocator` with simple defaults. This is the default
tick locator for most plotting.
`MaxNLocator` Finds up to a max number of intervals with ticks at
nice locations.
`LinearLocator` Space ticks evenly from min to max.
`LogLocator` Space ticks logarithmically from min to max.
`MultipleLocator` Ticks and range are a multiple of base; either integer
or float.
`FixedLocator` Tick locations are fixed.
`IndexLocator` Locator for index plots (e.g., where
``x = range(len(y))``).
`NullLocator` No ticks.
`SymmetricalLogLocator` Locator for use with the symlog norm; works like
`LogLocator` for the part outside of the threshold and
adds 0 if inside the limits.
`AsinhLocator` Locator for use with the asinh norm, attempting to
space ticks approximately uniformly.
`LogitLocator` Locator for logit scaling.
`AutoMinorLocator` Locator for minor ticks when the axis is linear and the
major ticks are uniformly spaced. Subdivides the major
tick interval into a specified number of minor
intervals, defaulting to 4 or 5 depending on the major
interval.
======================= =======================================================
There are a number of locators specialized for date locations - see
the :mod:`.dates` module.
You can define your own locator by deriving from Locator. You must
override the ``__call__`` method, which returns a sequence of locations,
and you will probably want to override the autoscale method to set the
view limits from the data limits.
If you want to override the default locator, use one of the above or a custom
locator and pass it to the x- or y-axis instance. The relevant methods are::
ax.xaxis.set_major_locator(xmajor_locator)
ax.xaxis.set_minor_locator(xminor_locator)
ax.yaxis.set_major_locator(ymajor_locator)
ax.yaxis.set_minor_locator(yminor_locator)
The default minor locator is `NullLocator`, i.e., no minor ticks on by default.
.. note::
`Locator` instances should not be used with more than one
`~matplotlib.axis.Axis` or `~matplotlib.axes.Axes`. So instead of::
locator = MultipleLocator(5)
ax.xaxis.set_major_locator(locator)
ax2.xaxis.set_major_locator(locator)
do the following instead::
ax.xaxis.set_major_locator(MultipleLocator(5))
ax2.xaxis.set_major_locator(MultipleLocator(5))
.. _formatters:
Tick formatting
---------------
Tick formatting is controlled by classes derived from Formatter. The formatter
operates on a single tick value and returns a string to the axis.
========================= =====================================================
`NullFormatter` No labels on the ticks.
`FixedFormatter` Set the strings manually for the labels.
`FuncFormatter` User defined function sets the labels.
`StrMethodFormatter` Use string `format` method.
`FormatStrFormatter` Use an old-style sprintf format string.
`ScalarFormatter` Default formatter for scalars: autopick the format
string.
`LogFormatter` Formatter for log axes.
`LogFormatterExponent` Format values for log axis using
``exponent = log_base(value)``.
`LogFormatterMathtext` Format values for log axis using
``exponent = log_base(value)`` using Math text.
`LogFormatterSciNotation` Format values for log axis using scientific notation.
`LogitFormatter` Probability formatter.
`EngFormatter` Format labels in engineering notation.
`PercentFormatter` Format labels as a percentage.
========================= =====================================================
You can derive your own formatter from the Formatter base class by
simply overriding the ``__call__`` method. The formatter class has
access to the axis view and data limits.
To control the major and minor tick label formats, use one of the
following methods::
ax.xaxis.set_major_formatter(xmajor_formatter)
ax.xaxis.set_minor_formatter(xminor_formatter)
ax.yaxis.set_major_formatter(ymajor_formatter)
ax.yaxis.set_minor_formatter(yminor_formatter)
In addition to a `.Formatter` instance, `~.Axis.set_major_formatter` and
`~.Axis.set_minor_formatter` also accept a ``str`` or function. ``str`` input
will be internally replaced with an autogenerated `.StrMethodFormatter` with
the input ``str``. For function input, a `.FuncFormatter` with the input
function will be generated and used.
See :doc:`/gallery/ticks/major_minor_demo` for an example of setting major
and minor ticks. See the :mod:`matplotlib.dates` module for more information
and examples of using date locators and formatters.
<EFBFBD>N)<01>Integral)<02>_api<70>cbook)<01>
transforms)<1C>
TickHelper<EFBFBD> Formatter<65>FixedFormatter<65> NullFormatter<65> FuncFormatter<65>FormatStrFormatter<65>StrMethodFormatter<65>ScalarFormatter<65> LogFormatter<65>LogFormatterExponent<6E>LogFormatterMathtext<78>LogFormatterSciNotation<6F>LogitFormatter<65> EngFormatter<65>PercentFormatter<65>Locator<6F> IndexLocator<6F> FixedLocator<6F> NullLocator<6F> LinearLocator<6F>
LogLocator<EFBFBD> AutoLocator<6F>MultipleLocator<6F> MaxNLocator<6F>AutoMinorLocator<6F>SymmetricalLogLocator<6F> AsinhLocator<6F> LogitLocatorc<00><<00>eZdZdZd
d<02>Zd<03>Zd<04>Zd<05>Zd<06>Zd<07>Zd<08>Z y ) <0B>
_DummyAxis<EFBFBD>dummyc<00>.<00>d|_d|_||_y)N)r<00>)<03>_data_interval<61>_view_interval<61>_minpos)<02>self<6C>minposs <20>T/home/antigravity/intellecton/venv/lib/python3.12/site-packages/matplotlib/ticker.py<70>__init__z_DummyAxis.__init__<5F>s<00><00>$<24><04><1B>$<24><04><1B><1D><04> <0C>c<00><00>|jS<00>N<>r)<00>r+s r-<00>get_view_intervalz_DummyAxis.get_view_interval<61><00><00><00><13>"<22>"<22>"r/c<00><00>||f|_yr1r2<00>r+<00>vmin<69>vmaxs r-<00>set_view_intervalz_DummyAxis.set_view_interval<61><00><00><00>#<23>T<EFBFBD>l<EFBFBD><04>r/c<00><00>|jSr1)r*r3s r-<00>
get_minposz_DummyAxis.get_minpos<6F>s <00><00><13>|<7C>|<7C>r/c<00><00>|jSr1<00>r(r3s r-<00>get_data_intervalz_DummyAxis.get_data_interval<61>r5r/c<00><00>||f|_yr1r?r7s r-<00>set_data_intervalz_DummyAxis.set_data_interval<61>r;r/c<00><00>y)N<> <00>r3s r-<00>get_tick_spacez_DummyAxis.get_tick_space<63>s<00><00>r/N<>r)
<EFBFBD>__name__<5F>
__module__<EFBFBD> __qualname__r.r4r:r=r@rBrFrEr/r-r$r$<00>s*<00><00><16>H<EFBFBD><1E>
#<23>+<2B><1C>#<23>+<2B>r/r$c<00><00>eZdZdZd<02>Zd<03>Zy)rNc<00><00>||_yr1)<01>axis)r+rMs r-<00>set_axiszTickHelper.set_axis<69>s <00><00><18><04> r/c <00>><00>|j<00>tdi|<01><01>|_yy)NrE)rMr$<00>r+<00>kwargss r-<00>create_dummy_axiszTickHelper.create_dummy_axis<69>s <00><00> <0F>9<EFBFBD>9<EFBFBD> <1C>"<22>,<2C>V<EFBFBD>,<2C>D<EFBFBD>I<EFBFBD> r/)rHrIrJrMrNrRrEr/r-rr<00>s<00><00> <0F>D<EFBFBD><19>-r/rc<00>P<00>eZdZdZgZd d<03>Zd<04>Zd<05>Zd<06>Zd<07>Z d<08>Z
e d <09><00>Z d
<EFBFBD>Z y) rz=
Create a string based on a tick value and location.
Nc<00><00>td<01><00>)z
Return the format for tick value *x* at position pos.
``pos=None`` indicates an unspecified location.
<20>Derived must override<64><01>NotImplementedError<6F>r+<00>x<>poss r-<00>__call__zFormatter.__call__<5F>s<00><00>
"<22>"9<>:<3A>:r/c<00>z<00>|j|<01>t|<01>D<00><02>cgc]\}}|||<02><00><02>c}}Scc}}w)z1Return the tick labels for all the ticks at once.)<02>set_locs<63> enumerate)r+<00>values<65>i<>values r-<00> format_tickszFormatter.format_ticks<6B>s1<00><00> <0C> <0A> <0A>f<EFBFBD><1D>/8<><16>/@<40>A<>8<EFBFBD>1<EFBFBD>e<EFBFBD><04>U<EFBFBD>A<EFBFBD><0E>A<>A<><41>As<00>7c<00>$<00>|j|<01>S)zk
Return the full string representation of the value with the
position unspecified.
)r[<00>r+ras r-<00> format_datazFormatter.format_data<74>s<00><00>
<14>}<7D>}<7D>U<EFBFBD>#<23>#r/c<00>$<00>|j|<01>S)z|
Return a short string version of the tick value.
Defaults to the position-independent long value.
<20>rerds r-<00>format_data_shortzFormatter.format_data_short<72>s<00><00> <14><1F><1F><05>&<26>&r/c<00><00>y<01>N<>rEr3s r-<00>
get_offsetzFormatter.get_offset<65>s<00><00>r/c<00><00>||_y)z<>
Set the locations of the ticks.
This method is called before computing the tick labels because some
formatters need to know all tick locations to do so.
N<><01>locs<63>r+ros r-r]zFormatter.set_locs<63>s <00><00><19><04> r/c<00>P<00>tjdr|jdd<03>S|S)a 
Some classes may want to replace a hyphen for minus with the proper
Unicode symbol (U+2212) for typographical correctness. This is a
helper method to perform such a replacement when it is enabled via
:rc:`axes.unicode_minus`.
zaxes.unicode_minus<75>-u−)<03>mpl<70>rcParams<6D>replace)<01>ss r-<00> fix_minuszFormatter.fix_minus<75>s/<00><00><17><<3C><<3C> 4<>5<><12> <09> <09>#<23>/<2F>0<> <18><16> r/c<00><00>y)z6Subclasses may want to override this to set a locator.NrE)r+<00>locators r-<00> _set_locatorzFormatter._set_locators<00><00> r/r1)rHrIrJ<00>__doc__ror[rbrerhrlr]<00> staticmethodrwrzrEr/r-rr<00>sF<00><00><08>
<0E>D<EFBFBD>;<3B>B<01>
$<24>'<27><12><19><12> <18><12> <18> r/rc<00><00>eZdZdZdd<03>Zy)r
zAlways return the empty string.Nc<00><00>yrjrErXs r-r[zNullFormatter.__call__
s<00><00>r/r1)rHrIrJr{r[rEr/r-r
r
s
<00><00>)<29>r/r
c<00>*<00>eZdZdZd<02>Zdd<04>Zd<05>Zd<06>Zy)r z<>
Return fixed strings for tick labels based only on position, not value.
.. note::
`.FixedFormatter` should only be used together with `.FixedLocator`.
Otherwise, the labels may end up in unexpected positions.
c<00> <00>||_d|_y)z?Set the sequence *seq* of strings that will be used for labels.rkN)<02>seq<65> offset_string)r+r<>s r-r.zFixedFormatter.__init__s<00><00><16><04><08><1F><04>r/Nc<00>V<00>|<02>|t|j<00>k\ry|j|S)a
Return the label that matches the position, regardless of the value.
For positions ``pos < len(seq)``, return ``seq[i]`` regardless of
*x*. Otherwise return empty string. ``seq`` is the sequence of
strings that this object was initialized with.
rk)<02>lenr<6E>rXs r-r[zFixedFormatter.__call__s)<00><00> <0F>;<3B>#<23><13>T<EFBFBD>X<EFBFBD>X<EFBFBD><1D>.<2E><15><17>8<EFBFBD>8<EFBFBD>C<EFBFBD>=<3D> r/c<00><00>|jSr1<00>r<>r3s r-rlzFixedFormatter.get_offset*<00><00><00><13>!<21>!<21>!r/c<00><00>||_yr1r<><00>r+<00>ofss r-<00>set_offset_stringz FixedFormatter.set_offset_string-<00>
<00><00> <20><04>r/r1<00>rHrIrJr{r.r[rlr<>rEr/r-r r s<00><00><08> <20>
!<21>"<22>!r/r c<00>*<00>eZdZdZd<02>Zdd<04>Zd<05>Zd<06>Zy)r z<>
Use a user-defined function for formatting.
The function should take in two inputs (a tick value ``x`` and a
position ``pos``), and return a string containing the corresponding
tick label.
c<00> <00>||_d|_yrj)<02>funcr<63>)r+r<>s r-r.zFuncFormatter.__init__:s<00><00><18><04> <09><1F><04>r/Nc<00>&<00>|j||<02>S)zq
Return the value of the user defined function.
*x* and *pos* are passed through as-is.
)r<>rXs r-r[zFuncFormatter.__call__>s<00><00> <14>y<EFBFBD>y<EFBFBD><11>C<EFBFBD> <20> r/c<00><00>|jSr1r<>r3s r-rlzFuncFormatter.get_offsetFr<>r/c<00><00>||_yr1r<>r<>s r-r<>zFuncFormatter.set_offset_stringIr<>r/r1r<>rEr/r-r r 1s<00><00><08> <20>!<21>"<22>!r/r c<00><00>eZdZdZd<02>Zdd<04>Zy)r a<>
Use an old-style ('%' operator) format string to format the tick.
The format string should have a single variable format (%) in it.
It will be applied to the value (not the position) of the tick.
Negative numeric values (e.g., -1) will use a dash, not a Unicode minus;
use mathtext to get a Unicode minus by wrapping the format specifier with $
(e.g. "$%g$").
c<00><00>||_yr1<00><01>fmt<6D>r+r<>s r-r.zFormatStrFormatter.__init__Y<00> <00><00><16><04>r/Nc<00> <00>|j|zS)zw
Return the formatted label string.
Only the value *x* is formatted. The position is ignored.
r<>rXs r-r[zFormatStrFormatter.__call__\s<00><00> <14>x<EFBFBD>x<EFBFBD>!<21>|<7C>r/r1<00>rHrIrJr{r.r[rEr/r-r r Ms<00><00> <08><17>r/r c<00>"<00><00>eZdZdZ<03>fd<02>Z<04>xZS)<03>_UnicodeMinusFormata.
A specialized string formatter so that `.StrMethodFormatter` respects
:rc:`axes.unicode_minus`. This implementation relies on the fact that the
format string is only ever called with kwargs *x* and *pos*, so it blindly
replaces dashes by unicode minuses without further checking.
c<00>J<00><01>tjt<00>|<00> ||<02><00>Sr1)rrw<00>super<65> format_field)r+ra<00> format_spec<65> __class__s <20>r-r<>z _UnicodeMinusFormat.format_fieldms <00><><00><18>"<22>"<22>5<EFBFBD>7<EFBFBD>#7<><05>{<7B>#K<>L<>Lr/)rHrIrJr{r<><00> __classcell__<5F>r<>s@r-r<>r<>es<00><><00><08>M<01>Mr/r<>c<00><00>eZdZdZd<02>Zdd<04>Zy)r a<>
Use a new-style format string (as used by `str.format`) to format the tick.
The field used for the tick value must be labeled *x* and the field used
for the tick position must be labeled *pos*.
The formatter will respect :rc:`axes.unicode_minus` when formatting
negative numeric values.
It is typically unnecessary to explicitly construct `.StrMethodFormatter`
objects, as `~.Axis.set_major_formatter` directly accepts the format string
itself.
c<00><00>||_yr1r<>r<>s r-r.zStrMethodFormatter.__init__<5F>r<>r/Nc<00>N<00>t<00>j|j||<02><01>S)z<>
Return the formatted label string.
*x* and *pos* are passed to `str.format` as keyword arguments
with those exact names.
)rYrZ)r<><00>formatr<74>rXs r-r[zStrMethodFormatter.__call__<5F>s#<00><00>#<23>$<24>+<2B>+<2B>D<EFBFBD>H<EFBFBD>H<EFBFBD><01>s<EFBFBD>+<2B>C<>Cr/r1r<>rEr/r-r r qs<00><00> <08><17>Dr/r c<00><><00>eZdZdZddd<03>d<04>Zd<05>Zd<06>Zeee<06><07>Zd<08>Z d <09>Z
ee e
<EFBFBD><07>Z d
<EFBFBD>Z d <0B>Z ee e <0A><07>Zd <0C>Zd <0A>Zd<0E>Zeee<11><07>Zdd<0F>Zd<10>Zd<11>Zd<12>Zd<13>Zd<14>Zd<15>Zd<16>Zd<17>Zd<18>Zy)ra@
Format tick values as a number.
Parameters
----------
useOffset : bool or float, default: :rc:`axes.formatter.useoffset`
Whether to use offset notation. See `.set_useOffset`.
useMathText : bool, default: :rc:`axes.formatter.use_mathtext`
Whether to use fancy math formatting. See `.set_useMathText`.
useLocale : bool, default: :rc:`axes.formatter.use_locale`.
Whether to use locale settings for decimal sign and positive sign.
See `.set_useLocale`.
usetex : bool, default: :rc:`text.usetex`
To enable/disable the use of TeX's math mode for rendering the
numbers in the formatter.
.. versionadded:: 3.10
Notes
-----
In addition to the parameters above, the formatting of scientific vs.
floating point representation can be configured via `.set_scientific`
and `.set_powerlimits`).
**Offset notation and scientific notation**
Offset notation and scientific notation look quite similar at first sight.
Both split some information from the formatted tick values and display it
at the end of the axis.
- The scientific notation splits up the order of magnitude, i.e. a
multiplicative scaling factor, e.g. ``1e6``.
- The offset notation separates an additive constant, e.g. ``+1e6``. The
offset notation label is always prefixed with a ``+`` or ``-`` sign
and is thus distinguishable from the order of magnitude label.
The following plot with x limits ``1_000_000`` to ``1_000_010`` illustrates
the different formatting. Note the labels at the right edge of the x axis.
.. plot::
lim = (1_000_000, 1_000_010)
fig, (ax1, ax2, ax3) = plt.subplots(3, 1, gridspec_kw={'hspace': 2})
ax1.set(title='offset notation', xlim=lim)
ax2.set(title='scientific notation', xlim=lim)
ax2.xaxis.get_major_formatter().set_useOffset(False)
ax3.set(title='floating-point notation', xlim=lim)
ax3.xaxis.get_major_formatter().set_useOffset(False)
ax3.xaxis.get_major_formatter().set_scientific(False)
N)<01>usetexc<00>@<00>|<01>tjd}tjd|_|j|<01>|j |<04>|j |<02>d|_d|_d|_tjd|_ |j|<03>y)Nzaxes.formatter.useoffsetzaxes.formatter.offset_thresholdrrkTzaxes.formatter.limits) rsrt<00>_offset_threshold<6C> set_useOffset<65>
set_usetex<EFBFBD>set_useMathText<78>orderOfMagnituder<65><00> _scientific<69> _powerlimits<74> set_useLocale)r+<00> useOffset<65> useMathText<78> useLocaler<65>s r-r.zScalarFormatter.__init__<5F>s<><00><00> <14> <1C><1B> <0C> <0C>%?<3F>@<40>I<EFBFBD> <0F>L<EFBFBD>L<EFBFBD>:<3A> ;<3B> <0A><1E> <0C><1A><1A>9<EFBFBD>%<25> <0C><0F><0F><06><1F> <0C><1C><1C>[<5B>)<29> !<21><04><1D><18><04> <0B><1F><04><18><1F>L<EFBFBD>L<EFBFBD>)@<40>A<><04><19> <0C><1A><1A>9<EFBFBD>%r/c<00><00>|jS)z8Return whether TeX's math mode is enabled for rendering.)<01>_usetexr3s r-<00>
get_usetexzScalarFormatter.get_usetex<65>s <00><00><13>|<7C>|<7C>r/c<00>:<00>tj|d<01>|_y)zJSet whether to use TeX's math mode for rendering numbers in the formatter.<2E> text.usetexN)rs<00>
_val_or_rcr<EFBFBD><00>r+<00>vals r-r<>zScalarFormatter.set_usetex<65>s<00><00><1A>~<7E>~<7E>c<EFBFBD>=<3D>9<><04> r/)<02>fget<65>fsetc<00><00>|jS)a$
Return whether automatic mode for offset notation is active.
This returns True if ``set_useOffset(True)``; it returns False if an
explicit offset was set, e.g. ``set_useOffset(1000)``.
See Also
--------
ScalarFormatter.set_useOffset
)<01>
_useOffsetr3s r-<00> get_useOffsetzScalarFormatter.get_useOffset<65>s<00><00><14><EFBFBD><EFBFBD>r/c<00>F<00>|dvrd|_||_yd|_||_y)a<>
Set whether to use offset notation.
When formatting a set numbers whose value is large compared to their
range, the formatter can separate an additive constant. This can
shorten the formatted numbers so that they are less likely to overlap
when drawn on an axis.
Parameters
----------
val : bool or float
- If False, do not use offset notation.
- If True (=automatic mode), use offset notation if it can make
the residual numbers significantly shorter. The exact behavior
is controlled by :rc:`axes.formatter.offset_threshold`.
- If a number, force an offset of the given value.
Examples
--------
With active offset notation, the values
``100_000, 100_002, 100_004, 100_006, 100_008``
will be formatted as ``0, 2, 4, 6, 8`` plus an offset ``+1e5``, which
is written to the edge of the axis.
)TFrFN)<02>offsetr<74>r<>s r-r<>zScalarFormatter.set_useOffset<65>s(<00><00>6 <0F>-<2D> <1F><1B>D<EFBFBD>K<EFBFBD>!<21>D<EFBFBD>O<EFBFBD>#<23>D<EFBFBD>O<EFBFBD><1D>D<EFBFBD>Kr/c<00><00>|jS)z<>
Return whether locale settings are used for formatting.
See Also
--------
ScalarFormatter.set_useLocale
)<01>
_useLocaler3s r-<00> get_useLocalezScalarFormatter.get_useLocales<00><00><14><EFBFBD><EFBFBD>r/c<00>H<00>|<01>tjd|_y||_y)z<>
Set whether to use locale settings for decimal sign and positive sign.
Parameters
----------
val : bool or None
*None* resets to :rc:`axes.formatter.use_locale`.
Nzaxes.formatter.use_locale)rsrtr<>r<>s r-r<>zScalarFormatter.set_useLocales!<00><00> <0F>;<3B>!<21>l<EFBFBD>l<EFBFBD>+F<>G<>D<EFBFBD>O<EFBFBD>!<21>D<EFBFBD>Or/c<00><><00><02>|j|jrU|jr-dj<00>fd<02>|j d<01>D<00><00><00>St j |<01>fd<03><00>S|<01>z<00>S)zX
Format *arg* with *fmt*, applying Unicode minus and locale if desired.
<20>,c3<00>n<00>K<00>|],}tj|<01>fd<00>jdd<02><00><01><00>.y<03>w)Tr<54>z{,}N)<03>locale<6C> format_stringru)<03>.0<EFBFBD>part<72>args <20>r-<00> <genexpr>zAScalarFormatter._format_maybe_minus_and_locale.<locals>.<genexpr>/s8<00><><00><><00>6<>"<22>!<21>.<2E>.<2E>t<EFBFBD>c<EFBFBD>V<EFBFBD>T<EFBFBD>B<>J<>J<>3<EFBFBD>PU<50>V<>6<>s<00>25T)rwr<><00> _useMathText<78>join<69>splitr<74>r<>)r+r<>r<>s `r-<00>_format_maybe_minus_and_localez.ScalarFormatter._format_maybe_minus_and_locale(s<><00><><00><14>~<7E>~<7E> <18>?<3F>?<3F>:><3E>9J<39>9J<39><15><18><18>6<>&)<29>i<EFBFBD>i<EFBFBD><03>n<EFBFBD>6<>6<> <20> <20>
<1D>*<2A>*<2A>3<EFBFBD><13><06><04>=<3D>  <20> <20><19>3<EFBFBD>Y<EFBFBD> <20> r/c<00><00>|jS)z<>
Return whether to use fancy math formatting.
See Also
--------
ScalarFormatter.set_useMathText
)r<>r3s r-<00>get_useMathTextzScalarFormatter.get_useMathText5s<00><00><14> <20> <20> r/c<00>l<00>|<01><>tjd|_|jdurs ddlm}|j |j tjd<00><07>d<03><08>}|ttjd <09><00>k(rtjd
<EFBFBD>yyy||_y#t$rd}Y<00>NwxYw) a
Set whether to use fancy math formatting.
If active, scientific notation is formatted as :math:`1.2 \times 10^3`.
Parameters
----------
val : bool or None
*None* resets to :rc:`axes.formatter.use_mathtext`.
Nzaxes.formatter.use_mathtextFr)<01> font_managerz font.family)<01>family)<01>fallback_to_defaultzfonts/ttf/cmr10.ttfzXcmr10 font should ideally be used with mathtext, set axes.formatter.use_mathtext to True) rsrtr<><00>
matplotlibr<EFBFBD><00>findfont<6E>FontProperties<65>
ValueError<EFBFBD>strr<00>_get_data_pathr<00> warn_external)r+r<>r<><00>ufonts r-r<>zScalarFormatter.set_useMathText?s<><00><00> <0F>;<3B> #<23> <0C> <0C>-J<> K<>D<EFBFBD> <1D><13> <20> <20>E<EFBFBD>)<29> !<21>7<>(<28>1<>1<>$<24>3<>3<>#&<26><<3C><<3C> <0A>#><3E>4<><1A>-2<> 2<><16>E<EFBFBD><19>C<EFBFBD><05> 4<> 4<>5J<35> K<>L<>L<><18>&<26>&<26>L<01><16>M<01>*<2A>$!$<24>D<EFBFBD> <1D><>"<22>!<21> <20>E<EFBFBD>!<21>s<00>:B%<00>% B3<03>2B3c<00><><00>t|j<00>dk(ry||jz
d|jzz }t |<03>dkrd}|j |j |<03>S)zI
Return the format for tick value *x* at position *pos*.
rrk<00>$@<40>:<3A>0<EFBFBD><30>yE>)r<>ror<>r<><00>absr<73>r<><00>r+rYrZ<00>xps r-r[zScalarFormatter.__call__bs[<00><00> <0F>t<EFBFBD>y<EFBFBD>y<EFBFBD>><3E>Q<EFBFBD> <1E><15><13>d<EFBFBD>k<EFBFBD>k<EFBFBD>/<2F>c<EFBFBD>T<EFBFBD>-B<>-B<>&B<>C<>B<EFBFBD><12>2<EFBFBD>w<EFBFBD><14>~<7E><16><02><17>6<>6<>t<EFBFBD>{<7B>{<7B>B<EFBFBD>G<> Gr/c<00>$<00>t|<01>|_y)z<>
Turn scientific notation on or off.
See Also
--------
ScalarFormatter.set_powerlimits
N)<02>boolr<6C>)r+<00>bs r-<00>set_scientificzScalarFormatter.set_scientificns<00><00> <20><01>7<EFBFBD><04>r/c<00>D<00>t|<01>dk7r td<02><00>||_y)a
Set size thresholds for scientific notation.
Parameters
----------
lims : (int, int)
A tuple *(min_exp, max_exp)* containing the powers of 10 that
determine the switchover threshold. For a number representable as
:math:`a \times 10^\mathrm{exp}` with :math:`1 <= |a| < 10`,
scientific notation will be used if ``exp <= min_exp`` or
``exp >= max_exp``.
The default limits are controlled by :rc:`axes.formatter.limits`.
In particular numbers with *exp* equal to the thresholds are
written in scientific notation.
Typically, *min_exp* will be negative and *max_exp* will be
positive.
For example, ``formatter.set_powerlimits((-3, 4))`` will provide
the following formatting:
:math:`1 \times 10^{-3}, 9.9 \times 10^{-3}, 0.01,`
:math:`9999, 1 \times 10^4`.
See Also
--------
ScalarFormatter.set_scientific
<20>z%'lims' must be a sequence of length 2N)r<>r<>r<>)r+<00>limss r-<00>set_powerlimitszScalarFormatter.set_powerlimitsxs#<00><00>< <0F>t<EFBFBD>9<EFBFBD><01>><3E><1C>D<>E<> E<> <20><04>r/c<00>H<00>|tjjuryt|t<00>rd}<02>n`t |j dd<01>dv<00>r|j jdk(ri|j jj<00>}|j<00>}|j|df<02>}|j|ddgddggz<00>dd<00>df}nh|j jj<00>}|j<00>}|jd|f<02>}|j|ddgddggz<00>dd<00>df}t||z
<00>j<00>}n%|j j<00>\}} | |z
d z }d
t!j"||<07><00>d <0B>}|j%||<01>S) Nrk<00>%drH)<02>xaxis<69>yaxisr<73>r<00><><EFBFBD><EFBFBD><EFBFBD>r'<00><00><>@z%-#.<2E>g)<13>np<6E>ma<6D>masked<65>
isinstancer<00>getattrrMrH<00>axes<65>get_xaxis_transform<72>inverted<65> transform<72>get_yaxis_transformr<6D><00>maxr4r<00> _g_sig_digitsr<73>)
r+rar<><00>axis_trf<72> axis_inv_trf<72> screen_xy<78>neighbor_values<65>delta<74>ar<61>s
r-rhz!ScalarFormatter.format_data_short<72>s<><00><00> <10>B<EFBFBD>E<EFBFBD>E<EFBFBD>L<EFBFBD>L<EFBFBD> <20><15> <15>e<EFBFBD>X<EFBFBD> &<26><16>C<EFBFBD><16>t<EFBFBD>y<EFBFBD>y<EFBFBD>*<2A>b<EFBFBD>1<>5G<35>G<><17>9<EFBFBD>9<EFBFBD>%<25>%<25><17>0<>#<23>y<EFBFBD>y<EFBFBD>~<7E>~<7E>A<>A<>C<>H<EFBFBD>#+<2B>#4<>#4<>#6<>L<EFBFBD> (<28> 2<> 2<>E<EFBFBD>1<EFBFBD>:<3A> ><3E>I<EFBFBD>&2<>&<<3C>&<<3C>!<21>b<EFBFBD>!<21>W<EFBFBD>r<EFBFBD>1<EFBFBD>g<EFBFBD>$6<>6<>'8<>89<38>1<EFBFBD><04>'><3E>O<EFBFBD> $<24>y<EFBFBD>y<EFBFBD>~<7E>~<7E>A<>A<>C<>H<EFBFBD>#+<2B>#4<>#4<>#6<>L<EFBFBD> (<28> 2<> 2<>A<EFBFBD>u<EFBFBD>:<3A> ><3E>I<EFBFBD>&2<>&<<3C>&<<3C>!<21>a<EFBFBD><12>W<EFBFBD>q<EFBFBD>"<22>g<EFBFBD>$6<>6<>'8<>89<38>1<EFBFBD><04>'><3E>O<EFBFBD><1B>O<EFBFBD>e<EFBFBD>3<>4<>8<>8<>:<3A><05><1C>y<EFBFBD>y<EFBFBD>2<>2<>4<><04><01>1<EFBFBD><1A>Q<EFBFBD><15>#<23> <0A><05><18><15>,<2C>,<2C>U<EFBFBD>E<EFBFBD>:<3A>;<3B>1<EFBFBD>=<3D>C<EFBFBD><13>2<>2<>3<EFBFBD><05>><3E>>r/c<00>V<00>tjtjt|<01><00><00>}t |d|zz d<01>}|j |dzdk(rdnd|<03>}|dk(r|S|j d|<02>}|j s |jrd|z}|dk(r|S|<04>d|<05><00>S|<04>d|<05><00>S) N<>
r'rr<>z%1.10gz10^{%s}z \times <20>e)<08>math<74>floor<6F>log10r<30><00>roundr<64>r<>r<>)r+rarrv<00> significand<6E>exponents r-rezScalarFormatter.format_data<74>s<><00><00> <10>J<EFBFBD>J<EFBFBD>t<EFBFBD>z<EFBFBD>z<EFBFBD>#<23>e<EFBFBD>*<2A>-<2D> .<2E><01> <11>%<25>"<22>a<EFBFBD>%<25>-<2D><12> $<24><01><1A>9<>9<><15><01>E<EFBFBD>Q<EFBFBD>J<EFBFBD>D<EFBFBD>H<EFBFBD>a<EFBFBD>1<> <0B> <0C><01>6<EFBFBD><1E> <1E><17>6<>6<>t<EFBFBD>Q<EFBFBD>?<3F><08> <0F> <1C> <1C><04> <0C> <0C> <20>8<EFBFBD>+<2B>H<EFBFBD> !<21>Q<EFBFBD><06>H<EFBFBD> ><3E>(<28>M<EFBFBD><18>(<28><1A><<3C> ><3E>"<22>]<5D>!<21>H<EFBFBD>:<3A>.<2E> .r/c<00>(<00>t|j<00>dk(ry|js |jr<>d}d}|jr/|j |j<00>}|jdkDrd|z}|jrF|j
s |j r|j d|jz<00>}nd|jz}|j s |j
r|dk7rd|z}d|<02>d|<01>d <09>}ndj||f<02>}|j|<03>Sy)
z:
Return scientific notation, plus offset.
rrk<00>+r z1e%dz\times\mathdefault{%s}<7D>$z \mathdefault{z}$) r<>ror<>r<>rer<>r<>r<>rw<00>r+<00> offsetStr<74> sciNotStrrvs r-rlzScalarFormatter.get_offset<65>s<><00><00> <0F>t<EFBFBD>y<EFBFBD>y<EFBFBD>><3E>Q<EFBFBD> <1E><15> <0F> <20> <20>D<EFBFBD>K<EFBFBD>K<EFBFBD><1A>I<EFBFBD><1A>I<EFBFBD><13>{<7B>{<7B> <20>,<2C>,<2C>T<EFBFBD>[<5B>[<5B>9<> <09><17>;<3B>;<3B><11>?<3F> #<23>i<EFBFBD><0F>I<EFBFBD><13>$<24>$<24><17><<3C><<3C>4<EFBFBD>#4<>#4<> $<24> 0<> 0<><12>t<EFBFBD>7L<37>7L<37>1L<31> M<>I<EFBFBD> &<26><14>)><3E>)><3E> ><3E>I<EFBFBD><13> <20> <20>D<EFBFBD>L<EFBFBD>L<EFBFBD><1C><02>?<3F> 9<>I<EFBFBD> E<>I<EFBFBD><18><19> <0B>><3E>)<29><1B>C<EFBFBD>@<40><01><16>G<EFBFBD>G<EFBFBD>Y<EFBFBD> <09>2<>3<><01><17>><3E>><3E>!<21>$<24> $<24>r/c<00><><00>||_t|j<00>dkDr=|jr|j<00>|j <00>|j <00>yy)Nr)ror<>r<><00>_compute_offset<65>_set_order_of_magnitude<64> _set_formatrps r-r]zScalarFormatter.set_locs<63>sI<00><00><18><04> <09> <0E>t<EFBFBD>y<EFBFBD>y<EFBFBD>><3E>A<EFBFBD> <1D><13><EFBFBD><EFBFBD><14>$<24>$<24>&<26> <10> (<28> (<28> *<2A> <10> <1C> <1C> <1E> r/c<00><><00>
<EFBFBD> <0B>|j}t|jj<00><00>\}}t j
|<01>}|||k||kz}t |<01>sd|_y|j<00>|j<00>}}||k(s|dcxkr |krd|_ynd|_yttt|<04><00>tt|<05><00>g<02>\<00> <0B>
tjd|<04>}t jtj<00>
<EFBFBD><00>}dt!<00>
<EFBFBD> fd<03>t#j$|d<04>D<00><00>z}<08>
<EFBFBD> z
d|zz dkr,dt!<00>
<EFBFBD> fd<07>t#j$|d<04>D<00><00>z}|j&dz
} <09>
d|zzd| zk\r|<06>
d|zzzd|zz|_yd|_y)Nrr'c3<00>D<00>K<00>|]}<01>d|zz<00>d|zzk7r|<01><01><00>y<01>w)r NrE<00>r<><00>oom<6F>abs_max<61>abs_mins <20><>r-r<>z2ScalarFormatter._compute_offset.<locals>.<genexpr>s4<00><><00><><00>H<01>s<EFBFBD>!<21>R<EFBFBD>3<EFBFBD>Y<EFBFBD>.<2E>'<27>R<EFBFBD>3<EFBFBD>Y<EFBFBD>2F<32>F<><1B>H<01>s<00> r<>r <00>{<14>G<EFBFBD>z<EFBFBD>?c3<00>J<00>K<00>|]}<01>d|zz<00>d|zzz
dkDr|<01><01><00>y<02>w)r r'NrEr!s <20><>r-r<>z2ScalarFormatter._compute_offset.<locals>.<genexpr> s9<00><><00><><00>O<01>3<EFBFBD>%<25><12>s<EFBFBD><19>2<>W<EFBFBD><02>c<EFBFBD> <09>5I<35>I<>A<EFBFBD>M<><1F>O<01>s<00> #)ro<00>sortedrMr4r<><00>asarrayr<79>r<><00>minrr<><00>floatr<00>copysign<67>ceilr<00>next<78> itertools<6C>countr<74>) r+ror8r9<00>lmin<69>lmax<61>sign<67>oom_maxr"<00>nr#r$s @@r-rzScalarFormatter._compute_offset<65>s<><00><><00><13>y<EFBFBD>y<EFBFBD><04><1B>D<EFBFBD>I<EFBFBD>I<EFBFBD>7<>7<>9<>:<3A>
<EFBFBD><04>d<EFBFBD><11>z<EFBFBD>z<EFBFBD>$<24><1F><04><13>T<EFBFBD>T<EFBFBD>\<5C>d<EFBFBD>d<EFBFBD>l<EFBFBD>3<>4<><04><12>4<EFBFBD>y<EFBFBD><1B>D<EFBFBD>K<EFBFBD> <12><19>X<EFBFBD>X<EFBFBD>Z<EFBFBD><14><18><18><1A>d<EFBFBD><04> <10>4<EFBFBD><<3C>4<EFBFBD>1<EFBFBD>,<2C><04>,<2C><1B>D<EFBFBD>K<EFBFBD> <12>-<2D><1B>D<EFBFBD>K<EFBFBD> <12>"<22>3<EFBFBD>u<EFBFBD>T<EFBFBD>{<7B>#3<>S<EFBFBD><15>t<EFBFBD><1B>5E<35>"F<>G<><18><07><17><13>}<7D>}<7D>Q<EFBFBD><04>%<25><04>
<15>'<27>'<27>$<24>*<2A>*<2A>W<EFBFBD>-<2D>.<2E><07><0F>$<24>H<01>i<EFBFBD>o<EFBFBD>o<EFBFBD>g<EFBFBD>r<EFBFBD>&B<>H<01>H<01>H<01><03> <13>g<EFBFBD> <1D><12>s<EFBFBD><19> *<2A>d<EFBFBD> 2<>
<14>d<EFBFBD>O<01>)<29>/<2F>/<2F>'<27>2<EFBFBD>*F<>O<01>O<01>O<01>C<EFBFBD> <11> "<22> "<22>Q<EFBFBD> &<26><01>!<21>R<EFBFBD>3<EFBFBD>Y<EFBFBD>.<2E>"<22>a<EFBFBD>%<25>7<><1C>w<EFBFBD>"<22><03>)<29>3<>4<>r<EFBFBD>S<EFBFBD>y<EFBFBD>@<40><04> <0B><1D> <0A> r/c<00><00>|jsd|_y|jd|jdcxk(rdk7rnn|jd|_yt|jj <00><00>\}}t j|j<00>}|||k||kz}t j|<03>}t|<03>sd|_y|jr,tjtj||z
<00><00>}n@|j<00>}|dk(rd}n(tjtj|<05><00>}||jdkr||_y||jdk\r||_yd|_y<00>Nrr')r<>r<>r<>r'rMr4r<>r(ror<>r<>r<>rrrr)r+r8r9ror"r<>s r-rz'ScalarFormatter._set_order_of_magnitudesA<00><00><14><1F><1F>$%<25>D<EFBFBD> !<21> <12> <0F> <1C> <1C>Q<EFBFBD> <1F>4<EFBFBD>#4<>#4<>Q<EFBFBD>#7<> <<3C>1<EFBFBD> <<3C>$(<28>$5<>$5<>a<EFBFBD>$8<>D<EFBFBD> !<21> <12><1B>D<EFBFBD>I<EFBFBD>I<EFBFBD>7<>7<>9<>:<3A>
<EFBFBD><04>d<EFBFBD><11>z<EFBFBD>z<EFBFBD>$<24>)<29>)<29>$<24><04><13>T<EFBFBD>T<EFBFBD>\<5C>d<EFBFBD>d<EFBFBD>l<EFBFBD>3<>4<><04><11>v<EFBFBD>v<EFBFBD>d<EFBFBD>|<7C><04><12>4<EFBFBD>y<EFBFBD>$%<25>D<EFBFBD> !<21> <12> <0F>;<3B>;<3B><16>*<2A>*<2A>T<EFBFBD>Z<EFBFBD>Z<EFBFBD><04>t<EFBFBD> <0B>4<>5<>C<EFBFBD><16>(<28>(<28>*<2A>C<EFBFBD><12>a<EFBFBD>x<EFBFBD><17><03><1A>j<EFBFBD>j<EFBFBD><14><1A><1A>C<EFBFBD><1F>1<><03> <0E>$<24>#<23>#<23>A<EFBFBD>&<26> &<26>$'<27>D<EFBFBD> !<21> <10>D<EFBFBD>%<25>%<25>a<EFBFBD>(<28> (<28>$'<27>D<EFBFBD> !<21>$%<25>D<EFBFBD> !r/c<00>x<00>t|j<00>dkr)g|j<00>|jj<00><00>}n |j}t j
|<01>|j z
d|jzz }t j|<02>}|dk(r(t jt j|<02><00>}|dk(rd}t|j<00>dkr|dd}ttjtj|<03><00><00>}tdd|z
<00>}dd|zz}|dk\rKt j|t j||<05> <09>z
<00>j<00>|kr|dz}nn|dk\r<01>K|dz }d
|<05>d <0B>|_|j"s |j$rd |j z|_yy) Nr<4E>r<>rr'<00><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><00><><EFBFBD><EFBFBD><EFBFBD>MbP?r )<01>decimalsz%1.<2E>f<>$\mathdefault{%s}$)r<>rorMr4r<>r(r<>r<><00>ptprr<><00>intrrrrr<>r<>r<>)r+<00>_locsro<00> loc_range<67> loc_range_oom<6F>sigfigs<67>threshs r-rzScalarFormatter._set_format3st<00><00> <0E>t<EFBFBD>y<EFBFBD>y<EFBFBD>><3E>A<EFBFBD> <1D>@<40>d<EFBFBD>i<EFBFBD>i<EFBFBD>@<40>$<24>)<29>)<29>"=<3D>"=<3D>"?<3F>@<40>E<EFBFBD><18>I<EFBFBD>I<EFBFBD>E<EFBFBD><12>
<EFBFBD>
<EFBFBD>5<EFBFBD>!<21>D<EFBFBD>K<EFBFBD>K<EFBFBD>/<2F>3<EFBFBD>$<24>:O<>:O<>3O<33>O<><04><16>F<EFBFBD>F<EFBFBD>4<EFBFBD>L<EFBFBD> <09> <14><01>><3E><1A><06><06>r<EFBFBD>v<EFBFBD>v<EFBFBD>d<EFBFBD>|<7C>,<2C>I<EFBFBD> <14><01>><3E><19>I<EFBFBD> <0E>t<EFBFBD>y<EFBFBD>y<EFBFBD>><3E>A<EFBFBD> <1D><17><03><12>9<EFBFBD>D<EFBFBD><1B>D<EFBFBD>J<EFBFBD>J<EFBFBD>t<EFBFBD>z<EFBFBD>z<EFBFBD>)<29>'<<3C>=<3D>><3E> <0A><15>a<EFBFBD><11>]<5D>*<2A>+<2B><07><15><02>m<EFBFBD>+<2B>+<2B><06><15><11>l<EFBFBD><11>v<EFBFBD>v<EFBFBD>d<EFBFBD>R<EFBFBD>X<EFBFBD>X<EFBFBD>d<EFBFBD>W<EFBFBD>=<3D>=<3D>><3E>B<>B<>D<>v<EFBFBD>M<><17>1<EFBFBD> <0C><07><15> <16><11>l<EFBFBD>
<10>1<EFBFBD> <0C><07><1B>G<EFBFBD>9<EFBFBD>A<EFBFBD>&<26><04> <0B> <0F><<3C><<3C>4<EFBFBD>,<2C>,<2C>/<2F>$<24>+<2B>+<2B>=<3D>D<EFBFBD>K<EFBFBD>-r/)NNNr1)rHrIrJr{r.r<>r<><00>propertyr<79>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r[r<>r<>rhrerlr]rrrrEr/r-rr<00>s<><00><00>4<08>l &<26><1C> &<26><1C>:<3A><16>:<3A>J<EFBFBD> 7<>F<EFBFBD> <1F> <1E>D<19>m<EFBFBD>-<2D>@<40>I<EFBFBD><1F> "<22><19>m<EFBFBD>-<2D>@<40>I<EFBFBD>  <20>!<21>$<24>B<1B><0F>o<EFBFBD>F<>K<EFBFBD>
H<01>#<23> !<21>D?<3F>8/<2F> <12>6<1F>%<1F>N &<26>D>r/rc<00>R<00>eZdZdZ d d<03>Zd<04>Zd<05>Zd d<06>Zd<07>Zd d<08>Z d <09>Z
d
<EFBFBD>Z d <0B>Z y)ra<>
Base class for formatting ticks on a log or symlog scale.
It may be instantiated directly, or subclassed.
Parameters
----------
base : float, default: 10.
Base of the logarithm used in all calculations.
labelOnlyBase : bool, default: False
If True, label ticks only at integer powers of base.
This is normally True for major ticks and False for
minor ticks.
minor_thresholds : (subset, all), default: (1, 0.4)
If labelOnlyBase is False, these two numbers control
the labeling of ticks that are not at integer powers of
base; normally these are the minor ticks. The controlling
parameter is the log of the axis data range. In the typical
case where base is 10 it is the number of decades spanned
by the axis, so we can call it 'numdec'. If ``numdec <= all``,
all minor ticks will be labeled. If ``all < numdec <= subset``,
then only a subset of minor ticks will be labeled, so as to
avoid crowding. If ``numdec > subset`` then no minor ticks will
be labeled.
linthresh : None or float, default: None
If a symmetric log scale is in use, its ``linthresh``
parameter must be supplied here.
Notes
-----
The `set_locs` method must be called to enable the subsetting
logic controlled by the ``minor_thresholds`` parameter.
In some cases such as the colorbar, there is no distinction between
major and minor ticks; the tick locations might be set manually,
or by a locator that puts ticks at integer powers of base and
at intermediate locations. For this situation, disable the
minor_thresholds logic by using ``minor_thresholds=(np.inf, np.inf)``,
so that all ticks will be labeled.
To disable labeling of minor ticks when 'labelOnlyBase' is False,
use ``minor_thresholds=(0, 0)``. This is the default for the
"classic" style.
Examples
--------
To label a subset of minor ticks when the view limits span up
to 2 decades, and all of the ticks when zoomed in to 0.5 decades
or less, use ``minor_thresholds=(2, 0.5)``.
To label all minor ticks when the view limits span up to 1.5
decades, use ``minor_thresholds=(1.5, 1.5)``.
Nc<00><><00>|j|<01>|j|<02>|<03>tjdrd}nd}||_d|_||_y)N<>_internal.classic_mode<64>rr)r'g<><67><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>?)<07>set_base<73>set_label_minorrsrt<00>minor_thresholds<64>
_sublabels<EFBFBD>
_linthresh)r+<00>base<73> labelOnlyBaserL<00> linthreshs r-r.zLogFormatter.__init__<5F>sS<00><00> <0A> <0A> <0A>d<EFBFBD><1B> <0C><1C><1C>]<5D>+<2B> <1B> #<23><12>|<7C>|<7C>4<>5<>#)<29> <20>#+<2B> <20> 0<><04><1D><1E><04><0F>#<23><04>r/c<00>$<00>t|<01>|_y)z<>
Change the *base* for labeling.
.. warning::
Should always match the base used for :class:`LogLocator`
N)r*<00>_base)r+rOs r-rJzLogFormatter.set_base<73>s<00><00><1B>4<EFBFBD>[<5B><04>
r/c<00><00>||_y)z<>
Switch minor tick labeling on or off.
Parameters
----------
labelOnlyBase : bool
If True, label ticks only at integer powers of base.
N<>rP)r+rPs r-rKzLogFormatter.set_label_minor<6F>s <00><00>+<2B><04>r/c<00>|<00>tj|jd<00>rd|_y|j}|<02>% |j
j <00>j}|j
j<00>\}}||kDr||}}|<02>|dkr dh|_y|j}|<02><>d}|| kr>t|| <00>}|tj||z <00>tj|<05>z z }||kDr<>t||<02>}|tj||z <00>tj|<05>z z }ndtj|<03>tj|<05>z }tj|<04>tj|<05>z }t||z
<00>}||jdkDr dh|_y||jdkDrJtj d|t#|<05>dzdz<00>} t%tj&| <09><00>|_yt%tj(d|dz<00><00>|_y#t$rY<00><01><>wxYw)z<>
Use axis view limits to control which ticks are labeled.
The *locs* parameter is ignored in the present algorithm.
rNr'r<>)r<><00>isinfrLrMrNrM<00> get_transformrQ<00>AttributeErrorr4rSr)r<00>logrr<><00> geomspacer?<00>setr<00>arange)
r+rorQr8r9r<><00>numdec<65>rhs<68>lhs<68>cs
r-r]zLogFormatter.set_locs<63>s<><00><00> <0E>8<EFBFBD>8<EFBFBD>D<EFBFBD>)<29>)<29>!<21>,<2C> -<2D>"<22>D<EFBFBD>O<EFBFBD> <12><19>O<EFBFBD>O<EFBFBD> <09> <14> <1C> <15> <20>I<EFBFBD>I<EFBFBD>3<>3<>5<>?<3F>?<3F> <09><1A>Y<EFBFBD>Y<EFBFBD>0<>0<>2<>
<EFBFBD><04>d<EFBFBD> <0F>$<24>;<3B><1D>t<EFBFBD>$<24>D<EFBFBD> <14> <1C><14><11><19> !<21>c<EFBFBD>D<EFBFBD>O<EFBFBD> <12> <10>J<EFBFBD>J<EFBFBD><01> <14> <20><17>F<EFBFBD><13>y<EFBFBD>j<EFBFBD> <20><19>$<24><19>
<EFBFBD>+<2B><03><16>$<24>(<28>(<28>4<EFBFBD>#<23>:<3A>.<2E><14><18><18>!<21><1B><<3C><<3C><06><13>i<EFBFBD><1F><19>$<24> <09>*<2A><03><16>$<24>(<28>(<28>4<EFBFBD>#<23>:<3A>.<2E><14><18><18>!<21><1B><<3C><<3C><06><17>8<EFBFBD>8<EFBFBD>D<EFBFBD>><3E>D<EFBFBD>H<EFBFBD>H<EFBFBD>Q<EFBFBD>K<EFBFBD>/<2F>D<EFBFBD><17>8<EFBFBD>8<EFBFBD>D<EFBFBD>><3E>D<EFBFBD>H<EFBFBD>H<EFBFBD>Q<EFBFBD>K<EFBFBD>/<2F>D<EFBFBD><18><14><04><1B>%<25>F<EFBFBD> <11>D<EFBFBD>)<29>)<29>!<21>,<2C> ,<2C> <20>c<EFBFBD>D<EFBFBD>O<EFBFBD> <13>d<EFBFBD>+<2B>+<2B>A<EFBFBD>.<2E> .<2E><13> <0C> <0C>Q<EFBFBD><01>3<EFBFBD>q<EFBFBD>6<EFBFBD>1<EFBFBD>9<EFBFBD>q<EFBFBD>=<3D>1<>A<EFBFBD>!<21>"<22>(<28>(<28>1<EFBFBD>+<2B>.<2E>D<EFBFBD>O<EFBFBD>"<22>"<22>)<29>)<29>A<EFBFBD>q<EFBFBD>1<EFBFBD>u<EFBFBD>"5<>6<>D<EFBFBD>O<EFBFBD><4F>U"<22> <15><14> <15>s<00>$H.<00>. H;<03>:H;c<00>P<00>d|cxkrdkrnn|j|||z
<00>S|d<03>S)Nr'<00>'z1.0e)<01> _pprint_val)r+rYr8r9s r-<00>_num_to_stringzLogFormatter._num_to_string<6E>s,<00><00>34<33><01>?<3F>U<EFBFBD>?<3F>t<EFBFBD><1F><1F><01>4<EFBFBD>$<24>;<3B>/<2F>S<>1<EFBFBD>T<EFBFBD>(<28>Sr/c<00><00>|dk(ryt|<01>}|j}tj|<01>tj|<03>z }t |<04>}|r t |<04>nt j|<04>}t |||z
z<00>}|jr|sy|j<00>||jvry|jj<00>\}} tj|| d<04><05>\}} |j||| <09>}
|j|
<EFBFBD>S)N<><00>0rk皙<><E79A99><EFBFBD><EFBFBD><EFBFBD>?<3F><01>expander)r<>rSrrZ<00>_is_close_to_intrr<>rrPrMrMr4<00> mtransforms<6D> nonsingularrerw) r+rYrZr<><00>fx<66> is_x_decader<00>coeffr8r9rvs r-r[zLogFormatter.__call__<5F>s<><00><00> <0C><03>8<EFBFBD><16> <0F><01>F<EFBFBD><01> <10>J<EFBFBD>J<EFBFBD><01> <11>X<EFBFBD>X<EFBFBD>a<EFBFBD>[<5B>4<EFBFBD>8<EFBFBD>8<EFBFBD>A<EFBFBD>;<3B> &<26><02>&<26>r<EFBFBD>*<2A> <0B> +<2B>5<EFBFBD><12>9<EFBFBD><12><18><18>"<22><1C><08><15>a<EFBFBD>B<EFBFBD><18>M<EFBFBD>*<2A>+<2B><05> <0F> <1D> <1D>k<EFBFBD><15> <0F>?<3F>?<3F> &<26>5<EFBFBD><04><0F><0F>+G<><15><19>Y<EFBFBD>Y<EFBFBD>0<>0<>2<>
<EFBFBD><04>d<EFBFBD> <20>,<2C>,<2C>T<EFBFBD>4<EFBFBD>$<24>G<>
<EFBFBD><04>d<EFBFBD> <10> <1F> <1F><01>4<EFBFBD><14> .<2E><01><13>~<7E>~<7E>a<EFBFBD> <20> r/c<00><><00>tj|d<01><02>5tj|j|<01><00>cddd<00>S#1swYyxYw)NFrU)r<00> _setattr_cm<63>
strip_mathr[rds r-rezLogFormatter.format_datas><00><00> <12> <1E> <1E>t<EFBFBD>5<EFBFBD> 9<> :<3A><18>#<23>#<23>D<EFBFBD>M<EFBFBD>M<EFBFBD>%<25>$8<>9<> :<3A> :<3A> :<3A>s <00>$A<03>Ac<00>(<00>d|zj<00>S)Nz%-12g)<01>rstriprds r-rhzLogFormatter.format_data_short s<00><00><17>%<25><0F>'<27>'<27>)<29>)r/c<00><><00>t|<01>dkr|t|<01>k(rd|zS|dkrdn|dkrdn|dkrdn|d krd
nd }||z}|jd <0C>}t|<05>d k(r@|dj d<0F>j d<10>}t|d<00>}|r d||fz}|S|}|S|j d<0F>j d<10>}|S)Nr<4E>r<>r%z%1.3er'z%1.3fr z%1.2fgj<>@z%1.1fz%1.1err<>rrh<00>.z%se%d)r<>r?r<>r<>rv)r+rY<00>dr<64>rv<00>tup<75>mantissars r-rdzLogFormatter._pprint_vals<><00><00> <0E>q<EFBFBD>6<EFBFBD>C<EFBFBD><<3C>A<EFBFBD><13>Q<EFBFBD><16>K<EFBFBD><17>!<21>8<EFBFBD>O<EFBFBD><1B>d<EFBFBD>(<28>w<EFBFBD><1B>q<EFBFBD>&<26>w<EFBFBD><1B>r<EFBFBD>'<27>w<EFBFBD><1B>s<EFBFBD>(<28>w<EFBFBD><16> <0C>
<10>!<21>G<EFBFBD><01><0F>g<EFBFBD>g<EFBFBD>c<EFBFBD>l<EFBFBD><03> <0E>s<EFBFBD>8<EFBFBD>q<EFBFBD>=<3D><1A>1<EFBFBD>v<EFBFBD>}<7D>}<7D>S<EFBFBD>)<29>0<>0<><13>5<>H<EFBFBD><1A>3<EFBFBD>q<EFBFBD>6<EFBFBD>{<7B>H<EFBFBD><17><1B>x<EFBFBD><18>2<>2<><01>
<11><08><1D><01><11><08><12><08><08><13> <0A>$<24>$<24>S<EFBFBD>)<29>A<EFBFBD><10>r/)r<>FNNr1) rHrIrJr{r.rJrKr]rer[rerhrdrEr/r-rrUsB<00><00>7<08>r16<31>"&<26><1F> $<24>!<21> +<2B>97<>vT<01>!<21>.:<3A>*<2A>r/rc<00><00>eZdZdZd<02>Zy)r<00>J
Format values for log axis using ``exponent = log_base(value)``.
c<00>><00>tj|<01>tj|j<00>z }dt|<04>cxkrdkrOnnLtj||z
<00>tj|j<00>z }|j ||<05>}|S|d<03>}|S)Nr'rcz1.0g)rrZrSr<>rd)r+rYr8r9ro<00>fdrvs r-rez#LogFormatterExponent._num_to_string+s<00><00> <11>X<EFBFBD>X<EFBFBD>a<EFBFBD>[<5B>4<EFBFBD>8<EFBFBD>8<EFBFBD>D<EFBFBD>J<EFBFBD>J<EFBFBD>/<2F> /<2F><02> <0C><03>B<EFBFBD><07> <20>5<EFBFBD> <20><15><18><18>$<24><14>+<2B>&<26><14><18><18>$<24>*<2A>*<2A>)=<3D>=<3D>B<EFBFBD><14> <20> <20><12>R<EFBFBD>(<28>A<EFBFBD><11><08><16>d<EFBFBD>)<29>A<EFBFBD><10>r/N)rHrIrJr{rerEr/r-rr&s <00><00><08>r/rc<00><00>eZdZdZd<02>Zdd<04>Zy)rr}c<00><00>d|||fzS)<02>'Return string for non-decade locations.z$\mathdefault{%s%s^{%.2f}}$rE)r+<00> sign_stringrOror<>s r-<00>_non_decade_formatz'LogFormatterMathtext._non_decade_format:s<00><00>-<2D><1B>d<EFBFBD>B<EFBFBD>0G<30>G<>Gr/Nc<00>b<00>|dk(ry|dkrdnd}t|<01>}|j}tj|<01>tj|<04>z }t |<05>}|r t |<05>nt j|<05>}t |||z
z<00>}|jr|sy|j<00>||jvry|r t |<05>}|dzdk(rd|z} nd|z} t|<05>tjd krd
||fzS|s'tjd }
|j|| ||
<EFBFBD>Sd || |fzS) Nrz$\mathdefault{0}$rrrkr'rgr<>z%szaxes.formatter.min_exponentz$\mathdefault{%s%g}$r<>z$\mathdefault{%s%s^{%d}}$) r<>rSrrZrlrr<>rrPrMrsrtr<>) r+rYrZr<>r<>rorprrqrOr<>s r-r[zLogFormatterMathtext.__call__>s*<00><00> <0C><01>6<EFBFBD>'<27><1E><11>U<EFBFBD>c<EFBFBD><02> <0B> <0F><01>F<EFBFBD><01> <10>J<EFBFBD>J<EFBFBD><01><12>X<EFBFBD>X<EFBFBD>a<EFBFBD>[<5B>4<EFBFBD>8<EFBFBD>8<EFBFBD>A<EFBFBD>;<3B> &<26><02>&<26>r<EFBFBD>*<2A> <0B> +<2B>5<EFBFBD><12>9<EFBFBD><12><18><18>"<22><1C><08><15>a<EFBFBD>B<EFBFBD><18>M<EFBFBD>*<2A>+<2B><05> <0F> <1D> <1D>k<EFBFBD><15> <0F>?<3F>?<3F> &<26>5<EFBFBD><04><0F><0F>+G<><15> <16><16>r<EFBFBD><19>B<EFBFBD> <0A>q<EFBFBD>5<EFBFBD>C<EFBFBD><<3C><17>!<21>8<EFBFBD>D<EFBFBD><17>!<21>8<EFBFBD>D<EFBFBD> <0E>r<EFBFBD>7<EFBFBD>S<EFBFBD>\<5C>\<5C>"?<3F>@<40> @<40>*<2A>k<EFBFBD>1<EFBFBD>-=<3D>=<3D> =<3D><1C><18>\<5C>\<5C>-<2D>0<>F<EFBFBD><17>*<2A>*<2A>;<3B><04>b<EFBFBD>&<26>I<> I<>/<2F>;<3B><04>b<EFBFBD>2I<32>I<> Ir/r1)rHrIrJr{r<>r[rEr/r-rr5s<00><00><08>H<01>#Jr/rc<00><00>eZdZdZd<02>Zy)rzL
Format values following scientific notation in a logarithmic axis.
c<00><><00>t|<02>}tj|<03>}|||z
z}t|<07>r t |<07>}d||||fzS)r<>z!$\mathdefault{%s%g\times%s^{%d}}$)r*rrrlr)r+r<>rOror<>r<>rrqs r-r<>z*LogFormatterSciNotation._non_decade_formatisP<00><00> <11>$<24>K<EFBFBD><01><17>:<3A>:<3A>b<EFBFBD>><3E><08><11>b<EFBFBD>8<EFBFBD>m<EFBFBD>$<24><05> <1B>E<EFBFBD> "<22><19>%<25>L<EFBFBD>E<EFBFBD>3<><1A>E<EFBFBD>4<EFBFBD><18>2<>3<> 3r/N)rHrIrJr{r<>rEr/r-rrds <00><00><08>3r/rc<00>^<00>eZdZdZdddddd<06>d<07>Zd<08>Zd <09>Zd
<EFBFBD>Zd <0B>Zd <0C>Z dd <0A>Z
d<0E>Z dd<10>Z d<11>Z y)rz2
Probability formatter (using Math text).
Fz \frac{1}{2}<7D><00>)<05> use_overline<6E>one_half<6C>minor<6F>minor_threshold<6C> minor_numberc<00>h<00>||_||_||_t<00>|_||_||_y)a<>
Parameters
----------
use_overline : bool, default: False
If x > 1/2, with x = 1 - v, indicate if x should be displayed as
$\overline{v}$. The default is to display $1 - v$.
one_half : str, default: r"\\frac{1}{2}"
The string used to represent 1/2.
minor : bool, default: False
Indicate if the formatter is formatting minor ticks or not.
Basically minor ticks are not labelled, except when only few ticks
are provided, ticks with most space with neighbor ticks are
labelled. See other parameters to change the default behavior.
minor_threshold : int, default: 25
Maximum number of locs for labelling some minor ticks. This
parameter have no effect if minor is False.
minor_number : int, default: 6
Number of ticks which are labelled when the number of ticks is
below the threshold.
N)<07> _use_overline<6E> _one_half<6C>_minorr\<00> _labelled<65>_minor_threshold<6C> _minor_number)r+r<>r<>r<>r<>r<>s r-r.zLogitFormatter.__init__ys4<00><00>B*<2A><04><1A>!<21><04><0E><1B><04> <0B><1C><15><04><0E> /<2F><04><1D>)<29><04>r/c<00><00>||_y)a
Switch display mode with overline for labelling p>1/2.
Parameters
----------
use_overline : bool
If x > 1/2, with x = 1 - v, indicate if x should be displayed as
$\overline{v}$. The default is to display $1 - v$.
N<>r<>)r+r<>s r-r<>zLogitFormatter.use_overline<6E>s <00><00>*<2A><04>r/c<00><00>||_y)zz
Set the way one half is displayed.
one_half : str
The string used to represent 1/2.
N)r<>)r+r<>s r-<00> set_one_halfzLogitFormatter.set_one_half<6C>s <00><00>"<22><04>r/c<00><00>||_y)a 
Set the threshold for labelling minors ticks.
Parameters
----------
minor_threshold : int
Maximum number of locations for labelling some minor ticks. This
parameter have no effect if minor is False.
N)r<>)r+r<>s r-<00>set_minor_thresholdz"LogitFormatter.set_minor_threshold<6C>s <00><00>!0<><04>r/c<00><00>||_y)a
Set the number of minor ticks to label when some minor ticks are
labelled.
Parameters
----------
minor_number : int
Number of ticks which are labelled when the number of ticks is
below the threshold.
N)r<>)r+r<>s r-<00>set_minor_numberzLogitFormatter.set_minor_number<65>s <00><00>*<2A><04>r/c<00><><00><01><04><05>tj<00><01>|_|jj <00>|j
syt d<01><00>D<00><00>ryt<00><01>|jk<00>rZt<00><01>|jkr|jj<00><01>ytjtjd|jz dz
<00> <00>}tjtjtjf|f<02>tj|tjff<02><00><00>tjd|f<02>tj|df<02>z<00>t!t#t|j<00><00><00><04>fd<04><08><05>|j d}|jj<00>fd<06>|D<00><00>yy)Nc3<00><>K<00>|]Y}t|d<00><01>xsFtd|z
d<00><01>xs4td|z<00>xr$ttjd|z<00><00>dk(<00><01><00>[y<04>w)<05>H<EFBFBD><48><EFBFBD><EFBFBD><EFBFBD>z><3E><01>rtolr'r<>N)<05>
_is_decaderlr?r<>r)r<>rYs r-r<>z*LogitFormatter.set_locs.<locals>.<genexpr><3E>sh<00><00><><00>
<EFBFBD>
<12> <17>q<EFBFBD>t<EFBFBD> $<24> +<2B><19>!<21>a<EFBFBD>%<25>d<EFBFBD>+<2B> +<2B> <20><11>Q<EFBFBD><15>'<27>*<2A><13>B<EFBFBD>H<EFBFBD>H<EFBFBD>Q<EFBFBD><11>U<EFBFBD>O<EFBFBD>$<24><01>)<29> +<2B>
<EFBFBD>s<00>AA!r'rGc<00><00><02><00>|<00>|fSr1rE)r`<00>space_pessimistic<69> space_sums <20><>r-<00><lambda>z)LogitFormatter.set_locs.<locals>.<lambda><3E>s<00><><00>#4<>Q<EFBFBD>#7<><19>1<EFBFBD><1C>"F<>r/)<01>keyc3<00>(<00>K<00>|] }<01>|<00><01><00> y<00>wr1rE)r<>r`ros <20>r-r<>z*LogitFormatter.set_locs.<locals>.<genexpr><3E>s<00><><00><><00>%B<>!<21>d<EFBFBD>1<EFBFBD>g<EFBFBD>%B<>s<00>)r<><00>arrayror<><00>clearr<72><00>allr<6C>r<>r<><00>update<74>diffrZ<00>minimum<75> concatenate<74>infr'<00>range)r+ror<><00>
good_minorr<EFBFBD>r<>s ` @@r-r]zLogitFormatter.set_locs<63>sd<00><><00><16>H<EFBFBD>H<EFBFBD>T<EFBFBD>N<EFBFBD><04> <09> <0C><0E><0E><1C><1C><1E><13>{<7B>{<7B><17> <0E>
<EFBFBD>
<1A> 
<EFBFBD>
<EFBFBD><18> <0E>t<EFBFBD>9<EFBFBD>t<EFBFBD>,<2C>,<2C> ,<2C><12>4<EFBFBD>y<EFBFBD>4<EFBFBD>-<2D>-<2D>-<2D><14><0E><0E>%<25>%<25>d<EFBFBD>+<2B><1A>w<EFBFBD>w<EFBFBD><02><06><06>q<EFBFBD>4<EFBFBD>9<EFBFBD>9<EFBFBD>}<7D>q<EFBFBD>'8<> 9<>9<>:<3A><04>$&<26>J<EFBFBD>J<EFBFBD><16>N<EFBFBD>N<EFBFBD>R<EFBFBD>V<EFBFBD>V<EFBFBD>I<EFBFBD>t<EFBFBD>#4<>5<><16>N<EFBFBD>N<EFBFBD>D<EFBFBD>2<EFBFBD>6<EFBFBD>6<EFBFBD>)<29>#4<>5<>%<12>!<21>
<17>N<EFBFBD>N<EFBFBD>D<EFBFBD>$<24><<3C>0<><18>n<EFBFBD>n<EFBFBD>d<EFBFBD>D<EFBFBD>\<5C>2<>3<><1A>$<24><19>#<23>d<EFBFBD>i<EFBFBD>i<EFBFBD>.<2E>)<29>F<><12><18>%<25>%<25>%<25>&<26>(<28>
<EFBFBD><15><0E><0E>%<25>%<25>%B<>z<EFBFBD>%B<>B<>3 -r/c<00><><00>|r+tjtj|<01><00>}d}nd}d}|d| zz}t |<02>dkr|}n<>tj
tj ||z
<00><00>d}tj|<08> |z}t|<07>rttj|<07><00>ntj|<07>}||kr|}d||fz} |s| Sd| |fz}
|
S)Nrr'r r<>z%.*fz%s\cdot10^{%d}) rrr<>rr<><00>sortr<74>rlr?rr,) r+rYro<00> sci_notationr<00> min_precisionra<00> precisionr<6E>r{rvs r-<00> _format_valuezLogitFormatter._format_value<75>s<><00><00> <17><1B>z<EFBFBD>z<EFBFBD>"<22>(<28>(<28>1<EFBFBD>+<2B>.<2E>H<EFBFBD><1D>M<EFBFBD><18>H<EFBFBD><1D>M<EFBFBD><11>B<EFBFBD>H<EFBFBD>9<EFBFBD>%<25>%<25><05> <0E>t<EFBFBD>9<EFBFBD>q<EFBFBD>=<3D>%<25>I<EFBFBD><15>7<EFBFBD>7<EFBFBD>2<EFBFBD>6<EFBFBD>6<EFBFBD>$<24><11>(<28>+<2B>,<2C>Q<EFBFBD>/<2F>D<EFBFBD><1B><18><18>$<24><1E><0F>(<28>2<>I<EFBFBD>$<24>I<EFBFBD>.<2E><14>B<EFBFBD>H<EFBFBD>H<EFBFBD>Y<EFBFBD>'<27>(<28><19>Y<EFBFBD>Y<EFBFBD>y<EFBFBD>)<29> <16>
<19>=<3D>(<28>)<29> <09><1A>i<EFBFBD><15>/<2F>/<2F><08><1B><1B>O<EFBFBD> <1D><18>8<EFBFBD> 4<> 4<><01><10>r/c<00>.<00>|jrd|zSd|<01><00>S)Nz \overline{%s}<7D>1-r<>)r+rvs r-<00>
_one_minuszLogitFormatter._one_minuss!<00><00> <0F> <1D> <1D>#<23>a<EFBFBD>'<27> '<27><17><01>s<EFBFBD>8<EFBFBD>Or/Nc<00><><00>|jr||jvry|dks|dk\rytd|z<00>r"td|z<00>dk(r|j}d |zS|dkr5t |d<06><07>r(tt j|<01><00>}d|z}d |zS|dkDrJt d|z
d<06><07>r:tt jd|z
<00><00>}|jd|z<00>}d |zS|d kr!|j||j<00>}d |zS|d
kDr6|j|jd|z
d|jz
<00><00>}d |zS|j||jd <0B> <0C>}d |zS)Nrkrr'r<><00><00>?r<>r<>z10^{%d}皙<><E79A99><EFBFBD><EFBFBD><EFBFBD>?<3F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>?F)r<>r=) r<>r<>rlrr<>r<>rrr<>r<>ro)r+rYrZrvrs r-r[zLogitFormatter.__call__sq<00><00> <0F>;<3B>;<3B>1<EFBFBD>D<EFBFBD>N<EFBFBD>N<EFBFBD>2<><15> <0C><01>6<EFBFBD>Q<EFBFBD>!<21>V<EFBFBD><15> <1B>A<EFBFBD><01>E<EFBFBD> "<22>u<EFBFBD>Q<EFBFBD><11>U<EFBFBD>|<7C>q<EFBFBD>'8<><14><0E><0E>A<EFBFBD>%<25>q<EFBFBD>(<28>(<28><0F><13>W<EFBFBD><1A>A<EFBFBD>D<EFBFBD>1<><1C>T<EFBFBD>Z<EFBFBD>Z<EFBFBD><01>]<5D>+<2B>H<EFBFBD><19>H<EFBFBD>$<24>A<EFBFBD>%<25>q<EFBFBD>(<28>(<28><0F><13>W<EFBFBD><1A>A<EFBFBD><01>E<EFBFBD><04>5<><1C>T<EFBFBD>Z<EFBFBD>Z<EFBFBD><01>A<EFBFBD><05>.<2E>/<2F>H<EFBFBD><14><0F><0F> <09>H<EFBFBD> 4<>5<>A<EFBFBD>%<25>q<EFBFBD>(<28>(<28> <0F><13>W<EFBFBD><14>"<22>"<22>1<EFBFBD>d<EFBFBD>i<EFBFBD>i<EFBFBD>0<>A<EFBFBD>
%<25>q<EFBFBD>(<28>(<28> <0F><13>W<EFBFBD><14><0F><0F><04> 2<> 2<>1<EFBFBD>Q<EFBFBD>3<EFBFBD><01>$<24>)<29>)<29> <0B> D<>E<>A<EFBFBD>%<25>q<EFBFBD>(<28>(<28><15>"<22>"<22>1<EFBFBD>d<EFBFBD>i<EFBFBD>i<EFBFBD>e<EFBFBD>"<22>D<>A<EFBFBD>$<24>q<EFBFBD>(<28>(r/c<00>8<00>|dkr|d<02>S|dkr|d<04>Sdd|z
d<02><04>S)Nr<4E>rr<>r<r<>r'rErds r-rhz LogitFormatter.format_data_short.s9<00><00> <11>3<EFBFBD>;<3B><1B>A<EFBFBD>Y<EFBFBD> <1F> <10>3<EFBFBD>;<3B><1B>A<EFBFBD>Y<EFBFBD> <1F><13>A<EFBFBD><05>I<EFBFBD>a<EFBFBD>=<3D>!<21>!r/)Tr1)rHrIrJr{r.r<>r<>r<>r<>r]r<>r<>r[rhrEr/r-rrtsM<00><00><08><1B><1F><13><1A><16>&*<2A>P
*<2A>"<22>
0<> *<2A>(C<01>T<11>4<1C> )<29>*"r/rc<00><><00><00>eZdZdZidd<03>dd<05>dd<07>dd <09>d
d <0B>d d <0A>dd<0F>dd<11>dd<13>dd<15>dd<17>dd<19>dd<1B>dd<1D>dd<1F>d d!<21>d"d#<23>d$d%d&d'd(<28><04>Zd2d)d)d*d+<2B><03>fd,<2C> Zd3d-<2D>Zd.<2E>Zd/<2F>Zd0<64>Z d1<64>Z
<EFBFBD>xZ S)4rz<>
Format axis values using engineering prefixes to represent powers
of 1000, plus a specified unit, e.g., 10 MHz instead of 1e7.
i<><69><EFBFBD><EFBFBD><EFBFBD>qi<71><69><EFBFBD><EFBFBD><EFBFBD>ri<72><69><EFBFBD><EFBFBD><EFBFBD>yi<79><69><EFBFBD><EFBFBD><EFBFBD>zi<7A><69><EFBFBD><EFBFBD>r i<><69><EFBFBD><EFBFBD>r<i<><69><EFBFBD><EFBFBD><EFBFBD>pi<70><69><EFBFBD><EFBFBD>r4i<><69><EFBFBD><EFBFBD><EFBFBD>µ<><C2B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>mrrkr9<00>kr<6B><00>MrD<00>G<> <00>T<><00>P<><00>E<>Z<>Y<>R<>Q)<04><00><00><00>NF)r<>r<>r<>c<00>V<00><01>||_||_||_t<00>|<00>||d|<04><02>y)a$
Parameters
----------
unit : str, default: ""
Unit symbol to use, suitable for use with single-letter
representations of powers of 1000. For example, 'Hz' or 'm'.
places : int, default: None
Precision with which to display the number, specified in
digits after the decimal point (there will be between one
and three digits before the decimal point). If it is None,
the formatting falls back to the floating point format '%g',
which displays up to 6 *significant* digits, i.e. the equivalent
value for *places* varies between 0 and 5 (inclusive).
sep : str, default: " "
Separator used between the value and the prefix/unit. For
example, one get '3.14 mV' if ``sep`` is " " (default) and
'3.14mV' if ``sep`` is "". Besides the default behavior, some
other useful options may be:
* ``sep=""`` to append directly the prefix/unit to the value;
* ``sep="\N{THIN SPACE}"`` (``U+2009``);
* ``sep="\N{NARROW NO-BREAK SPACE}"`` (``U+202F``);
* ``sep="\N{NO-BREAK SPACE}"`` (``U+00A0``).
usetex : bool, default: :rc:`text.usetex`
To enable/disable the use of TeX's math mode for rendering the
numbers in the formatter.
useMathText : bool, default: :rc:`axes.formatter.use_mathtext`
To enable/disable the use mathtext for rendering the numbers in
the formatter.
useOffset : bool or float, default: False
Whether to use offset notation with :math:`10^{3*N}` based prefixes.
This features allows showing an offset with standard SI order of
magnitude prefix near the axis. Offset is computed similarly to
how `ScalarFormatter` computes it internally, but here you are
guaranteed to get an offset which will make the tick labels exceed
3 digits. See also `.set_useOffset`.
.. versionadded:: 3.10
F)r<>r<>r<>r<>N)<05>unit<69>places<65>sepr<70>r.)r+r<>r<>r<>r<>r<>r<>r<>s <20>r-r.zEngFormatter.__init__Ws9<00><><00>Z<19><04> <09><1C><04> <0B><16><04><08> <0A><07><18><1F>#<23><1B><19> <19>
r/c<00>&<00>t|j<00>dk(s|jdk(r |j|j |<01><00>S||jz
d|j
zz }t |<03>dkrd}|j|j|<03>S)z<>
Return the format for tick value *x* at position *pos*.
If there is no currently offset in the data, it returns the best
engineering formatting that fits the given argument, independently.
rr<>r<>) r<>ror<>rwrer<>r<>r<>r<>r<>s r-r[zEngFormatter.__call__<5F>s}<00><00> <0F>t<EFBFBD>y<EFBFBD>y<EFBFBD>><3E>Q<EFBFBD> <1E>$<24>+<2B>+<2B><11>"2<><17>><3E>><3E>$<24>"2<>"2<>1<EFBFBD>"5<>6<> 6<><13>d<EFBFBD>k<EFBFBD>k<EFBFBD>/<2F>c<EFBFBD>T<EFBFBD>-B<>-B<>&B<>C<>B<EFBFBD><12>2<EFBFBD>w<EFBFBD><14>~<7E><16><02><17>6<>6<>t<EFBFBD>{<7B>{<7B>B<EFBFBD>G<> Gr/c<00><><00>||_t|j<00>dkDr<>t|jj <00><00>\}}|j
r6|j <00>|jdk7rt||zdz d<03>|_tjtj||z
d<04><00>dz|_ |j<00>yy)Nrr<>r9<00><>)ror<>r'rMr4r<>rr<>rrrrZr<>r)r+ror8r9s r-r]zEngFormatter.set_locs<63>s<><00><00><18><04> <09> <0E>t<EFBFBD>y<EFBFBD>y<EFBFBD>><3E>A<EFBFBD> <1D><1F><04> <09> <09> ;<3B> ;<3B> =<3D>><3E>J<EFBFBD>D<EFBFBD>$<24><13><EFBFBD><EFBFBD><14>$<24>$<24>&<26><17>;<3B>;<3B>!<21>#<23>#(<28><14><04><1B>a<EFBFBD><0F><11>";<3B>D<EFBFBD>K<EFBFBD>$(<28>J<EFBFBD>J<EFBFBD>t<EFBFBD>x<EFBFBD>x<EFBFBD><04>t<EFBFBD> <0B>T<EFBFBD>/J<>$K<>A<EFBFBD>$M<>D<EFBFBD> !<21> <10> <1C> <1C> <1E> r/c<00><><00>t|j<00>dk(ry|jr<>d}|jr/|j|j<00>}|jdkDrd|z}|jd|jz<00>}|j
s |j r|dk7rd|z}d|<02>|<01>d<06>}n||z}|j|<03>Sy)Nrrkrr z\times%sr)r<>ror<>rer<>r<>r<>rwrs r-rlzEngFormatter.get_offset<65>s<><00><00> <0E>t<EFBFBD>y<EFBFBD>y<EFBFBD>><3E>Q<EFBFBD> <1E><15> <0F>;<3B>;<3B><1A>I<EFBFBD><13>{<7B>{<7B> <20>,<2C>,<2C>T<EFBFBD>[<5B>[<5B>9<> <09><17>;<3B>;<3B><11>?<3F> #<23>i<EFBFBD><0F>I<EFBFBD><1C>(<28>(<28><12>t<EFBFBD>/D<>/D<>)D<>E<>I<EFBFBD><13> <20> <20>D<EFBFBD>L<EFBFBD>L<EFBFBD><1C><02>?<3F> +<2B>i<EFBFBD> 7<>I<EFBFBD><17> <09>{<7B>9<EFBFBD>+<2B>Q<EFBFBD>/<2F><01><1D> <09>)<29><01><17>><3E>><3E>!<21>$<24> $<24>r/c<00>$<00>|j|<01>S)z!Alias to EngFormatter.format_datarg)r+<00>nums r-<00>
format_engzEngFormatter.format_eng<6E>s<00><00><13><1F><1F><03>$<24>$r/c<00><><00>d}|j<00>dnd|jd<04>d<05>}|dkrd}| }|dk7r8ttjtj|<01>dz <00>dz<00>}nd}d }t j |t|j<00>t|j<00><00>}||zd
|zz }ttt||<03><00><00>d k\r"|t|j<00>kr
|d z}|dz }|jt|<04>}|js|r|j<00>|<06>|j<00><00>}nd }|js |j r d ||<03>d <0C><02>d |<07><00>S||<03>d <0C><02>|<07><00>S)u{
Format a number in engineering notation, appending a letter
representing the power of 1000 of the original number.
Some examples:
>>> format_data(0) # for self.places = 0
'0'
>>> format_data(1000000) # for self.places = 1
'1.0 M'
>>> format_data(-1e-6) # for self.places = 2
'-1.00 µ'
r'r<>rxryr<rr<>r9rgr<>r<>rkr)r<>r?rrrr<><00>clipr)<00> ENG_PREFIXESrr<>r*r<>r<>r<>r<>r<>)r+rar2r<><00>pow10<31>mant<6E> unit_prefix<69>suffixs r-rezEngFormatter.format_data<74>sk<00><00><11><04><19>[<5B>[<5B>(<28>c<EFBFBD><01>$<24>+<2B>+<2B>a<EFBFBD><1F><01>.B<><03> <10>1<EFBFBD>9<EFBFBD><15>D<EFBFBD><1A>F<EFBFBD>E<EFBFBD> <10>A<EFBFBD>:<3A><17><04>
<EFBFBD>
<EFBFBD>4<EFBFBD>:<3A>:<3A>e<EFBFBD>#4<>q<EFBFBD>#8<>9<>A<EFBFBD>=<3D>><3E>E<EFBFBD><15>E<EFBFBD><18>E<EFBFBD><12><07><07><05>s<EFBFBD>4<EFBFBD>#4<>#4<>5<>s<EFBFBD>4<EFBFBD>;L<>;L<>7M<37>N<><05><13>e<EFBFBD>|<7C>t<EFBFBD>u<EFBFBD>}<7D>-<2D><04> <10><05>f<EFBFBD>T<EFBFBD>3<EFBFBD>'<27>(<28> )<29>T<EFBFBD> 1<><19>C<EFBFBD><04> 1<> 1<>2<>2<> <10>D<EFBFBD>L<EFBFBD>D<EFBFBD> <11>Q<EFBFBD>J<EFBFBD>E<EFBFBD><1A>'<27>'<27><03>E<EFBFBD>
<EFBFBD>3<> <0B> <0F>9<EFBFBD>9<EFBFBD> <0B><1C><08><08>z<EFBFBD>+<2B><1D>t<EFBFBD>y<EFBFBD>y<EFBFBD>k<EFBFBD>:<3A>F<EFBFBD><17>F<EFBFBD> <0F><<3C><<3C>4<EFBFBD>,<2C>,<2C><16>t<EFBFBD>S<EFBFBD>E<EFBFBD><10>6<EFBFBD>l<EFBFBD>!<21>F<EFBFBD>8<EFBFBD>,<2C> ,<2C><1A>C<EFBFBD>5<EFBFBD><00>&<26>\<5C>&<26><18>*<2A> *r/)rkN<> r1) rHrIrJr{r<>r.r[r]rlr<>rer<>r<>s@r-rr8s<00><><00><08> <06> <0B>S<EFBFBD><06> <0B>S<EFBFBD><06> <0C>S<EFBFBD><06> <0C>S<EFBFBD> <06>
<0C>S<EFBFBD> <06> <0C>S<EFBFBD> <06> <0C>S<EFBFBD><06>
<0C>S<EFBFBD><06>
<0C> <1D><06>
<0C>S<EFBFBD><06> <0C>R<EFBFBD><06> <0C>S<EFBFBD><06> <0C>S<EFBFBD><06> <0C>S<EFBFBD><06>
<0C>S<EFBFBD><06>
<0C>S<EFBFBD>!<06>"
<0C>S<EFBFBD>#<06>$<11> <10> <10> <10>+<06>L<EFBFBD>05
<EFBFBD><04>!<21>U<EFBFBD>5
<EFBFBD>n H<01><1F>2<12>(%<25>2+r/rc<00>`<00>eZdZdZd d<03>Zd
d<04>Zd<05>Zd<06>Zed<07><00>Z e jd<08><00>Z y) ra<>
Format numbers as a percentage.
Parameters
----------
xmax : float
Determines how the number is converted into a percentage.
*xmax* is the data value that corresponds to 100%.
Percentages are computed as ``x / xmax * 100``. So if the data is
already scaled to be percentages, *xmax* will be 100. Another common
situation is where *xmax* is 1.0.
decimals : None or int
The number of decimal places to place after the point.
If *None* (the default), the number will be computed automatically.
symbol : str or None
A string that will be appended to the label. It may be
*None* or empty to indicate that no symbol should be used. LaTeX
special characters are escaped in *symbol* whenever latex mode is
enabled, unless *is_latex* is *True*.
is_latex : bool
If *False*, reserved LaTeX characters in *symbol* will be escaped.
Nc<00>B<00>|dz|_||_||_||_y)Nrg)<04>xmaxr;<00>_symbol<6F> _is_latex)r+r<>r;<00>symbol<6F>is_latexs r-r.zPercentFormatter.__init__s"<00><00><18>3<EFBFBD>J<EFBFBD><04> <09> <20><04> <0A><1D><04> <0C>!<21><04>r/c<00><><00>|jj<00>\}}t||z
<00>}|j|j ||<05><00>S)z=Format the tick as a percentage with the appropriate scaling.)rMr4r<>rw<00>
format_pct)r+rYrZ<00>ax_min<69>ax_max<61> display_ranges r-r[zPercentFormatter.__call__#s@<00><00><1D><19><19>4<>4<>6<><0E><06><06><1B>F<EFBFBD>V<EFBFBD>O<EFBFBD>,<2C> <0A><13>~<7E>~<7E>d<EFBFBD>o<EFBFBD>o<EFBFBD>a<EFBFBD><1D>?<3F>@<40>@r/c<00>B<00>|j|<01>}|j<00>W|j|<02>}|dkrd}nJtjdtjd|z<00>z
<00>}|dkDrd}n|dkrd}n |j}|dt |<04><00>d<05><03>}||j zS)a|
Format the number as a percentage number with the correct
number of decimals and adds the percent symbol, if any.
If ``self.decimals`` is `None`, the number of digits after the
decimal point is set based on the *display_range* of the axis
as follows:
============= ======== =======================
display_range decimals sample
============= ======== =======================
>50 0 ``x = 34.5`` => 35%
>5 1 ``x = 34.5`` => 34.5%
>0.5 2 ``x = 34.5`` => 34.50%
... ... ...
============= ======== =======================
This method will not be very good for tiny axis ranges or
extremely large ones. It assumes that the values on the chart
are percentages displayed on a reasonable scale.
r<00>@<40>z0.r<)<07>convert_to_pctr;rr,rr?r<>)r+rYr<><00> scaled_ranger;rvs r-r<>zPercentFormatter.format_pct)s<><00><00>, <11> <1F> <1F><01> "<22><01> <0F>=<3D>=<3D> <20><1F>.<2E>.<2E>}<7D>=<3D>L<EFBFBD><1B>q<EFBFBD> <20><1C><08>  <20>9<EFBFBD>9<EFBFBD>S<EFBFBD>4<EFBFBD>:<3A>:<3A>c<EFBFBD>L<EFBFBD>6H<36>+I<>%I<>J<><08><1B>a<EFBFBD><<3C> <20>H<EFBFBD><1D><01>\<5C> <20>H<EFBFBD><1B>}<7D>}<7D>H<EFBFBD><10><12>C<EFBFBD><08>M<EFBFBD>?<3F>!<21>#<23>$<24><01><10>4<EFBFBD>;<3B>;<3B><EFBFBD>r/c<00>&<00>d||jz zS)NgY@)r<>)r+rYs r-r<>zPercentFormatter.convert_to_pctUs<00><00><14><01>D<EFBFBD>I<EFBFBD>I<EFBFBD> <0A>&<26>&r/c<00><><00>|j}|sd}|S|js/tjdrdD]}|j |d|z<00>}<01>|S)z<>
The configured percent symbol as a string.
If LaTeX is enabled via :rc:`text.usetex`, the special characters
``{'#', '$', '%', '&', '~', '_', '^', '\', '{', '}'}`` are
automatically escaped in the string.
rkr<>z
\#$%&~_^{}<7D>\)r<>r<>rsrtru)r+r<><00>specs r-r<>zPercentFormatter.symbolXsZ<00><00><16><1C><1C><06><15><17>F<EFBFBD><16> <0A> <16><1E><1E>C<EFBFBD>L<EFBFBD>L<EFBFBD><1D>$?<3F>&<26> ;<3B><04><1F><1E><1E><04>d<EFBFBD>T<EFBFBD>k<EFBFBD>:<3A><06> ;<3B><15> r/c<00><00>||_yr1)r<>)r+r<>s r-r<>zPercentFormatter.symbolls <00><00><1D><04> r/)<04>dN<>%Fr1) rHrIrJr{r.r[r<>r<>rEr<><00>setterrEr/r-rrsI<00><00><08>2"<22> A<01> *<1F>X'<27><0E><16><0E><16>& <0C>]<5D>]<5D><1E><13>r/rc<00>8<00>eZdZdZdZd<03>Zd<04>Zd<05>Zd<06>Zd<07>Z d<08>Z
y )
rz<>
Determine tick locations.
Note that the same locator should not be used across multiple
`~matplotlib.axis.Axis` because the locator stores references to the Axis
data and view limits.
r<>c<00><00>td<01><00>)a<>
Return the values of the located ticks given **vmin** and **vmax**.
.. note::
To get tick locations with the vmin and vmax values defined
automatically for the associated ``axis`` simply call
the Locator instance::
>>> print(type(loc))
<type 'Locator'>
>>> print(loc())
[1, 2, 3, 4]
rUrVr7s r-<00> tick_valueszLocator.tick_values<65>s<00><00>"<22>"9<>:<3A>:r/c <00>X<00>tjdtt|<00><00>z<00>y)z<>
Do nothing, and raise a warning. Any locator class not supporting the
set_params() function will call this.
z/'set_params()' not defined for locator of type N)rr<>r<><00>typerPs r-<00>
set_paramszLocator.set_params<6D>s%<00><00>
<0A><1A><1A> =<3D> <0F><04>T<EFBFBD>
<EFBFBD>O<EFBFBD> <1C> r/c<00><00>td<01><00>)<02>"Return the locations of the ticks.rUrVr3s r-r[zLocator.__call__<5F>s<00><00>"<22>"9<>:<3A>:r/c<00><><00>t|<01>|jk\r2tjdt|<01>|d|d|j<00>|S)a<>
Log at WARNING level if *locs* is longer than `Locator.MAXTICKS`.
This is intended to be called immediately before returning *locs* from
``__call__`` to inform users in case their Locator returns a huge
number of ticks, causing Matplotlib to run out of memory.
The "strange" name of this method dates back to when it would raise an
exception instead of emitting a log.
z]Locator attempting to generate %s ticks ([%s, ..., %s]), which exceeds Locator.MAXTICKS (%s).rr<>)r<><00>MAXTICKS<4B>_log<6F>warningrps r-<00>raise_if_exceedszLocator.raise_if_exceeds<64>sE<00><00> <0F>t<EFBFBD>9<EFBFBD><04> <0A> <0A> %<25> <10>L<EFBFBD>L<EFBFBD>7<><13>D<EFBFBD> <09>4<EFBFBD><01>7<EFBFBD>D<EFBFBD><12>H<EFBFBD>d<EFBFBD>m<EFBFBD>m<EFBFBD> =<3D><14> r/c<00>2<00>tj||d<01><02>S)a1
Adjust a range as needed to avoid singularities.
This method gets called during autoscaling, with ``(v0, v1)`` set to
the data limits on the Axes if the Axes contains any data, or
``(-inf, +inf)`` if not.
- If ``v0 == v1`` (possibly up to some floating point slop), this
method returns an expanded interval around this value.
- If ``(v0, v1) == (-inf, +inf)``, this method returns appropriate
default view limits.
- Otherwise, ``(v0, v1)`` is returned without modification.
rirj<00>rmrn)r+<00>v0<76>v1s r-rnzLocator.nonsingular<61>s<00><00><1B>&<26>&<26>r<EFBFBD>2<EFBFBD><03><<3C><r/c<00>.<00>tj||<02>S)z<>
Select a scale for the range from vmin to vmax.
Subclasses should override this method to change locator behaviour.
rr7s r-<00> view_limitszLocator.view_limits<74>s<00><00> <1B>&<26>&<26>t<EFBFBD>T<EFBFBD>2<>2r/N) rHrIrJr{rr rr[rrnrrEr/r-rrqs,<00><00><08><14>H<EFBFBD>;<3B>"<1D>;<3B> <14>$=<3D> 3r/rc<00>*<00>eZdZdZd<02>Zdd<04>Zd<05>Zd<06>Zy)rz<>
Place ticks at every nth point plotted.
IndexLocator assumes index plotting; i.e., that the ticks are placed at integer
values in the range between 0 and len(data) inclusive.
c<00> <00>||_||_y)z:Place ticks every *base* data point, starting at *offset*.N<>rSr<><00>r+rOr<>s r-r.zIndexLocator.__init__<5F>s<00><00><19><04>
<EFBFBD><1C><04> r/Nc<00>*<00>|<01>||_|<02>||_yy)z"Set parameters within this locatorNrrs r-rzIndexLocator.set_params<6D>s!<00><00> <0F> <1B><1D>D<EFBFBD>J<EFBFBD> <11> <1D> <20>D<EFBFBD>K<EFBFBD> r/c<00>`<00>|jj<00>\}}|j||<02>S)z!Return the locations of the ticks)rMr@r <00>r+<00>dmin<69>dmaxs r-r[zIndexLocator.__call__<5F><00>+<00><00><19>Y<EFBFBD>Y<EFBFBD>0<>0<>2<>
<EFBFBD><04>d<EFBFBD><13><1F><1F><04>d<EFBFBD>+<2B>+r/c<00><><00>|jtj||jz|dz|j<00><00>S)Nr')rr<>r]r<>rSr7s r-r zIndexLocator.tick_values<65>s8<00><00><13>$<24>$<24> <0E>I<EFBFBD>I<EFBFBD>d<EFBFBD>T<EFBFBD>[<5B>[<5B>(<28>$<24><11>(<28>D<EFBFBD>J<EFBFBD>J<EFBFBD> ?<3F>A<01> Ar/<00>NN<4E>rHrIrJr{r.rr[r rEr/r-rr<00>s<00><00><08> <1D>
!<21>,<2C>
Ar/rc<00>,<00>eZdZdZdd<03>Zdd<04>Zd<05>Zd<06>Zy)ra<>
Place ticks at a set of fixed values.
If *nbins* is None ticks are placed at all values. Otherwise, the *locs* array of
possible positions will be subsampled to keep the number of ticks
:math:`\leq nbins + 1`. The subsampling will be done to include the smallest
absolute value; for example, if zero is included in the array of possibilities, then
it will be included in the chosen ticks.
Nc<00><><00>tj|<01>|_tjd|j<00><02>|<02>t |d<03>|_yd|_y)Nr1rnr<>)r<>r(ror<00> check_shaper<00>nbins)r+ror,s r-r.zFixedLocator.__init__<5F>s><00><00><16>J<EFBFBD>J<EFBFBD>t<EFBFBD>$<24><04> <09> <0C><18><18><17>t<EFBFBD>y<EFBFBD>y<EFBFBD>1<>&+<2B>&7<>S<EFBFBD><15><01>]<5D><04>
<EFBFBD>T<EFBFBD><04>
r/c<00><00>|<01>||_yy<01><02>#Set parameters within this locator.N<>r,)r+r,s r-rzFixedLocator.set_params<6D>s<00><00> <10> <1C><1E>D<EFBFBD>J<EFBFBD> r/c<00>&<00>|jdd<00>Sr1<00>r r3s r-r[zFixedLocator.__call__<5F><00><00><00><13><1F><1F><04>d<EFBFBD>+<2B>+r/c <00><><00>|j<00> |jSttt j
t |j<00>|jz <00><00>d<02>}|jdd|<03>}td|<03>D]^}|j|d|<03>}t j|<06>j<00>t j|<04>j<00>ks<01>]|}<04>`|j|<04>S)z<>
Return the locations of the ticks.
.. note::
Because the values are fixed, vmin and vmax are not used in this
method.
Nr') r,rorr?r<>r,r<>r<>r<>r)r)r+r8r9<00>step<65>ticksr`<00>ticks1s r-r zFixedLocator.tick_valuess<><00><00> <10>:<3A>:<3A> <1D><17>9<EFBFBD>9<EFBFBD> <1C><12>3<EFBFBD>r<EFBFBD>w<EFBFBD>w<EFBFBD>s<EFBFBD>4<EFBFBD>9<EFBFBD>9<EFBFBD>~<7E><04>
<EFBFBD>
<EFBFBD>:<3A>;<3B><<3C>a<EFBFBD>@<40><04><14> <09> <09>&<26>D<EFBFBD>&<26>!<21><05><16>q<EFBFBD>$<24><1E> <1F>A<EFBFBD><19>Y<EFBFBD>Y<EFBFBD>q<EFBFBD>w<EFBFBD>$<24>w<EFBFBD>'<27>F<EFBFBD><11>v<EFBFBD>v<EFBFBD>f<EFBFBD>~<7E>!<21>!<21>#<23>b<EFBFBD>f<EFBFBD>f<EFBFBD>U<EFBFBD>m<EFBFBD>&7<>&7<>&9<>9<><1E><05> <1F><14>$<24>$<24>U<EFBFBD>+<2B>+r/r1r(rEr/r-rr<00>s<00><00><08>B<01>
<1F>
,<2C>,r/rc<00><00>eZdZdZd<02>Zd<03>Zy)rz
No ticks
c<00>&<00>|jdd<00>Sr1r2r3s r-r[zNullLocator.__call__r3r/c<00><00>gS)z<>
Return the locations of the ticks.
.. note::
Because the values are Null, vmin and vmax are not used in this
method.
rEr7s r-r zNullLocator.tick_valuess <00><00><12> r/N)rHrIrJr{r[r rEr/r-rrs<00><00><08>,<2C> r/rc<00>f<00>eZdZdZd
d<03>Zed<04><00>Zejd<05><00>Zd
d<06>Zd<07>Z d<08>Z
d <09>Z y) ra 
Place ticks at evenly spaced values.
The first time this function is called it will try to set the
number of ticks to make a nice tick partitioning. Thereafter, the
number of ticks will be fixed so that interactive navigation will
be nice
Nc<00>4<00>||_|<02>i|_y||_y)ao
Parameters
----------
numticks : int or None, default None
Number of ticks. If None, *numticks* = 11.
presets : dict or None, default: None
Dictionary mapping ``(vmin, vmax)`` to an array of locations.
Overrides *numticks* if there is an entry for the current
``(vmin, vmax)``.
N)<02>numticks<6B>presets<74>r+r=r>s r-r.zLinearLocator.__init__3s<00><00>!<21><04> <0A> <12>?<3F><1D>D<EFBFBD>L<EFBFBD>"<22>D<EFBFBD>Lr/c<00>6<00>|j<00> |jSdS)N<> <00><01> _numticksr3s r-r=zLinearLocator.numticksDs<00><00>"&<26><1E><1E>!;<3B>t<EFBFBD>~<7E>~<7E>C<><12>Cr/c<00><00>||_yr1rB)r+r=s r-r=zLinearLocator.numticksIs <00><00>!<21><04>r/c<00>*<00>|<02>||_|<01>||_yyr.)r>r=r?s r-rzLinearLocator.set_paramsMs!<00><00> <12> <1E>"<22>D<EFBFBD>L<EFBFBD> <13> <1F>$<24>D<EFBFBD>M<EFBFBD> r/c<00>`<00>|jj<00>\}}|j||<02>S<00>r<00>rMr4r r7s r-r[zLinearLocator.__call__Tr%r/c<00><00>tj||d<01><02>\}}||f|jvr|j||fS|jdk(rgSt j
|||j<00>}|j |<03>S)Nrirjr)rmrnr>r=r<><00>linspacer)r+r8r9<00>ticklocss r-r zLinearLocator.tick_valuesYsu<00><00> <20>,<2C>,<2C>T<EFBFBD>4<EFBFBD>$<24>G<>
<EFBFBD><04>d<EFBFBD> <10>$<24><<3C>4<EFBFBD><<3C><<3C> '<27><17><<3C><<3C><14>t<EFBFBD> <0C>-<2D> -<2D> <0F>=<3D>=<3D>A<EFBFBD> <1D><15>I<EFBFBD><15>;<3B>;<3B>t<EFBFBD>T<EFBFBD>4<EFBFBD>=<3D>=<3D>9<><08><13>$<24>$<24>X<EFBFBD>.<2E>.r/c <00><><00>||kr||}}||k(r
|dz}|dz }tjddk(r<>ttj||z
<00>tjt |j dz
d<01><00><00>\}}||dkz}t |j dz
d<01>| z}tj||z<00>|z }tj||z<00>|z }tj||<02>S)<05>,Try to choose the view limits intelligently.r'<00>axes.autolimit_mode<64> round_numbersr<73>) rsrt<00>divmodrrrr=rr,rmrn)r+r8r9r<00> remainder<65>scales r-rzLinearLocator.view_limitses<><00><00> <10>$<24>;<3B><1D>t<EFBFBD>$<24>D<EFBFBD> <0F>4<EFBFBD><<3C> <10>A<EFBFBD>I<EFBFBD>D<EFBFBD> <10>A<EFBFBD>I<EFBFBD>D<EFBFBD> <0E><<3C><<3C>-<2D> .<2E>/<2F> A<>"(<28><14>
<EFBFBD>
<EFBFBD>4<EFBFBD>$<24>;<3B>'<27><14><1A><1A>C<EFBFBD><04> <0A> <0A><01>8I<38>1<EFBFBD>4M<34>)N<>#P<01> <1F>H<EFBFBD>i<EFBFBD> <14><19>R<EFBFBD><1E> (<28>H<EFBFBD><17><04> <0A> <0A><01>)<29>1<EFBFBD>-<2D>8<EFBFBD>)<29><<3C>E<EFBFBD><17>:<3A>:<3A>e<EFBFBD>d<EFBFBD>l<EFBFBD>+<2B>e<EFBFBD>3<>D<EFBFBD><17>9<EFBFBD>9<EFBFBD>U<EFBFBD>T<EFBFBD>\<5C>*<2A>U<EFBFBD>2<>D<EFBFBD><1A>&<26>&<26>t<EFBFBD>T<EFBFBD>2<>2r/r') rHrIrJr{r.rEr=rrr[r rrEr/r-rr)sN<00><00><08>#<23>"<0E>D<01><0E>D<01><0E>_<EFBFBD>_<EFBFBD>"<22><15>"<22>%<25>,<2C>
/<2F>3r/rc<00>2<00>eZdZdZdd<02>Zd d<04>Zd<05>Zd<06>Zd<07>Zy)
rzI
Place ticks at every integer multiple of a base plus an offset.
c<00>4<00>t|d<01>|_||_y)z<>
Parameters
----------
base : float > 0, default: 1.0
Interval between ticks.
offset : float, default: 0.0
Value added to each multiple of *base*.
.. versionadded:: 3.8
rN<><03> _Edge_integer<65>_edge<67>_offsetrs r-r.zMultipleLocator.__init__s<00><00>#<23>4<EFBFBD><11>+<2B><04>
<EFBFBD><1D><04> r/Nc<00>><00>|<01>t|d<02>|_|<02>||_yy)a
Set parameters within this locator.
Parameters
----------
base : float > 0, optional
Interval between ticks.
offset : float, optional
Value added to each multiple of *base*.
.. versionadded:: 3.8
NrrUrs r-rzMultipleLocator.set_params<6D>s*<00><00> <10> <1B>&<26>t<EFBFBD>Q<EFBFBD>/<2F>D<EFBFBD>J<EFBFBD> <11> <1D>!<21>D<EFBFBD>L<EFBFBD> r/c<00>`<00>|jj<00>\}}|j||<02>SrGrHr7s r-r[zMultipleLocator.__call__<5F>r%r/c<00>R<00>||kr||}}|jj}||jz}||jz}|jj|<01>|z}||z
d|zz|z}||z
t j
|dz<00>|zz|jz}|j |<05>S)Nr:r9)rWr5rX<00>ger<65>r]r)r+r8r9r5r4ros r-r zMultipleLocator.tick_values<65>s<><00><00> <0F>$<24>;<3B><1D>t<EFBFBD>$<24>D<EFBFBD><13>z<EFBFBD>z<EFBFBD><EFBFBD><EFBFBD><04> <0C><04> <0C> <0C><1C><04> <0C><04> <0C> <0C><1C><04><13>z<EFBFBD>z<EFBFBD>}<7D>}<7D>T<EFBFBD>"<22>T<EFBFBD>)<29><04> <11>D<EFBFBD>[<5B>5<EFBFBD>4<EFBFBD><<3C> '<27>D<EFBFBD> 0<><01><13>d<EFBFBD>{<7B>R<EFBFBD>Y<EFBFBD>Y<EFBFBD>q<EFBFBD>1<EFBFBD>u<EFBFBD>-<2D><04>4<>4<>t<EFBFBD>|<7C>|<7C>C<><04><13>$<24>$<24>T<EFBFBD>*<2A>*r/c<00><><00>tjddk(r<>|jj||jz
<00>|jj
z|jz}|jj ||jz
<00>|jj
z|jz}||k(r|dz}|dz }n|}|}tj||<04>S)zW
Set the view limits to the nearest tick values that contain the data.
rNrOr') rsrtrW<00>lerXr5r\rmrn)r+r#r$r8r9s r-rzMultipleLocator.view_limits<74>s<><00><00> <0F><<3C><<3C>-<2D> .<2E>/<2F> A<><17>:<3A>:<3A>=<3D>=<3D><14><04> <0C> <0C>!4<>5<><04>
<EFBFBD>
<EFBFBD><0F><0F>G<>$<24>,<2C>,<2C>V<>D<EFBFBD><17>:<3A>:<3A>=<3D>=<3D><14><04> <0C> <0C>!4<>5<><04>
<EFBFBD>
<EFBFBD><0F><0F>G<>$<24>,<2C>,<2C>V<>D<EFBFBD><13>t<EFBFBD>|<7C><14><01> <09><04><14><01> <09><04><17>D<EFBFBD><17>D<EFBFBD><1A>&<26>&<26>t<EFBFBD>T<EFBFBD>2<>2r/)<02><00>?rgr'<00> rHrIrJr{r.rr[r rrEr/r-rrzs <00><00><08> <1E>"<22>$,<2C>
+<2B>3r/rc<00>
<00>t||z
<00>}||zdz }t|<05>|z |krd}n8tjdtjt|<05><00>dzz|<05>}dtj||z <00>dzz}||fS)Nr<4E>rr r')r<>rr+r)r8r9r4<00> threshold<6C>dv<64>meanvr<76>rRs r-<00> scale_rangere<00>s<><00><00> <0C>T<EFBFBD>D<EFBFBD>[<5B> <19>B<EFBFBD> <11>D<EFBFBD>[<5B>A<EFBFBD> <1D>E<EFBFBD>
<EFBFBD>5<EFBFBD>z<EFBFBD>B<EFBFBD><EFBFBD><19>"<22><12><06><15><1D><1D>r<EFBFBD>d<EFBFBD>j<EFBFBD>j<EFBFBD><13>U<EFBFBD><1A>&<<3C><01>&A<>B<>E<EFBFBD>J<><06> <0E>4<EFBFBD>:<3A>:<3A>b<EFBFBD>1<EFBFBD>f<EFBFBD>%<25><11>*<2A> +<2B>E<EFBFBD> <10>&<26>=<3D>r/c<00>(<00>eZdZdZd<02>Zd<03>Zd<04>Zd<05>Zy)rVz<>
Helper for `.MaxNLocator`, `.MultipleLocator`, etc.
Take floating-point precision limitations into account when calculating
tick locations as integer multiples of a step.
c<00>R<00>|dkr td<02><00>||_t|<02>|_y)z<>
Parameters
----------
step : float > 0
Interval between ticks.
offset : float
Offset subtracted from the data limits prior to calculating tick
locations.
rz'step' must be positiveN)r<>r5r<>rX)r+r5r<>s r-r.z_Edge_integer.__init__<5F>s)<00><00> <10>1<EFBFBD>9<EFBFBD><1C>6<>7<> 7<><18><04> <09><1A>6<EFBFBD>{<7B><04> r/c<00><><00>|jdkDrKtj|j|jz <00>}t dd|dz
z<00>}t d|<04>}nd}t ||z
<00>|kS)Nrg<><67><EFBFBD><EFBFBD><EFBFBD>|<7C>=r r<>g<Nё\<5C><>?)rXr<>rr5rr)r<>)r+<00>ms<6D>edge<67>digits<74>tols r-<00>closetoz_Edge_integer.closeto<74>sb<00><00> <0F><<3C><<3C>!<21> <1B><17>X<EFBFBD>X<EFBFBD>d<EFBFBD>l<EFBFBD>l<EFBFBD>T<EFBFBD>Y<EFBFBD>Y<EFBFBD>6<>7<>F<EFBFBD><15>e<EFBFBD>R<EFBFBD>F<EFBFBD>R<EFBFBD>K<EFBFBD>0<>1<>C<EFBFBD><15>f<EFBFBD>c<EFBFBD>"<22>C<EFBFBD><17>C<EFBFBD><12>2<EFBFBD><04>9<EFBFBD>~<7E><03>#<23>#r/c<00><><00>t||j<00>\}}|j||jz d<01>r|dzS|S)z"Return the largest n: n*step <= x.r'<00>rPr5rm<00>r+rYryr<>s r-r^z_Edge_integer.le<6C>s:<00><00><15>a<EFBFBD><14><19><19>#<23><04><01>1<EFBFBD> <0F><<3C><<3C><01>D<EFBFBD>I<EFBFBD>I<EFBFBD> <0A>q<EFBFBD> )<29><14>q<EFBFBD>5<EFBFBD>L<EFBFBD><10>r/c<00><><00>t||j<00>\}}|j||jz d<01>r|S|dzS)z#Return the smallest n: n*step >= x.rr'rorps r-r\z_Edge_integer.ge<67>s:<00><00><15>a<EFBFBD><14><19><19>#<23><04><01>1<EFBFBD> <0F><<3C><<3C><01>D<EFBFBD>I<EFBFBD>I<EFBFBD> <0A>q<EFBFBD> )<29><14>H<EFBFBD><10>1<EFBFBD>u<EFBFBD> r/N)rHrIrJr{r.rmr^r\rEr/r-rVrV<00>s<00><00><08> #<23>$<24><11>r/rVc<00>r<00>eZdZdZedddddd<05><06>Zdd<07>Zed<08><00>Zed <09><00>Z d
<EFBFBD>Z
d <0B>Z d <0C>Z d <0A>Z d<0E>Zy)rz<>
Place evenly spaced ticks, with a cap on the total number of ticks.
Finds nice tick locations with no more than :math:`nbins + 1` ticks being within the
view limits. Locations beyond the limits are added to support autoscaling.
r NFr<46>)r,<00>steps<70>integer<65> symmetric<69>prune<6E> min_n_ticksc <00>R<00>|<01>||d<|jdii|j<00>|<02><01><01>y)aj
Parameters
----------
nbins : int or 'auto', default: 10
Maximum number of intervals; one less than max number of
ticks. If the string 'auto', the number of bins will be
automatically determined based on the length of the axis.
steps : array-like, optional
Sequence of acceptable tick multiples, starting with 1 and
ending with 10. For example, if ``steps=[1, 2, 4, 5, 10]``,
``20, 40, 60`` or ``0.4, 0.6, 0.8`` would be possible
sets of ticks because they are multiples of 2.
``30, 60, 90`` would not be generated because 3 does not
appear in this example list of steps.
integer : bool, default: False
If True, ticks will take only integer values, provided at least
*min_n_ticks* integers are found within the view limits.
symmetric : bool, default: False
If True, autoscaling will result in a range symmetric about zero.
prune : {'lower', 'upper', 'both', None}, default: None
Remove the 'lower' tick, the 'upper' tick, or ticks on 'both' sides
*if they fall exactly on an axis' edge* (this typically occurs when
:rc:`axes.autolimit_mode` is 'round_numbers'). Removing such ticks
is mostly useful for stacked or ganged plots, where the upper tick
of an Axes overlaps with the lower tick of the axes above it.
min_n_ticks : int, default: 2
Relax *nbins* and *integer* constraints if necessary to obtain
this minimum number of ticks.
Nr,rE)r<00>default_params)r+r,rQs r-r.zMaxNLocator.__init__s6<00><00>F <11> <1C>#<23>F<EFBFBD>7<EFBFBD>O<EFBFBD><17><04><0F><0F><<3C>;<3B>T<EFBFBD>0<>0<>;<3B>F<EFBFBD>;<3B><r/c<00>|<00>tj|<00>s td<01><00>tj|<00>}tjtj
|<00>dk<00>s|ddkDs|ddkr td<01><00>|ddk7rtj dg|g<02>}|ddk7rtj |dgg<02>}|S)NzSsteps argument must be an increasing sequence of numbers between 1 and 10 inclusiverr<>r r')r<><00>iterabler<65>r(<00>anyr<79>r<><00>rss r-<00>_validate_stepszMaxNLocator._validate_steps/s<><00><00><11>{<7B>{<7B>5<EFBFBD>!<21><1C>E<01>F<01> F<01><12>
<EFBFBD>
<EFBFBD>5<EFBFBD>!<21><05> <0A>6<EFBFBD>6<EFBFBD>"<22>'<27>'<27>%<25>.<2E>A<EFBFBD>%<25> &<26>%<25><02>)<29>b<EFBFBD>.<2E>E<EFBFBD>!<21>H<EFBFBD>q<EFBFBD>L<EFBFBD><1C>E<01>F<01> F<01> <10><11>8<EFBFBD>q<EFBFBD>=<3D><16>N<EFBFBD>N<EFBFBD>Q<EFBFBD>C<EFBFBD><15><<3C>0<>E<EFBFBD> <10><12>9<EFBFBD><02>?<3F><16>N<EFBFBD>N<EFBFBD>E<EFBFBD>B<EFBFBD>4<EFBFBD>=<3D>1<>E<EFBFBD><14> r/c<00>L<00>tjd|ddz|d|dzgg<03>S)Nr<4E>r<>r r')r<>r<>r}s r-<00>
_staircasezMaxNLocator._staircase>s/<00><00><12>~<7E>~<7E>s<EFBFBD>U<EFBFBD>3<EFBFBD>B<EFBFBD>Z<EFBFBD>/<2F><15><12>e<EFBFBD>A<EFBFBD>h<EFBFBD><1D><0F>H<>I<>Ir/c <00><><00>d|vr?|jd<01>|_|jdk7rt|j<00>|_d|vr|jd<03>|_d|vr1|jd<04>}t j
gd<05>|<02><06>||_d|vr td|jd<07><00>|_d |vrf|jd <09>}|<03>tjgd <0B><01>|_ n|j|<03>|_ |j|j<00>|_d |vr|jd <0C>|_|rt j d |<01><00>y
)a
Set parameters for this locator.
Parameters
----------
nbins : int or 'auto', optional
see `.MaxNLocator`
steps : array-like, optional
see `.MaxNLocator`
integer : bool, optional
see `.MaxNLocator`
symmetric : bool, optional
see `.MaxNLocator`
prune : {'lower', 'upper', 'both', None}, optional
see `.MaxNLocator`
min_n_ticks : int, optional
see `.MaxNLocator`
r,<00>autorurv)<04>upper<65>lower<65>bothN)rvrwr'rsN)
r'g<00>?r<><00>@r9<00>r<>r<><00>r rtr)<11>pop<6F>_nbinsr?<00>
_symmetricr<00> check_in_list<73>_pruner<00> _min_n_ticksr<73>r<><00>_stepsr~r<><00>_extended_steps<70>_integer<65> kwarg_error)r+rQrvrss r-rzMaxNLocator.set_paramsDs$<00><00>& <13>f<EFBFBD> <1C> <20>*<2A>*<2A>W<EFBFBD>-<2D>D<EFBFBD>K<EFBFBD><13>{<7B>{<7B>f<EFBFBD>$<24>!<21>$<24>+<2B>+<2B>.<2E><04> <0B> <16>&<26> <20>$<24>j<EFBFBD>j<EFBFBD><1B>5<>D<EFBFBD>O<EFBFBD> <12>f<EFBFBD> <1C><1A>J<EFBFBD>J<EFBFBD>w<EFBFBD>'<27>E<EFBFBD> <10> <1E> <1E>?<3F>u<EFBFBD> M<><1F>D<EFBFBD>K<EFBFBD> <18>F<EFBFBD> "<22> #<23>A<EFBFBD>v<EFBFBD>z<EFBFBD>z<EFBFBD>-<2D>'@<40> A<>D<EFBFBD> <1D> <12>f<EFBFBD> <1C><1A>J<EFBFBD>J<EFBFBD>w<EFBFBD>'<27>E<EFBFBD><14>}<7D> <20>h<EFBFBD>h<EFBFBD>'J<>K<><04> <0B>"<22>2<>2<>5<EFBFBD>9<><04> <0B>#'<27>?<3F>?<3F>4<EFBFBD>;<3B>;<3B>#?<3F>D<EFBFBD> <20> <14><06> <1E>"<22>J<EFBFBD>J<EFBFBD>y<EFBFBD>1<>D<EFBFBD>M<EFBFBD> <11><16>"<22>"<22><<3C><16>8<> 8<> r/c<00>
<00>|jdk(rV|j<00>Gtj|jj <00>t d|j dz
<00>d<04>}nd}n |j}t|||<03>\}}||z
}||z
}|j|z}|jr9|dktj|tj|<08>z
<00>dkz} || }||z
|z }
t|jd<06>r+|jjjdk(r|
dzd z }
||
k\} tj d
d k(r||z|z} | ||zz} | | |k\z} t#| <0B>rtj$| <0B>d d }nt'|<08>dz
}|d|dzddd <0A>D]<5D>}|jrGtj(|<07>tj*|<06>z
|j dz
k\r t d|<0F>}||z|z}t-||<05>}|j/||z
<00>}|j1||z
<00>}tj2||dz<00>|z|z}||k||k\zj5<00>}||j k\s<01><>||zS|zS)z<>
Generate a list of tick locations including the range *vmin* to
*vmax*. In some applications, one or both of the end locations
will not be needed, in which case they are trimmed off
elsewhere.
r<>Nr'rDr:r<><00>3d<33>r<>rNrOrr<>)r<>rMr<>r<>rFrr<>rer<>r<>r<>r<00>hasattrr<72><00>namersrtr|<00>nonzeror<6F>rr,rVr^r\r]<00>sum)r+r8r9r,rRr<><00>_vmin<69>_vmaxrs<00>igood<6F>raw_step<65> large_steps<70> floored_vmins<6E> floored_vmaxs<78>istepr5<00> best_vminrj<00>low<6F>highr6<00>ntickss r-<00>
_raw_tickszMaxNLocator._raw_ticksos<><00><00> <10>;<3B>;<3B>&<26> <20><13>y<EFBFBD>y<EFBFBD>$<24><1A><07><07><04> <09> <09> 8<> 8<> :<3A> #<23>A<EFBFBD>t<EFBFBD>'8<>'8<>1<EFBFBD>'<<3C> =<3D>q<EFBFBD>B<01><05><1A><05><18>K<EFBFBD>K<EFBFBD>E<EFBFBD>#<23>D<EFBFBD>$<24><05>6<> <0A><05>v<EFBFBD><14>v<EFBFBD> <0A><05><14>v<EFBFBD> <0A><05><14>$<24>$<24>u<EFBFBD>,<2C><05> <0F>=<3D>=<3D><1A>Q<EFBFBD>Y<EFBFBD>2<EFBFBD>6<EFBFBD>6<EFBFBD>%<25>"<22>(<28>(<28>5<EFBFBD>/<2F>*A<>#B<>U<EFBFBD>#J<>K<>E<EFBFBD><19>%<25>L<EFBFBD>E<EFBFBD><1A>U<EFBFBD>]<5D>e<EFBFBD>+<2B><08> <12>4<EFBFBD>9<EFBFBD>9<EFBFBD>f<EFBFBD> %<25>$<24>)<29>)<29>.<2E>.<2E>*=<3D>*=<3D><14>*E<> <20>"<22>}<7D>R<EFBFBD>'<27>H<EFBFBD><1B>x<EFBFBD>'<27> <0B> <0E><<3C><<3C>-<2D> .<2E>/<2F> A<>#<23>e<EFBFBD>^<5E>u<EFBFBD>4<>M<EFBFBD>)<29>E<EFBFBD>E<EFBFBD>M<EFBFBD>9<>M<EFBFBD>%<25><1D>%<25>)?<3F>@<40>K<EFBFBD> <0F>{<7B> <1B><16>J<EFBFBD>J<EFBFBD>{<7B>+<2B>A<EFBFBD>.<2E>q<EFBFBD>1<>E<EFBFBD><17><05>J<EFBFBD><11>N<EFBFBD>E<EFBFBD>
<1A>(<28>5<EFBFBD><11>7<EFBFBD>O<EFBFBD>D<EFBFBD>b<EFBFBD>D<EFBFBD>)<29> <16>D<EFBFBD><14> <0A> <0A><16>H<EFBFBD>H<EFBFBD>U<EFBFBD>O<EFBFBD>b<EFBFBD>g<EFBFBD>g<EFBFBD>e<EFBFBD>n<EFBFBD>4<><04>8I<38>8I<38>A<EFBFBD>8M<38>M<><1A>1<EFBFBD>d<EFBFBD>|<7C><04><1E>$<24><1D>$<24>.<2E>I<EFBFBD> !<21><14>v<EFBFBD>.<2E>D<EFBFBD><16>'<27>'<27>%<25>)<29>+<2B>,<2C>C<EFBFBD><17>7<EFBFBD>7<EFBFBD>5<EFBFBD>9<EFBFBD>,<2C>-<2D>D<EFBFBD><16>I<EFBFBD>I<EFBFBD>c<EFBFBD>4<EFBFBD>!<21>8<EFBFBD>,<2C>t<EFBFBD>3<>i<EFBFBD>?<3F>E<EFBFBD><1C><05>~<7E>%<25>5<EFBFBD>.<2E>9<>><3E>><3E>@<40>F<EFBFBD><15><14>*<2A>*<2A>*<2A><15><14>v<EFBFBD>~<7E><1D>' <16>&<15>v<EFBFBD>~<7E>r/c<00>`<00>|jj<00>\}}|j||<02>Sr1rHr7s r-r[zMaxNLocator.__call__<5F>s+<00><00><19>Y<EFBFBD>Y<EFBFBD>0<>0<>2<>
<EFBFBD><04>d<EFBFBD><13><1F><1F><04>d<EFBFBD>+<2B>+r/c<00>2<00>|jr!tt|<01>t|<02><00>}| }tj||dd<02><03>\}}|j ||<02>}|j }|dk(r|dd}n|dk(r|dd}n
|dk(r|dd}|j|<03>S) N<><4E>vIh<49>%<=g<>+<2B><><EFBFBD><EFBFBD>=<3D>rk<00>tinyr<79>r'r<>r<>r<>)r<>rr<>rmrnr<>r<>r)r+r8r9rorvs r-r zMaxNLocator.tick_values<65>s<><00><00> <0F>?<3F>?<3F><16>s<EFBFBD>4<EFBFBD>y<EFBFBD>#<23>d<EFBFBD>)<29>,<2C>D<EFBFBD><18>5<EFBFBD>D<EFBFBD> <20>,<2C>,<2C> <10>$<24><15>U<EFBFBD>4<>
<EFBFBD><04>d<EFBFBD><13><EFBFBD><EFBFBD>t<EFBFBD>T<EFBFBD>*<2A><04><14> <0B> <0B><05> <10>G<EFBFBD> <1B><17><01><02>8<EFBFBD>D<EFBFBD> <12>g<EFBFBD> <1D><17><03><12>9<EFBFBD>D<EFBFBD> <12>f<EFBFBD>_<EFBFBD><17><01>"<22>:<3A>D<EFBFBD><13>$<24>$<24>T<EFBFBD>*<2A>*r/c<00><><00>|jr!tt|<01>t|<02><00>}| }tj||dd<02><03>\}}t
j ddk(r|j||<02>ddgS||fS)Ng<11>-<2D><><EFBFBD>q=r<>r<>rNrOrr<>)r<>rr<>rmrnrsrtr<>r"s r-rzMaxNLocator.view_limits<74>sy<00><00> <0F>?<3F>?<3F><16>s<EFBFBD>4<EFBFBD>y<EFBFBD>#<23>d<EFBFBD>)<29>,<2C>D<EFBFBD><18>5<EFBFBD>D<EFBFBD> <20>,<2C>,<2C> <10>$<24><15>U<EFBFBD>4<>
<EFBFBD><04>d<EFBFBD> <0F><<3C><<3C>-<2D> .<2E>/<2F> A<><17>?<3F>?<3F>4<EFBFBD><14>.<2E><01>2<EFBFBD>w<EFBFBD>7<> 7<><17><14>:<3A> r/r1)rHrIrJr{<00>dictryr.r|r~r<>rr<>r[r rrEr/r-rr<00>sp<00><00><08> <1A><02> $<24>"'<27>$)<29> $<24>&'<27> )<29>N<EFBFBD>%=<3D>N<12> <15><12> <15><12>J<01><12>J<01>
)9<>VC<1E>J,<2C>+<2B>" r/rr )rOr<>c<00>N<00>tj|<00>sy|dk(rytjt|<00><00>tj|<01>z }|<02>)tj|tj
|<03><00>Stj|tj
|<03>|<02><04>S)z1Return True if *x* is an integer power of *base*.FrgTr<54>)r<><00>isfiniterZr<><00>iscloser)rYrOr<><00>lxs r-r<>r<><00>sq<00><00> <0A>;<3B>;<3B>q<EFBFBD>><3E><14><08>C<EFBFBD>x<EFBFBD><13> <0B><16><16><03>A<EFBFBD><06><1E>"<22>&<26>&<26><14>,<2C> &<26>B<EFBFBD> <0B>|<7C><11>z<EFBFBD>z<EFBFBD>"<22>b<EFBFBD>h<EFBFBD>h<EFBFBD>r<EFBFBD>l<EFBFBD>+<2B>+<2B><11>z<EFBFBD>z<EFBFBD>"<22>b<EFBFBD>h<EFBFBD>h<EFBFBD>r<EFBFBD>l<EFBFBD><14>6<>6r/c<00><><00>|dk(r|S|dkrt| |<01> S|tjtj|<00>tj|<01>z <00>zS)z<>
Return the largest integer power of *base* that's less or equal to *x*.
If *x* is negative, the exponent will be *greater*.
r)<04>_decade_greater_equalr<6C>rrZ<00>rYrOs r-<00>_decade_less_equalr<6C><00>sX<00><00> <13>a<EFBFBD><16>A<EFBFBD>8<>01<30>A<EFBFBD><05> "<22>A<EFBFBD>2<EFBFBD>t<EFBFBD> ,<2C> ,<2C>8<> <10>B<EFBFBD>H<EFBFBD>H<EFBFBD>R<EFBFBD>V<EFBFBD>V<EFBFBD>A<EFBFBD>Y<EFBFBD><12><16><16><04><1C>5<>6<> 6<>8r/c<00><><00>|dk(r|S|dkrt| |<01> S|tjtj|<00>tj|<01>z <00>zS)z<>
Return the smallest integer power of *base* that's greater or equal to *x*.
If *x* is negative, the exponent will be *smaller*.
r)r<>r<>r,rZr<>s r-r<>r<><00>sX<00><00> <13>a<EFBFBD><16>A<EFBFBD>7<>-.<2E><11>U<EFBFBD> <1F><11><02>D<EFBFBD> )<29> )<29>7<> <10>B<EFBFBD>G<EFBFBD>G<EFBFBD>B<EFBFBD>F<EFBFBD>F<EFBFBD>1<EFBFBD>I<EFBFBD><02><06><06>t<EFBFBD> <0C>4<>5<> 5<>7r/c<00>X<00>|dkrt| |<01> St||<01>}||k(r||z}|S)z<>
Return the largest integer power of *base* that's less than *x*.
If *x* is negative, the exponent will be *greater*.
r)<02>_decade_greaterr<72>)rYrO<00>lesss r-<00> _decade_lessr<73><00>s><00><00>  <09>1<EFBFBD>u<EFBFBD><1F><11><02>D<EFBFBD>)<29>)<29>)<29> <1D>a<EFBFBD><14> &<26>D<EFBFBD> <0B>q<EFBFBD>y<EFBFBD> <0C><04> <0C><04> <0F>Kr/c<00>X<00>|dkrt| |<01> St||<01>}||k(r||z}|S)z<>
Return the smallest integer power of *base* that's greater than *x*.
If *x* is negative, the exponent will be *smaller*.
r)r<>r<>)rYrO<00>greaters r-r<>r<> s><00><00>  <09>1<EFBFBD>u<EFBFBD><1C>a<EFBFBD>R<EFBFBD><14>&<26>&<26>&<26>#<23>A<EFBFBD>t<EFBFBD>,<2C>G<EFBFBD><0E>!<21>|<7C><0F>4<EFBFBD><0F><07> <12>Nr/c<00>@<00>tj|t|<00><00>Sr1)rr<>r<00>rYs r-rlrl s<00><00> <0F><<3C><<3C><01>5<EFBFBD><11>8<EFBFBD> $<24>$r/c<00>J<00>eZdZdZd dd<03>d<04>Zd dd<03>d<05>Zd<06>Zd<07>Zd<08>Zd <09>Z d
<EFBFBD>Z
y) rzd
Place logarithmically spaced ticks.
Places ticks at the values ``subs[j] * base**i``.
N)r=c<00><><00>|<03>tjdrd}nd}t|<01>|_|j |<02>||_y)a<>
Parameters
----------
base : float, default: 10.0
The base of the log used, so major ticks are placed at ``base**n``, where
``n`` is an integer.
subs : None or {'auto', 'all'} or sequence of float, default: (1.0,)
Gives the multiples of integer powers of the base at which to place ticks.
The default of ``(1.0, )`` places ticks only at integer powers of the base.
Permitted string values are ``'auto'`` and ``'all'``. Both of these use an
algorithm based on the axis view limits to determine whether and how to put
ticks between integer powers of the base:
- ``'auto'``: Ticks are placed only between integer powers.
- ``'all'``: Ticks are placed between *and* at integer powers.
- ``None``: Equivalent to ``'auto'``.
numticks : None or int, default: None
The maximum number of ticks to allow on a given axis. The default of
``None`` will try to choose intelligently as long as this Locator has
already been assigned to an axis using `~.axis.Axis.get_tick_space`, but
otherwise falls back to 9.
NrHr<>r<>)rsrtr*rS<00> _set_subsr=<00>r+rO<00>subsr=s r-r.zLogLocator.__init__! s?<00><00>, <14> <1B><12>|<7C>|<7C>4<>5<><1D><08>!<21><08><1A>4<EFBFBD>[<5B><04>
<EFBFBD> <0C><0E><0E>t<EFBFBD><1C> <20><04> r/c<00>b<00>|<01>t|<01>|_|<02>|j|<02>|<03>||_yyr.)r*rSr<>r=r<>s r-rzLogLocator.set_params@ s7<00><00> <0F> <1B><1E>t<EFBFBD><1B>D<EFBFBD>J<EFBFBD> <0F> <1B> <10>N<EFBFBD>N<EFBFBD>4<EFBFBD> <20> <13> <1F>$<24>D<EFBFBD>M<EFBFBD> r/c<00>r<00>|<01>d|_yt|t<00>rtjd|<01><04>||_y t j |t<00><05>|_|jjdk7r#td |jj<00>d
<EFBFBD><03><00>y#t$r}td|<01>d<07><03>|<02>d}~wwxYw) zT
Set the minor ticks for the log scaling every ``base**i*subs[j]``.
Nr<4E>)r<>r<>)r<>)<01>dtypez>subs must be None, 'all', 'auto' or a sequence of floats, not rxr'z5A sequence passed to subs must be 1-dimensional, not z -dimensional.)
<EFBFBD>_subsr<73>r<>rr<>r<>r(r*r<><00>ndim)r+r<>rs r-r<>zLogLocator._set_subsI s<><00><00> <10><<3C><1F>D<EFBFBD>J<EFBFBD> <17><04>c<EFBFBD> "<22> <10> <1E> <1E><EFBFBD>T<EFBFBD> :<3A><1D>D<EFBFBD>J<EFBFBD> 4<><1F>Z<EFBFBD>Z<EFBFBD><04>E<EFBFBD>:<3A><04>
<EFBFBD>
<14>z<EFBFBD>z<EFBFBD><EFBFBD><EFBFBD>!<21>#<23> <20>"7<>$(<28>J<EFBFBD>J<EFBFBD>O<EFBFBD>O<EFBFBD>#4<>M<EFBFBD>"C<01>D<01>D<01>$<24><> <1E> 4<> <20>"><3E>$(<28>6<EFBFBD><11>",<2C>-<2D>23<32>4<><34> 4<>s<00> B<00> B6<03>!B1<03>1B6c<00>`<00>|jj<00>\}}|j||<02>SrGrHr7s r-r[zLogLocator.__call__^ r%r/c<00><><00>|jdk(r?|j<00>0tj|jj <00>dd<03>}nd}n |j}|j
}|dkrK|j<00>|jj <00>}|dkstj|<01>s td<05><00>tjd||<02>||kr||}}tj|<01>tj|<04>z }tj|<02>tj|<04>z }tj|<06>tj|<05>z
}t|j t"<00>ro|dkDs|dkr;|j dk(rtj$g<00>Stj$d g<01>}n6|j dk(rd
nd } tj&| |<04>}n |j }t(j*d r%t-tj||d z
z <00>d <0C>n||zd z}
|
|k\rt-d |d z
<00>}
t/|<08>d kDxst/|<08>d k(xr|d d k7} tj&tj|<05>|
z
tj|<06>d|
zz|
<EFBFBD>} | rE|
d k(r*tj0|| zD<00> cgc]} || z<00><02> c} <0A>}ntj$g<00>}n|| z}tjd|<0E>t/|<08>d kDr;|
d k(r6||k||kzj3<00>d krt5<00>j7||<02>S|j9|<0E>Scc} w)Nr<4E>r<>rDrg<00>@Data has no positive values, and therefore cannot be log-scaled.zvmin %s vmax %sr r9r_r<>rHr'rz ticklocs %r)r=rMr<>r<>rFrSr=r<>r<>r<00>debugrrZrr,r<>r<>r<>r<>r]rsrtrr<>r<>r<>rr r)r+r8r9r=r<><00>log_vmin<69>log_vmaxr^r<><00>_first<73>stride<64> have_subs<62>decades<65> decade_startrKs r-r zLogLocator.tick_valuesc s<><00><00> <0F>=<3D>=<3D>F<EFBFBD> "<22><13>y<EFBFBD>y<EFBFBD>$<24><1D>7<EFBFBD>7<EFBFBD>4<EFBFBD>9<EFBFBD>9<EFBFBD>#;<3B>#;<3B>#=<3D>q<EFBFBD>!<21>D<><08><1C><08><1B>}<7D>}<7D>H<EFBFBD> <10>J<EFBFBD>J<EFBFBD><01> <0F>3<EFBFBD>;<3B><13>y<EFBFBD>y<EFBFBD>$<24><1B>y<EFBFBD>y<EFBFBD>+<2B>+<2B>-<2D><04><13>s<EFBFBD>{<7B>"<22>+<2B>+<2B>d<EFBFBD>"3<> <20>V<>X<01>X<01> <0A>
<EFBFBD>
<EFBFBD>$<24>d<EFBFBD>D<EFBFBD>1<> <0F>$<24>;<3B><1D>t<EFBFBD>$<24>D<EFBFBD><17>8<EFBFBD>8<EFBFBD>D<EFBFBD>><3E>D<EFBFBD>H<EFBFBD>H<EFBFBD>Q<EFBFBD>K<EFBFBD>/<2F><08><17>8<EFBFBD>8<EFBFBD>D<EFBFBD>><3E>D<EFBFBD>H<EFBFBD>H<EFBFBD>Q<EFBFBD>K<EFBFBD>/<2F><08><15><1A><1A>H<EFBFBD>%<25><04> <09> <09>(<28>(;<3B>;<3B><06> <15>d<EFBFBD>j<EFBFBD>j<EFBFBD>#<23> &<26><15><02>{<7B>a<EFBFBD>!<21>e<EFBFBD><17>:<3A>:<3A><16>'<27><1D>8<EFBFBD>8<EFBFBD>B<EFBFBD><<3C>'<27><1D>8<EFBFBD>8<EFBFBD>S<EFBFBD>E<EFBFBD>?<3F>D<EFBFBD> $<24>
<EFBFBD>
<EFBFBD>f<EFBFBD> 4<><13>#<23><06><19>y<EFBFBD>y<EFBFBD><16><11>+<2B><04><17>:<3A>:<3A>D<EFBFBD><19>\<5C>\<5C>":<3A>;<3B><16>d<EFBFBD>i<EFBFBD>i<EFBFBD><06>(<28>Q<EFBFBD>,<2C> 7<>8<>!<21><<3C><18>H<EFBFBD>$<24>q<EFBFBD>(<28> <0F> <12>V<EFBFBD> <1B><18><11>F<EFBFBD>Q<EFBFBD>J<EFBFBD>'<27>F<EFBFBD><18><04>I<EFBFBD><01>M<EFBFBD>H<>c<EFBFBD>$<24>i<EFBFBD>1<EFBFBD>n<EFBFBD>&G<><14>a<EFBFBD><17>C<EFBFBD><1E> <09><14>)<29>)<29>D<EFBFBD>J<EFBFBD>J<EFBFBD>x<EFBFBD>0<>6<EFBFBD>9<> <20>I<EFBFBD>I<EFBFBD>h<EFBFBD>/<2F>!<21>f<EFBFBD>*<2A><<3C>f<EFBFBD>F<01><07> <15><15><11>{<7B><1D>><3E>><3E>=><3E>'<27>\<5C>J<>\<5C>T<EFBFBD>L<EFBFBD>(<28>J<>L<01><08><1E>8<EFBFBD>8<EFBFBD>B<EFBFBD><<3C><08><18>G<EFBFBD>|<7C>H<EFBFBD> <0C>
<EFBFBD>
<EFBFBD>=<3D>(<28>+<2B> <0F><04>I<EFBFBD><01>M<EFBFBD><1A>a<EFBFBD>K<EFBFBD><1A>h<EFBFBD>&<26>8<EFBFBD>t<EFBFBD>+;<3B><<3C>A<>A<>C<>q<EFBFBD>H<><1F>=<3D>,<2C>,<2C>T<EFBFBD>4<EFBFBD>8<> 8<><17>(<28>(<28><18>2<> 2<><32>Ks<00> M+c<00><><00>|j}|j||<02>\}}tjddk(rt ||<03>}t ||<03>}||fS<00>rMrNrO)rSrnrsrtr<>r<><00>r+r8r9r<>s r-rzLogLocator.view_limits<74> sU<00><00> <10>J<EFBFBD>J<EFBFBD><01><19>%<25>%<25>d<EFBFBD>D<EFBFBD>1<>
<EFBFBD><04>d<EFBFBD> <0E><<3C><<3C>-<2D> .<2E>/<2F> A<>%<25>d<EFBFBD>A<EFBFBD>.<2E>D<EFBFBD>(<28><14>q<EFBFBD>1<>D<EFBFBD><13>T<EFBFBD>z<EFBFBD>r/c<00><><00>||kDr||}}tj|<01>rtj|<02>s d\}}||fS|dkrtjd<03>d\}}||fSt d<04>|j
j <00>D<00><00>}tj|<03>sd}|dkr|}||k(r,t||j<00>}t||j<00>}||fS)N)r'r rr<>c3<00><K<00>|]}|j<00><00><01><00>y<00>wr1)r=)r<>rMs r-r<>z)LogLocator.nonsingular.<locals>.<genexpr><3E> s<00><00><><00>T<>t<EFBFBD><14><1F><1F>*<2A>T<>s<00>gY<67><59><EFBFBD>n<>)
r<EFBFBD>r<>rr<>r)rM<00>_get_shared_axisr<73>rSr<>)r+r8r9r,s r-rnzLogLocator.nonsingular<61> s<><00><00> <0F>$<24>;<3B><1D>t<EFBFBD>$<24>D<EFBFBD><11>{<7B>{<7B>4<EFBFBD> <20><02> <0B> <0B>D<EFBFBD>(9<><1E>J<EFBFBD>D<EFBFBD>$<24> <14>T<EFBFBD>z<EFBFBD><19><12>Q<EFBFBD>Y<EFBFBD> <10> <1E> <1E><1E> <1F><1F>J<EFBFBD>D<EFBFBD>$<24><14>T<EFBFBD>z<EFBFBD><19><19>T<>t<EFBFBD>y<EFBFBD>y<EFBFBD>7Q<37>7Q<37>7S<37>T<>T<>F<EFBFBD><15>;<3B>;<3B>v<EFBFBD>&<26><1F><06><13>q<EFBFBD>y<EFBFBD><1D><04><13>t<EFBFBD>|<7C>#<23>D<EFBFBD>$<24>*<2A>*<2A>5<><04>&<26>t<EFBFBD>T<EFBFBD>Z<EFBFBD>Z<EFBFBD>8<><04><13>T<EFBFBD>z<EFBFBD>r/)r<>)r_r') rHrIrJr{r.rr<>r[r rrnrEr/r-rr s;<00><00><08> !<21>4<EFBFBD>!<21>>%<25>4<EFBFBD>%<25>D<01>*,<2C>
L3<>\
<1A>r/rc<00>2<00>eZdZdZdd<03>Zd d<04>Zd<05>Zd<06>Zd<07>Zy)
r z^
Place ticks spaced linearly near zero and spaced logarithmically beyond a threshold.
Nc<00><><00>|<01>#|j|_|j|_n|<03>|<04>||_||_n t d<02><00>|<02>dg|_d|_y||_d|_y)a<>
Parameters
----------
transform : `~.scale.SymmetricalLogTransform`, optional
If set, defines the *base* and *linthresh* of the symlog transform.
base, linthresh : float, optional
The *base* and *linthresh* of the symlog transform, as documented
for `.SymmetricalLogScale`. These parameters are only used if
*transform* is not set.
subs : sequence of float, default: [1]
The multiples of integer powers of the base where ticks are placed,
i.e., ticks are placed at
``[sub * base**i for i in ... for sub in subs]``.
Notes
-----
Either *transform*, or both *base* and *linthresh*, must be given.
Nz?Either transform, or both linthresh and base, must be provided.r_r<>)rOrSrQrNr<>r<>r=)r+rr<>rQrOs r-r.zSymmetricalLogLocator.__init__<5F> st<00><00>& <15> <20>"<22><1E><1E>D<EFBFBD>J<EFBFBD>'<27>1<>1<>D<EFBFBD>O<EFBFBD> <16> "<22>t<EFBFBD>'7<><1D>D<EFBFBD>J<EFBFBD>'<27>D<EFBFBD>O<EFBFBD><1C>;<3B><<3C> <<3C> <0F><<3C><1D><15>D<EFBFBD>J<EFBFBD><1B><04> <0A><1E>D<EFBFBD>J<EFBFBD><1A><04> r/c<00>*<00>|<02>||_|<01>||_yyr.)r=r<>)r+r<>r=s r-rz SymmetricalLogLocator.set_params<6D> s!<00><00> <13> <1F>$<24>D<EFBFBD>M<EFBFBD> <0F> <1B><1D>D<EFBFBD>J<EFBFBD> r/c<00>`<00>|jj<00>\}}|j||<02>SrGrHr7s r-r[zSymmetricalLogLocator.__call__
s-<00><00><1A>Y<EFBFBD>Y<EFBFBD>0<>0<>2<>
<EFBFBD><04>d<EFBFBD><13><1F><1F><04>d<EFBFBD>+<2B>+r/c <00><><00><14>|j}||kr||}}| |cxkr |cxkr|krnnt|d|h<03>S|| k}||kD}|xr|| kDxs |xr||k}|j<00><14>fd<02>}d\}} |r.t| |<02>}
|t |
<EFBFBD>t |<01>dz<00>\}} d\} } |rt ||<01>} || |dz<00>\} } | |z
| | z
z}|r|dz }t ||j dz
zd<04>}g}|r2|jd<05>tj|| |<0F>ddd<05>zz<00>|r|jd<06>|r)|j<00>tj| | |<0F>z<00>tj|j<00>}t|<11>dkDs|ddk7r5g}|D]-}|dk(r|j|<13><00>|j||z<00><00>/n|}|jtj|<12><00>S)Nrc<00><00><01>tjtj|<00>tj<00><02>z <00>}tjtj|<01>tj<00><02>z <00>}||fSr1)r<>rrZr,)<03>lo<6C>hirOs <20>r-<00> get_log_rangez8SymmetricalLogLocator.tick_values.<locals>.get_log_range/
sR<00><><00><13><18><18>"<22>&<26>&<26><12>*<2A>r<EFBFBD>v<EFBFBD>v<EFBFBD>d<EFBFBD>|<7C>3<>4<>B<EFBFBD><13><17><17><12><16><16><02><1A>b<EFBFBD>f<EFBFBD>f<EFBFBD>T<EFBFBD>l<EFBFBD>2<>3<>B<EFBFBD><15>r<EFBFBD>6<EFBFBD>Mr/rIr'r<>rgr_)rNr'rSr)r<>rr=<00>extendr<64>r]<00>appendr(r<>r<>rr<>)r+r8r9rQ<00>has_a<5F>has_c<5F>has_br<62><00>a_lo<6C>a_hi<68> a_upper_lim<69>c_lo<6C>c_hi<68> c_lower_lim<69> total_ticksr<73>r<>r<>rK<00>decaderOs @r-r z!SymmetricalLogLocator.tick_values
s <00><><00><18>O<EFBFBD>O<EFBFBD> <09> <0F>$<24>;<3B><1D>t<EFBFBD>$<24>D<EFBFBD>* <16>:<3A><14> 1<><04> 1<> <09> 1<><19>4<EFBFBD><11>D<EFBFBD>/<2F>*<2A> *<2A><16><19>
<EFBFBD>"<22><05><15> <09>!<21><05><17>,<2C>4<EFBFBD>9<EFBFBD>*<2A>,<2C>M<>%<25>2L<32>D<EFBFBD>9<EFBFBD><L<><05><13>z<EFBFBD>z<EFBFBD><04> <1A> <1C>
<EFBFBD><04>d<EFBFBD> <10><1D>y<EFBFBD>j<EFBFBD>$<24>/<2F>K<EFBFBD>&<26>s<EFBFBD>;<3B>'7<><13>T<EFBFBD><19>Q<EFBFBD><1D>G<>J<EFBFBD>D<EFBFBD>$<24><1B>
<EFBFBD><04>d<EFBFBD> <10><1D>i<EFBFBD><14>.<2E>K<EFBFBD>&<26>{<7B>D<EFBFBD>1<EFBFBD>H<EFBFBD>=<3D>J<EFBFBD>D<EFBFBD>$<24><1C>d<EFBFBD>{<7B>t<EFBFBD>d<EFBFBD>{<7B>3<> <0B> <10> <17>1<EFBFBD> <1C>K<EFBFBD><14>[<5B>T<EFBFBD>]<5D>]<5D>Q<EFBFBD>%6<>7<><11>;<3B><06><14><07> <10> <13>N<EFBFBD>N<EFBFBD>2<EFBFBD><14>"<22>)<29>)<29>D<EFBFBD>$<24>4:<3A>+<<3C><@<40>b<EFBFBD>D<EFBFBD>+B<01>"C<01>D<01> E<01> <11> <13>N<EFBFBD>N<EFBFBD>3<EFBFBD> <1F> <10> <13>N<EFBFBD>N<EFBFBD>4<EFBFBD>B<EFBFBD>I<EFBFBD>I<EFBFBD>d<EFBFBD>D<EFBFBD>&<26>$A<>B<> C<><11>z<EFBFBD>z<EFBFBD>$<24>*<2A>*<2A>%<25><04> <0E>t<EFBFBD>9<EFBFBD>q<EFBFBD>=<3D>D<EFBFBD><11>G<EFBFBD>s<EFBFBD>N<EFBFBD><19>H<EFBFBD>!<21> 3<><06><19>Q<EFBFBD>;<3B><1C>O<EFBFBD>O<EFBFBD>F<EFBFBD>+<2B><1C>O<EFBFBD>O<EFBFBD>D<EFBFBD>6<EFBFBD>M<EFBFBD>2<>  3<> <1F>H<EFBFBD><13>$<24>$<24>R<EFBFBD>X<EFBFBD>X<EFBFBD>h<EFBFBD>%7<>8<>8r/c<00><><00>|j}||kr||}}tjddk(r5t||<03>}t ||<03>}||k(rt ||<03>}t ||<03>}tj||<02>Sr<>) rSrsrtr<>r<>r<>r<>rmrnr<>s r-rz!SymmetricalLogLocator.view_limits^
sw<00><00> <10>J<EFBFBD>J<EFBFBD><01> <0F>$<24>;<3B><1D>t<EFBFBD>$<24>D<EFBFBD> <0E><<3C><<3C>-<2D> .<2E>/<2F> A<>%<25>d<EFBFBD>A<EFBFBD>.<2E>D<EFBFBD>(<28><14>q<EFBFBD>1<>D<EFBFBD><13>t<EFBFBD>|<7C>#<23>D<EFBFBD>!<21>,<2C><04>&<26>t<EFBFBD>Q<EFBFBD>/<2F><04><1A>&<26>&<26>t<EFBFBD>T<EFBFBD>2<>2r/<00>NNNNr'r`rEr/r-r r <00> s#<00><00><08> <1B>D<1E>,<2C> T9<>l 3r/r c<00>@<00><00>eZdZdZ d<06>fd<02> Z dd<03>Zd<04>Zd<05>Z<07>xZS)r!z<>
Place ticks spaced evenly on an inverse-sinh scale.
Generally used with the `~.scale.AsinhScale` class.
.. note::
This API is provisional and may be revised in the future
based on early user feedback.
c<00>h<00><01>t<00>|<00><00>||_||_||_||_||_y)a<>
Parameters
----------
linear_width : float
The scale parameter defining the extent
of the quasi-linear region.
numticks : int, default: 11
The approximate number of major ticks that will fit
along the entire axis
symthresh : float, default: 0.2
The fractional threshold beneath which data which covers
a range that is approximately symmetric about zero
will have ticks that are exactly symmetric.
base : int, default: 10
The number base used for rounding tick locations
on a logarithmic scale. If this is less than one,
then rounding is to the nearest integer multiple
of powers of ten.
subs : tuple, default: None
Multiples of the number base, typically used
for the minor ticks, e.g. (2, 5) when base=10.
N)r<>r.<00> linear_widthr=<00> symthreshrOr<>)r+r<>r=r<>rOr<>r<>s <20>r-r.zAsinhLocator.__init__y
s4<00><><00>0 <0E><07><18><1A>(<28><04><19> <20><04> <0A>"<22><04><0E><18><04> <09><18><04> r/c<00>n<00>|<01>||_|<02>||_|<03>||_|<04>t|<04>dkDr|nd|_yy)r/Nr)r=r<>rOr<>r<>)r+r=r<>rOr<>s r-rzAsinhLocator.set_params<6D>
sI<00><00> <14> <1F>$<24>D<EFBFBD>M<EFBFBD> <14> <20>&<26>D<EFBFBD>N<EFBFBD> <0F> <1B><1C>D<EFBFBD>I<EFBFBD> <0F> <1B> #<23>D<EFBFBD> <09>A<EFBFBD> <0A><04>4<EFBFBD>D<EFBFBD>I<EFBFBD> r/c<00><00>|jj<00>\}}||zdkrOtd||z z<00>|jkr1t t|<01>t|<02><00>}|j | |<03>S|j ||<02>Sr6)rMr4r<>r<>rr )r+r8r9<00>bounds r-r[zAsinhLocator.__call__<5F>
sx<00><00><19>Y<EFBFBD>Y<EFBFBD>0<>0<>2<>
<EFBFBD><04>d<EFBFBD> <10>4<EFBFBD>K<EFBFBD>1<EFBFBD> <1C><13>Q<EFBFBD><14><04><1B>_<EFBFBD>!5<><04><0E><0E>!F<><17><03>D<EFBFBD> <09>3<EFBFBD>t<EFBFBD>9<EFBFBD>-<2D>E<EFBFBD><17>#<23>#<23>U<EFBFBD>F<EFBFBD>E<EFBFBD>2<> 2<><17>#<23>#<23>D<EFBFBD>$<24>/<2F> /r/c <00><00>|jtjtj||g<02>|jz <00>z\}}tj|||j
<00>}t |||z
z <00>}||zdkr*tj||d|j
z kDdg<02>}|jtj||jz <00>z}|dk(}tjd<04><05>5|jdkDr<>tj|<07>|jtjtjt |<07><00>tj|j<00>z <00>zz} |jr.tj | |j<00>j#<00>n| }
ndtj$|ddtjtj&t |<07><00><00>z<00>} | tj(|| z <00>z}
ddd<00>tjt+t-
<EFBFBD><00><00>} t/| <0B>dk\r| Stj|||j
<00>S#1swY<00>axYw) Nrr<>rg<00>ignore)<01>divider'r r<>)r<>r<><00>arcsinhr<68>rJr=r<><00>hstack<63>sinh<6E>errstaterOr2rrZrr<><00>outer<65>flatten<65>whererrr'r\r<>) r+r8r9<00>ymin<69>ymax<61>ys<79>zero_dev<65>xs<78>zero_xs<78>pows<77>qsr6s r-r zAsinhLocator.tick_values<65>
s<><00><00><19>&<26>&<26><12><1A><1A>B<EFBFBD>H<EFBFBD>H<EFBFBD>d<EFBFBD>D<EFBFBD>\<5C>4J<34>6:<3A>6G<36>6G<36>5H<01>*I<01>I<01>
<EFBFBD><04>d<EFBFBD> <0F>[<5B>[<5B><14>t<EFBFBD>T<EFBFBD>]<5D>]<5D> 3<><02><16>r<EFBFBD>T<EFBFBD>D<EFBFBD>[<5B>)<29>*<2A><08> <0F>$<24>;<3B><11>?<3F><13><19><19>B<EFBFBD><08>3<EFBFBD><14><1D><1D>+><3E> ><3E>@<40>#<23>F<>G<>B<EFBFBD><12> <1E> <1E><12><17><17><12>d<EFBFBD>.?<3F>.?<3F>)?<3F>!@<40> @<40><02><15><11>7<EFBFBD><07><10>[<5B>[<5B><08> )<29> 0<><13>y<EFBFBD>y<EFBFBD>1<EFBFBD>}<7D><1A><07><07><02> <0B><1E>)<29>)<29>r<EFBFBD>x<EFBFBD>x<EFBFBD><02><06><06>s<EFBFBD>2<EFBFBD>w<EFBFBD><0F>$<24>(<28>(<28>4<EFBFBD>9<EFBFBD>9<EFBFBD>BU<42>0U<30>'V<>V<>W<01><04><@<40>I<EFBFBD>I<EFBFBD>R<EFBFBD>X<EFBFBD>X<EFBFBD>d<EFBFBD>D<EFBFBD>I<EFBFBD>I<EFBFBD>.<2E>6<>6<>8<>4<EFBFBD><02><19>x<EFBFBD>x<EFBFBD><07><11>B<EFBFBD><02><08><08><12><18><18>#<23>b<EFBFBD>'<27>9J<39>0K<30>,K<>L<><04><19>B<EFBFBD>H<EFBFBD>H<EFBFBD>R<EFBFBD>$<24>Y<EFBFBD>/<2F>/<2F><02> 0<><13><08><08><16><03>B<EFBFBD><07><1F>)<29><05><1B>E<EFBFBD>
<EFBFBD>a<EFBFBD><0F>u<EFBFBD>S<>R<EFBFBD>[<5B>[<5B><14>t<EFBFBD>T<EFBFBD>]<5D>]<5D>-S<>S<> 0<> 0<>s <00>6D%I;<03>;J)rAg<><67><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>?r Nr<4E>) rHrIrJr{r.rr[r r<>r<>s@r-r!r!n
s.<00><><00> <08>=@<01>#<23><19>>37<33>#'<27>
8<>0<>Tr/r!c<00>z<00><00>eZdZdZd
dd<03><01>fd<04> Zd <0B>fd<05> Zed<06><00>Zejd<07><00>Z<07>fd<08>Z d <09>Z
<EFBFBD>xZ S) r"z5
Place ticks spaced evenly on a logit scale.
r<>r0c<00>:<00><01>||_t<00>|<00> |gd<01><01><02>y)z<>
Parameters
----------
nbins : int or 'auto', optional
Number of ticks. Only used if minor is False.
minor : bool, default: False
Indicate if this locator is for minor ticks or not.
<20>r'r<>r<>r <00>r,rsN)r<>r<>r.)r+r<>r,r<>s <20>r-r.zLogitLocator.__init__<5F>
s<00><><00><1C><04> <0B> <0A><07><18>u<EFBFBD>M<EFBFBD><18>:r/c <00>6<00><01>|<01>||_t<00>|<00>di|<02><01>y)r/NrE)r<>r<>r)r+r<>rQr<>s <20>r-rzLogitLocator.set_params<6D>
s <00><><00> <10> <1C><1F>D<EFBFBD>K<EFBFBD> <0A><07><1A>$<24>V<EFBFBD>$r/c<00><00>|jSr1)r<>r3s r-r<>zLogitLocator.minor<6F>
s <00><00><13>{<7B>{<7B>r/c<00>(<00>|j|<01><01>y)N)r<>)rrds r-r<>zLogitLocator.minor<6F>
s<00><00> <0C><0F><0F>e<EFBFBD><0F>$r/c<00>N<00><01>t|jd<01>r.|jjjdk(r t d<03><00>|j
dk(r1|j<00>"|jj <00>}|dkrd}nd}n |j
}d<07>}|j||<02>\}}t|dkr(tjtj|<01><00>n2|d krd
n+tjtjd |z
<00><00> <00>}t|dkr(tjtj|<02><00>n2|d krd n+tjtjd |z
<00><00> <00>}||z
d z
}|dk\<00>r<>||kDr<>tj||z <00>}|jr+t||d z<00>D<00> cgc]} | |zd
k7r|| <09><00><02>}
} n*t||d z<00>D<00> cgc]} | |zd
k(r|| <09><00><02>}
} |j!tj"|
<EFBFBD><00>S|jr<>g}
t||<06>D]<5D>} | d kr,|
j%tj&dd <0A>d | zz<00><00>4| d k(r)|
j%tj&dd<0E>d z <00><00>b| d
k(r)|
j%tj&dd<06>d z <00><00><>|
j%d tj&dd <0A>ddd <0C>d | d z
zzz
<00><00><>|j!tj"|
<EFBFBD><00>St||d z<00>D<00> cgc]
} || <09><00><02> }
} |j!tj"|
<EFBFBD><00>S|jrgSt(<00> |<00>U||<02>Scc} wcc} wcc} w)Nr<4E><00>polarz%Polar axis cannot be logit scaled yetr<74>r<>rDc<00>6<00>|dkrd|zS|dkDr dd| zz
SdS)Nrr r'r<>rEr<>s r-<00> ideal_ticksz-LogitLocator.tick_values.<locals>.ideal_ticks<6B>
s-<00><00><1F>!<21>e<EFBFBD>2<EFBFBD><11>7<EFBFBD> K<>Q<EFBFBD><11>U<EFBFBD><11>b<EFBFBD>a<EFBFBD>R<EFBFBD>j<EFBFBD>)9<> K<><03> Kr/r<>r<>rr'r<>r r<>r<>)r<>rMr<>r<>rWr<>rFrnr?r<>rrr,rr<>r<>rr<>r<>r]r<>r ) r+r8r9r,r<00>binf<6E>bsup<75>numideal<61>subsampling_factorr<72>rKr<>s <20>r-r zLogitLocator.tick_values<65>
sO<00><><00> <12>4<EFBFBD>9<EFBFBD>9<EFBFBD>f<EFBFBD> %<25>$<24>)<29>)<29>.<2E>.<2E>*=<3D>*=<3D><17>*H<>%<25>&M<>N<> N<> <0F>;<3B>;<3B>&<26> <20><13>y<EFBFBD>y<EFBFBD>$<24><1C> <09> <09>0<>0<>2<><05><18>1<EFBFBD>9<EFBFBD><1D>E<EFBFBD><19><05><18>K<EFBFBD>K<EFBFBD>E<EFBFBD>
 L<01><1A>%<25>%<25>d<EFBFBD>D<EFBFBD>1<>
<EFBFBD><04>d<EFBFBD><12><13>c<EFBFBD>z<EFBFBD> <0F>H<EFBFBD>H<EFBFBD>R<EFBFBD>X<EFBFBD>X<EFBFBD>d<EFBFBD>^<5E> $<24><14>c<EFBFBD>z<EFBFBD><13><14>'<27>'<27>"<22>(<28>(<28>1<EFBFBD>t<EFBFBD>8<EFBFBD>,<2C>-<2D>-<2D> 
<EFBFBD><04><13><13>s<EFBFBD>{<7B> <0F>G<EFBFBD>G<EFBFBD>B<EFBFBD>H<EFBFBD>H<EFBFBD>T<EFBFBD>N<EFBFBD> #<23><14>s<EFBFBD>{<7B><13><14>(<28>(<28>2<EFBFBD>8<EFBFBD>8<EFBFBD>A<EFBFBD><04>H<EFBFBD>-<2D>.<2E>.<2E> 
<EFBFBD><04><18>$<24>;<3B><11>?<3F><08> <13>q<EFBFBD>=<3D><17>%<25><1F>&*<2A>Y<EFBFBD>Y<EFBFBD>x<EFBFBD>%<25>/?<3F>%@<40>"<22><17>;<3B>;<3B>"'<27>t<EFBFBD>T<EFBFBD>A<EFBFBD>X<EFBFBD>!6<> <16><1D><1D> 2<>2<>q<EFBFBD>8<>$<24>A<EFBFBD><0E> <16>H<EFBFBD> <16>"'<27>t<EFBFBD>T<EFBFBD>A<EFBFBD>X<EFBFBD>!6<> <16><1D><1D> 2<>2<>q<EFBFBD>8<>$<24>A<EFBFBD><0E> <16>H<EFBFBD> <16>
<1C>,<2C>,<2C>R<EFBFBD>X<EFBFBD>X<EFBFBD>h<EFBFBD>-?<3F>@<40>@<40><13>{<7B>{<7B><1D><08><1E>t<EFBFBD>T<EFBFBD>*<2A>
<1A>A<EFBFBD><18>2<EFBFBD>v<EFBFBD> <20><0F><0F><02> <09> <09>!<21>R<EFBFBD>(8<>2<EFBFBD><11>7<EFBFBD>(B<>C<><1A>b<EFBFBD><17> <20><0F><0F><02> <09> <09>!<21>Q<EFBFBD><0F>"<22>(<<3C>=<3D><1A>a<EFBFBD><16> <20><0F><0F><02> <09> <09>!<21>Q<EFBFBD><0F>"<22>(<<3C>=<3D> <20><0F><0F><1D><02> <09> <09>!<21>R<EFBFBD> 0<><14>2<EFBFBD><14> 6<><12><11><02>Q<EFBFBD><06><1E> G<>G<><1A>
<1A><1C>,<2C>,<2C>R<EFBFBD>X<EFBFBD>X<EFBFBD>h<EFBFBD>-?<3F>@<40>@<40>05<30>d<EFBFBD>D<EFBFBD>1<EFBFBD>H<EFBFBD>0E<30>F<>1<EFBFBD> <0B>A<EFBFBD><0E>F<>H<EFBFBD>F<><17>(<28>(<28><12><18><18>(<28>);<3B><<3C> <<3C> <0F>;<3B>;<3B><15>I<EFBFBD><14>w<EFBFBD>"<22>4<EFBFBD><14>.<2E>.<2E><>? <16><>  <16><>(Gs<00>N<04>/N<04>N"c<00><><00>d}|d|z
f}||kDr||}}tj|<01>rtj|<02>s |\}}||fS|dks|dk\rtjd<04>|\}}||fS|j<00>|jj <00>n|}tj|<05>s|}|dkr|}|dk\rd|z
}||k(r d|zdd|zz
}}||fS)Nr<4E>r'rzIData has no values between 0 and 1, and therefore cannot be logit-scaled.r<>)r<>r<>rr<>rMr=)r+r8r9<00>standard_minpos<6F> initial_ranger,s r-rnzLogitLocator.nonsingular7 s
<00><00><1E><0F>(<28>!<21>o<EFBFBD>*=<3D>><3E> <0A> <0F>$<24>;<3B><1D>t<EFBFBD>$<24>D<EFBFBD><11>{<7B>{<7B>4<EFBFBD> <20><02> <0B> <0B>D<EFBFBD>(9<>&<26>J<EFBFBD>D<EFBFBD>$<24>8<14>T<EFBFBD>z<EFBFBD><19>7<12>Q<EFBFBD>Y<EFBFBD>$<24>!<21>)<29> <11> <1E> <1E> <20> <0E>'<27>J<EFBFBD>D<EFBFBD>$<24>(<14>T<EFBFBD>z<EFBFBD><19>!<18>9<EFBFBD>9<EFBFBD>(<28><15> <09> <09>$<24>$<24>&<26>$<24> <13>
<16>;<3B>;<3B>v<EFBFBD>&<26>(<28><06><13>q<EFBFBD>y<EFBFBD><1D><04>
<14>q<EFBFBD>y<EFBFBD><18>6<EFBFBD>z<EFBFBD><04><13>t<EFBFBD>|<7C> <20>4<EFBFBD>Z<EFBFBD><11>S<EFBFBD>4<EFBFBD>Z<EFBFBD><1E>d<EFBFBD><04><13>T<EFBFBD>z<EFBFBD>r/)Fr1) rHrIrJr{r.rrEr<>rr rnr<>r<>s@r-r"r"<00>
sQ<00><><00><08> ;<3B>V<EFBFBD> ;<3B>%<25> <0E><1B><0E><1B> <0B>\<5C>\<5C>%<25><12>%<25>K/<2F>Z"r/r"c<00>"<00><00>eZdZdZ<03>fd<02>Z<04>xZS)rz<>
Place evenly spaced ticks, with the step size and maximum number of ticks chosen
automatically.
This is a subclass of `~matplotlib.ticker.MaxNLocator`, with parameters
*nbins = 'auto'* and *steps = [1, 2, 2.5, 5, 10]*.
c<00>h<00><01>tjdrd}gd<03>}nd}gd<05>}t<00>|<00> ||<02><06>y)z<>
To know the values of the non-public parameters, please have a
look to the defaults of `~matplotlib.ticker.MaxNLocator`.
rHrDr r<>)r'r<>r<>r<>r rN)rsrtr<>r.)r+r,rsr<>s <20>r-r.zAutoLocator.__init__d s8<00><><00>
<0F><<3C><<3C>0<> 1<><15>E<EFBFBD>!<21>E<EFBFBD><1A>E<EFBFBD>&<26>E<EFBFBD> <0A><07><18>u<EFBFBD>E<EFBFBD><18>2r/)rHrIrJr{r.r<>r<>s@r-rr\ s<00><><00><08> 3<> 3r/rc<00>$<00>eZdZdZdd<03>Zd<04>Zd<05>Zy)rz<>
Place evenly spaced minor ticks, with the step size and maximum number of ticks
chosen automatically.
The Axis must use a linear scale and have evenly spaced major ticks.
Nc<00><00>||_y)aG
Parameters
----------
n : int or 'auto', default: :rc:`xtick.minor.ndivs` or :rc:`ytick.minor.ndivs`
The number of subdivisions of the interval between major ticks;
e.g., n=2 will place a single minor tick midway between major ticks.
If *n* is 'auto', it will be set to 4 or 5: if the distance
between the major ticks equals 1, 2.5, 5 or 10 it can be perfectly
divided in 5 equidistant sub-intervals with a length multiple of
0.05; otherwise, it is divided in 4 sub-intervals.
N)<01>ndivs)r+r4s r-r.zAutoMinorLocator.__init__z s <00><00><17><04>
r/c<00>><00>|jj<00>dk(rtjd<02>gSt j
|jj <00><00>}t|<01>dkrgS|d|dz
}|j<00>3tj|jjdk(rdnd|_|jd k(rFd
t j|<02>dzz}t j|gd <0B><01>j<00>rd nd }n |j}||z }t|jj!<00><00>\}}|d}t#||z
|z <00>} t#||z
|z <00>dz}
t j$| |
<EFBFBD>|z|z} |j'| <0B>S)NrZz4AutoMinorLocator does not work on logarithmic scalesr<73>r'rr<>zytick.minor.ndivszxtick.minor.ndivsr<73>r )r'r<>r<>r r<>r<>)rM<00> get_scalerr<>r<><00>unique<75>get_majorticklocsr<73>r!rsrt<00> axis_namerr<>r|r'r4rr]r) r+<00> majorlocs<63> majorstep<65>majorstep_mantissar!<00> minorstepr8r9<00>t0<74>tmin<69>tmaxros r-r[zAutoMinorLocator.__call__<5F> sp<00><00> <0F>9<EFBFBD>9<EFBFBD> <1E> <1E> <20>E<EFBFBD> )<29> <10> <1E> <1E>U<> V<><15>I<EFBFBD><16>I<EFBFBD>I<EFBFBD>d<EFBFBD>i<EFBFBD>i<EFBFBD>9<>9<>;<3B><<3C> <09> <0E>y<EFBFBD>><3E>A<EFBFBD> <1D><16>I<EFBFBD><1D>a<EFBFBD>L<EFBFBD>9<EFBFBD>Q<EFBFBD><<3C>/<2F> <09> <0F>:<3A>:<3A> <1D><1C><1C><1C>'+<2B>y<EFBFBD>y<EFBFBD>':<3A>':<3A>c<EFBFBD>'A<>#<23>(<28>*<2A>D<EFBFBD>J<EFBFBD> <10>:<3A>:<3A><16> <1F>!#<23><02><08><08><19>(;<3B>a<EFBFBD>(?<3F>!@<40> <1E><1B><1A><1A>$6<><0F>H<>L<>L<>N<>A<EFBFBD>TU<54>E<EFBFBD><18>J<EFBFBD>J<EFBFBD>E<EFBFBD><1D><05>%<25> <09><1B>D<EFBFBD>I<EFBFBD>I<EFBFBD>7<>7<>9<>:<3A>
<EFBFBD><04>d<EFBFBD> <16>q<EFBFBD>\<5C><02><14>d<EFBFBD>R<EFBFBD>i<EFBFBD>9<EFBFBD>,<2C>-<2D><04><14>d<EFBFBD>R<EFBFBD>i<EFBFBD>9<EFBFBD>,<2C>-<2D><01>1<><04><12> <09> <09>$<24><04>%<25> <09>1<>R<EFBFBD>7<><04><13>$<24>$<24>T<EFBFBD>*<2A>*r/c<00>D<00>tdt|<00>j<00><00><02><00>)Nz Cannot get tick locations for a )rWr rHr7s r-r zAutoMinorLocator.tick_values<65> s&<00><00>!<21>.<2E>t<EFBFBD>D<EFBFBD>z<EFBFBD>/B<>/B<>.C<> D<>F<01> Fr/r1)rHrIrJr{r.r[r rEr/r-rrr s<00><00><08> <17>!+<2B>FFr/r)r'r):r{r.<00>loggingr<67>r<00>numbersr<00>string<6E>numpyr<79>r<>rsrrrrm<00> getLoggerrHr<00>__all__r$rrr
r r r r<>r rrrrrrrrrrrrrrrerVrr<>r<>r<>r<>r<>rlrr r!r"rrrEr/r-<00><module>r5s<00><01>B<04>H<11><0E> <0A> <0B><1C> <0A><12><18>"<22>0<><18>w<EFBFBD><18><18><18>"<22><04> D<01><07><11><11>8-<2D>-<2D>= <0A>
<EFBFBD>= <0A>@<12>I<EFBFBD><12>!<21>Y<EFBFBD>!<21>D!<21>I<EFBFBD>!<21>8<1C><19><1C>0 M<01>&<26>*<2A>*<2A> M<01>D<01><19>D<01>8E><3E>i<EFBFBD>E><3E>PN<11>9<EFBFBD>N<11>b <11><<3C> <11>,J<01><<3C>,J<01>^ 3<>2<> 3<> A"<22>Y<EFBFBD>A"<22>HH+<2B>?<3F>H+<2B>Vk<1E>y<EFBFBD>k<1E>\W3<>j<EFBFBD>W3<>tA<01>7<EFBFBD>A<01>:*,<2C>7<EFBFBD>*,<2C>Z<12>'<27><12>(N3<>G<EFBFBD>N3<>bC3<>g<EFBFBD>C3<>L<19>,<15>,<15>^Z<1E>'<27>Z<1E>z<1D>4<EFBFBD>
7<>8<>7<> <10> <13>%<25>w<1A><17>w<1A>tW3<>G<EFBFBD>W3<>tYT<01>7<EFBFBD>YT<01>xO<1A>;<3B>O<1A>d3<>+<2B>3<>,<F<01>w<EFBFBD><Fr/
Reference in a new issue Copy permalink