old-parkingkoncept/parkingkonceptvenv/lib/python3.7/site-packages/matplotlib/__pycache__/scale.cpython-37.pyc

B
U<>]<5D>^<00>@s<>dd
lZdd
l
Z
dd
lZddlmZ
ddlmZmZmZ
ddl	m
Z
mZmZm
Z
mZmZmZmZmZmZ
ddlmZmZ
Gdd<07>de<17>ZGdd	<09>d	e<18>ZGd
d<0B>de<15>ZGdd
<0A>d
e<18>Zejddd<10>Gdd<12>de<15><03>
Zejddd<10>Gdd<15>de<15><03>
Zejddd<10>Gdd<17>de<1D><03>
Zejddd<10>Gdd<19>de<1E><03>
Z ejddd<10>Gdd<1B>de<1D><03>
Z!ejddd<10>Gdd<1D>de<1E><03>
Z"ejddd<10>Gdd<1F>de<1D><03>
Z#ejddd<10>Gd d!<21>d!e<1E><03>
Z$Gd"d<0F>de<15>Z%Gd#d<13>de<1E>Z&Gd$d%<25>d%e<18>Z'Gd&d'<27>d'e'<27>Z(Gd(d)<29>d)e<15>Z)Gd*d+<2B>d+e<15>Z*Gd,d-<2D>d-e<18>Z+Gd.d/<2F>d/e<15>Z,Gd0d1<64>d1e<15>Z-Gd2d3<64>d3e<18>Z.ee'e+e.ee(d4<64>Z/d5d6<64>Z0d7d8<64>Z1e1j2<6A>r<>e1j2d9d:<3A>3e0<65><00>
i
e1_2d;d<<3C>Z4ejdd=d><3E>d?d@<40><00>
Z5dAdB<64>Z6ej7j8dC<64>3dDdE<64>e0<65>D<00>
<01>
e6<65><00>9<EFBFBD>dF<64>
d
S)G<>N)
<01>ma)<03>cbook<6F>	docstring<6E>rcParams)
<EFBFBD>
NullFormatter<65>ScalarFormatter<65>LogFormatterSciNotation<6F>LogitFormatter<65>NullLocator<6F>
LogLocator<EFBFBD>AutoLocator<6F>AutoMinorLocator<6F>SymmetricalLogLocator<6F>LogitLocator)<02>	Transform<72>IdentityTransformc@s0eZ
dZd
Zdd<03>Zdd<05>Zdd<07>Zdd	<09>Zd
S)<0B>	ScaleBasea@

    The base class for all scales.

    Scales are separable transformations, working on a single dimension.

    Any subclasses will want to override:

      - :attr:`name`
      - :meth:`get_transform`
      - :meth:`set_default_locators_and_formatters`

    And optionally:
      - :meth:`limit_range_for_scale`
    c
Ksd
S)a<>

        Construct a new scale.

        Notes
        -----
        The following note is for scale implementors.

        For back-compatibility reasons, scales take an `~matplotlib.axis.Axis`
        object as first argument.  However, this argument should not
        be used: a single scale object should be usable by multiple
        `~matplotlib.axis.Axis`\es at the same time.
        N<>)<03>self<6C>axis<69>kwargsrr<00>8/tmp/pip-install-i8dhxrtk/matplotlib/matplotlib/scale.py<70>__init__szScaleBase.__init__c


Cs
t<00><00>
d
S)zq
        Return the :class:`~matplotlib.transforms.Transform` object
        associated with this scale.
        N)
<01>NotImplementedError)
rrrr<00>
get_transform-szScaleBase.get_transformc
Cs
t<00><00>
d
S)z<>
        Set the :class:`~matplotlib.ticker.Locator` and
        :class:`~matplotlib.ticker.Formatter` objects on the given
        axis to match this scale.
        N)
r)rrrrr<00>#set_default_locators_and_formatters4sz-ScaleBase.set_default_locators_and_formatterscCs|
|fS)
z<>
        Returns the range *vmin*, *vmax*, possibly limited to the
        domain supported by this scale.

        *minpos* should be the minimum positive value in the data.
         This is used by log scales to determine a minimum value.
        r)r<00>vmin<69>vmax<61>minposrrr<00>limit_range_for_scale<szScaleBase.limit_range_for_scaleN)<08>__name__<5F>
__module__<EFBFBD>__qualname__<5F>__doc__rrrrrrrrrs
rcs4eZ
dZd
ZdZ<04>f
dd<04>Zdd<06>Zdd<08>Z<07>ZS)	<09>LinearScalez#
    The default linear scale.
    <20>linearcst<00>j
|
f
|<02>

d
S)z	
        N)<02>superr)rrr)
<01>	__class__rrrNszLinearScale.__init__cCsf|
<01>t
<01><00>

|
<01>t<03><00>

|
<01>t<05><00>

|
jd
kr6tdsH|
jdkrVtdrV|
<01>t	<09><00>

n|
<01>t
<EFBFBD><00>

dS)zd
        Set the locators and formatters to reasonable defaults for
        linear scaling.
        <20>
xzxtick.minor.visible<6C>
yzytick.minor.visibleN)<0B>set_major_locatorr<00>set_major_formatterr<00>set_minor_formatterr<00>	axis_namer<00>set_minor_locatorr
r
)rrrrrrVs



z/LinearScale.set_default_locators_and_formattersc


Cst<00>S)
zy
        The transform for linear scaling is just the
        :class:`~matplotlib.transforms.IdentityTransform`.
        )
r)
rrrrreszLinearScale.get_transform)	r r!r"r#<00>namerrr<00>
__classcell__rr)
r'rr$Gs
r$cs@eZ
dZd
ZdZdZdZdZ<07>f
dd<05>Zdd<07>Z	dd	<09>Z
<EFBFBD>ZS)
<EFBFBD>
FuncTransformzi
    A simple transform that takes and arbitrary function for the
    forward and inverse transform.
    <20>
Tcs4t<00><00>
<01>
t|
<01>
r(t|<02>
r(|
|_||_ntd
<01>
<01>
dS)a<>

        Parameters
        ----------

        forward : callable
            The forward function for the transform.  This function must have
            an inverse and, for best behavior, be monotonic.
            It must have the signature::

               def forward(values: array-like) -> array-like

        inverse : callable
            The inverse of the forward function.  Signature as ``forward``.
        z,arguments to FuncTransform must be functionsN)r&r<00>callable<6C>_forward<72>_inverse<73>
ValueError)r<00>forward<72>inverse)
r'rrrxs




zFuncTransform.__init__cCs
|<00>|
<01>
S)
N)
r4)r<00>valuesrrr<00>transform_non_affine<6E>s
z"FuncTransform.transform_non_affinec

Cst|j
|j<02>S)
N)r1r5r4)
rrrr<00>inverted<65>s
zFuncTransform.inverted)r r!r"r#<00>
input_dims<EFBFBD>output_dims<6D>is_separable<6C>has_inverserr:r;r0rr)
r'rr1ms


r1c@s,eZ
dZd
ZdZdd<04>Zdd<06>Zdd<08>Zd	S)
<EFBFBD>	FuncScalezN
    Provide an arbitrary scale with user-supplied function for the axis.
    <20>functioncCs|\}}t||<04>}||_
d
S)aq

        Parameters
        ----------

        axis: the axis for the scale

        functions : (callable, callable)
            two-tuple of the forward and inverse functions for the scale.
            The forward function must be monotonic.

            Both functions must have the signature::

               def forward(values: array-like) -> array-like
        N)r1<00>
_transform)rr<00>	functionsr7r8<00>	transformrrrr<00>s


zFuncScale.__init__c


Cs|jS)
z5
        The transform for arbitrary scaling
        )
rB)
rrrrr<00>szFuncScale.get_transformcCsf|
<01>t
<01><00>

|
<01>t<03><00>

|
<01>t<05><00>

|
jd
kr6tdsH|
jdkrVtdrV|
<01>t	<09><00>

n|
<01>t
<EFBFBD><00>

dS)zc
        Set the locators and formatters to the same defaults as the
        linear scale.
        r(zxtick.minor.visibler)zytick.minor.visibleN)r*rr+rr,rr-rr.r
r
)rrrrrr<00>s



z-FuncScale.set_default_locators_and_formattersN)r r!r"r#r/rrrrrrrr@<00>s
r@z3.1<EFBFBD>LogTransform)
<01>alternativec@s6eZ
dZd
Zd
ZdZdZddd<05>
Zdd<07>Zdd	<09>Z	d
S)<0C>LogTransformBaser2T<>clipcCst<00>
|<00>

d
dd<03>|
|_dS)NTF)rH<00>mask)rr<00>_clip)r<00>nonposrrrr<00>s


zLogTransformBase.__init__cCst<00>
||
<01>S)
N)rEr:)r<00>
arrrr:<00>s
z%LogTransformBase.transform_non_affinec

Csd
<01>t
|<00>
j|jrdnd<03>S)Nz{}({!r})rHrI)<04>format<61>typer rJ)
rrrr<00>__str__<5F>s

zLogTransformBase.__str__N)
rH)
r r!r"r<r=r>r?rr:rOrrrrrG<00>s



rG<00>InvertedLogTransformc@s,eZ
dZd
Zd
ZdZdZdd<04>Zdd<06>ZdS)<08>InvertedLogTransformBaser2TcCst<00>
|j|
<01>S)
N)r<00>power<65>base)rrLrrrr:<00>s
z-InvertedLogTransformBase.transform_non_affinec

Csd
<01>t
|<00>
j<02>
S)Nz{}())rMrNr )
rrrrrO<00>s
z InvertedLogTransformBase.__str__N)	r r!r"r<r=r>r?r:rOrrrrrQ<00>s


rQc@seZ
dZd
Zdd<03>ZdS)<05>Log10Transformg$@c


Cst<00>S)
N)
<01>InvertedLog10Transform)
rrrrr;<00>s
zLog10Transform.invertedN)r r!r"rSr;rrrrrT<00>srTc@seZ
dZd
Zdd<03>ZdS)rUg$@c


Cst<00>S)
N)
rT)
rrrrr;<00>s
zInvertedLog10Transform.invertedN)r r!r"rSr;rrrrrU<00>srUc@seZ
dZd
Zdd<03>ZdS)<05>
Log2Transformg@c


Cst<00>S)
N)
<01>InvertedLog2Transform)
rrrrr;<00>s
zLog2Transform.invertedN)r r!r"rSr;rrrrrV<00>srVc@seZ
dZd
Zdd<03>ZdS)rWg@c


Cst<00>S)
N)
rV)
rrrrr;
s
zInvertedLog2Transform.invertedN)r r!r"rSr;rrrrrW<00>srWc@seZ
dZejZd
d<02>ZdS)<04>NaturalLogTransformc


Cst<00>S)
N)
<01>InvertedNaturalLogTransform)
rrrrr;
s
zNaturalLogTransform.invertedN)r r!r"<00>np<6E>
erSr;rrrrrX
srXc@seZ
dZejZd
d<02>ZdS)rYc


Cst<00>S)
N)
rX)
rrrrr;
s
z$InvertedNaturalLogTransform.invertedN)r r!r"rZr[rSr;rrrrrY
srYc@s>eZ
dZd
Zd
ZdZdZd
dd<05>
Zdd<07>Zdd	<09>Z	d
d<0B>Z
dS)rEr2TrHcCs$t<00>
|<00>

|
|_d
dd<03>||_dS)NTF)rHrI)rrrSrJ)rrSrKrrrr
s



zLogTransform.__init__c

Cs d
<01>t
|<00>
j|j|jrdnd<03>S)Nz{}(base={}, nonpos={!r})rHrI)rMrNr rSrJ)
rrrrrO"
s

zLogTransform.__str__c	Csxtj
d
d
d<02><02>`
tjtjdtjdtji<03>|j<07>
}|r>||
<01>
}nt<00>|
<01>
}|t<00>|j<07>
}|jrjd||
dk
<WdQRX|S)N<>ignore)<02>divide<64>invalid<69><00>
i<18><><EFBFBD>r
)	rZ<00>errstater[<00>log<6F>log2<67>log10<31>getrSrJ)rrLrb<00>outrrrr:&
s
 







z!LogTransform.transform_non_affinec

Cs
t|j
<01>
S)
N)rPrS)
rrrrr;<
s
zLogTransform.invertedN)
rH)r r!r"r<r=r>r?rrOr:r;rrrrrE
s




c@s<eZ
dZd
Zd
ZdZdZdd<04>Zdd<06>Zdd<08>Z	d	d
<EFBFBD>Z
dS)rPr2TcCst<00>
|<00>

|
|_dS)
N)rrrS)rrSrrrrF
s


zInvertedLogTransform.__init__c

Csd
<01>t
|<00>
j|j<03>S)Nz{}(base={}))rMrNr rS)
rrrrrOJ
s
zInvertedLogTransform.__str__cCst<00>
|j|
<01>S)
N)rrRrS)rrLrrrr:M
s
z)InvertedLogTransform.transform_non_affinec

Cs
t|j
<01>
S)
N)rErS)
rrrrr;P
s
zInvertedLogTransform.invertedN)r r!r"r<r=r>r?rrOr:r;rrrrrP@
s



c@sdeZ
dZd
ZdZeZeZeZeZe	Z	e
Z
eZeZe
Z
dd<04>Zedd<06><00>
Zdd<08>Zd	d
<EFBFBD>Zdd<0C>Zd
S)<0E>LogScalezT
    A standard logarithmic scale.  Care is taken to only plot positive values.
    rbcKs<>|
jd
krB|<02>
dd<03>}|<02>
dd<05>}|<02>
dd<07>}tjddg|d	<09>
n6|<02>
d
d<03>}|<02>
dd<05>}|<02>
dd<07>}tjddg|d
<0A>
t|<02>
r<>tdd<0F>|<02>
<00>
<01>
|dk
s<>|dkr<>td<12>
<01>
|<00>||<05>|_||_	dS)a 
        *basex*/*basey*:
           The base of the logarithm

        *nonposx*/*nonposy*: {'mask', 'clip'}
          non-positive values in *x* or *y* can be masked as
          invalid, or clipped to a very small positive number

        *subsx*/*subsy*:
           Where to place the subticks between each major tick.
           Should be a sequence of integers.  For example, in a log10
           scale: ``[2, 3, 4, 5, 6, 7, 8, 9]``

           will place 8 logarithmically spaced minor ticks between
           each major tick.
        r(<00>basexg$@<40>subsxN<78>nonposxrHrI)
rj<00>basey<65>subsy<73>nonposy)
rmzrprovided too many kwargs, can only pass {'basex', 'subsx', nonposx'} or {'basey', 'subsy', nonposy'}.  You passed z{!r}r
r2z#The log base cannot be <= 0 or == 1)
r-<00>popr<00>_check_in_list<73>lenr6rMrErB<00>subs)rrrrSrqrKrrrre
s 










zLogScale.__init__c


Cs|jj
S)
N)rBrS)
rrrrrS<00>
sz
LogScale.basecCsR|
<01>t
|j<02>
<01>

|
<01>t|j<02>
<01>

|
<01>t
|j|j<06><02>

|
<01>t|j|jd
k	d<02><02>

d
S)zb
        Set the locators and formatters to specialized versions for
        log scaling.
        N)
Z
labelOnlyBase)r*rrSr+rr.rqr,)rrrrrr<00>
s




z,LogScale.set_default_locators_and_formattersc


Cs|jS)
z
        Return a :class:`~matplotlib.transforms.Transform` instance
        appropriate for the given logarithm base.
        )
rB)
rrrrr<00>
szLogScale.get_transformcCs.t<00>
|<03>
sd
}|
dk
r|n|
|dk
r(|n|fS)z6
        Limit the domain to positive values.
        gY<67><59><EFBFBD>n<>
r
)rZ<00>isfinite)rrrrrrrr<00>
s


zLogScale.limit_range_for_scaleN)r r!r"r#r/rGrTrUrVrWrXrYrErPr<00>propertyrSrrrrrrrrgT
s 








(rgc@s2eZ
dZd
ZdZddd<05>
Zedd<07><00>
Zdd	<09>Zd
S)<0C>FuncScaleLogzu
    Provide an arbitrary scale with user-supplied function for the axis and
    then put on a logarithmic axes.
    <20>functionlogr`cCs&|\}}d
|_t
||<05>t|<03>
|_d
S)a<>

        Parameters
        ----------

        axis: the axis for the scale

        functions : (callable, callable)
            two-tuple of the forward and inverse functions for the scale.
            The forward function must be monotonic.

            Both functions must have the signature::

                def forward(values: array-like) -> array-like

        base : float
            logarithmic base of the scale (default = 10)

        N)rqr1rErB)rrrCrSr7r8rrrr<00>
s

zFuncScaleLog.__init__c


Cs
|jj
jS)
N)rB<00>_brS)
rrrrrS<00>
szFuncScaleLog.basec


Cs|jS)
z5
        The transform for arbitrary scaling
        )
rB)
rrrrr<00>
szFuncScaleLog.get_transformN)
r`)	r r!r"r#r/rrsrSrrrrrrt<00>
s

rtc@s4eZ
dZd
Zd
ZdZdZdd<04>Zdd<06>Zdd<08>Z	d	S)
<EFBFBD>SymmetricalLogTransformr2TcCs@t<00>
|<00>

|
|_||_||_|d
|jd|_t<06>|
<01>
|_dS)Ng<00>?<3F><><EFBFBD><EFBFBD><EFBFBD>)	rrrS<00>	linthresh<73>linscale<6C>
_linscale_adjrZrb<00>	_log_base)rrSryrzrrrr<00>
s






z SymmetricalLogTransform.__init__c	Cspt<00>
|
<01>
}tjd
d
d<02><02><
t<00>|
<01>
|j|jt<00>||j<00>
|j}||jk
}WdQRX|
||j||<|S)Nr\)r]r^)rZ<00>absra<00>signryr{rbr|)rrL<00>abs_arf<00>insiderrrr:<00>
s








z,SymmetricalLogTransform.transform_non_affinec

Cst|j
|j|j<03>S)
N)<04>InvertedSymmetricalLogTransformrSryrz)
rrrrr;<00>
s


z SymmetricalLogTransform.invertedN)
r r!r"r<r=r>r?rr:r;rrrrrw<00>
s




rwc@s4eZ
dZd
Zd
ZdZdZdd<04>Zdd<06>Zdd<08>Z	d	S)
r<EFBFBD>r2TcCsLt<00>
|<00>

t|
||<03>}|
|_||_|<04>|<02>
|_||_|d
|jd|_dS)Ng<00>?rx)	rrrwrSryrD<00>invlinthreshrzr{)rrSryrz<00>symlogrrrr<00>
s







z(InvertedSymmetricalLogTransform.__init__c	Csnt<00>
|
<01>
}tjd
d
d<02><02>:
t<00>|
<01>
|jt<00>|j||j|j<00>}||jk
}WdQRX|
||j||<|S)Nr\)r]r^)	rZr}rar~ryrRrSr{r<>)rrLrrfr<>rrrr:s








z4InvertedSymmetricalLogTransform.transform_non_affinec

Cst|j
|j|j<03>S)
N)rwrSryrz)
rrrrr;s

z(InvertedSymmetricalLogTransform.invertedN)
r r!r"r<r=r>r?rr:r;rrrrr<><00>
s



	
r<EFBFBD>c@s4eZ
dZd
ZdZeZeZdd<04>Zdd<06>Zdd<08>Z	d	S)
<EFBFBD>SymmetricalLogScaleaJ
    The symmetrical logarithmic scale is logarithmic in both the
    positive and negative directions from the origin.

    Since the values close to zero tend toward infinity, there is a
    need to have a range around zero that is linear.  The parameter
    *linthresh* allows the user to specify the size of this range
    (-*linthresh*, *linthresh*).

    Parameters
    ----------
    basex, basey : float
        The base of the logarithm. Defaults to 10.

    linthreshx, linthreshy : float
        Defines the range ``(-x, x)``, within which the plot is linear.
        This avoids having the plot go to infinity around zero. Defaults to 2.

    subsx, subsy : sequence of int
        Where to place the subticks between each major tick.
        For example, in a log10 scale: ``[2, 3, 4, 5, 6, 7, 8, 9]`` will place
        8 logarithmically spaced minor ticks between each major tick.

    linscalex, linscaley : float, optional
        This allows the linear range ``(-linthresh, linthresh)`` to be
        stretched relative to the logarithmic range. Its value is the number of
        decades to use for each half of the linear range. For example, when
        *linscale* == 1.0 (the default), the space used for the positive and
        negative halves of the linear range will be equal to one decade in
        the logarithmic range.
    r<>cKs<>|
jd
kr<|<02>
dd<03>}|<02>
dd<05>}|<02>
dd<00>}|<02>
dd<08>}n0|<02>
d	d<03>}|<02>
d
d<05>}|<02>
dd<00>}|<02>
dd<08>}|dk
r|td
<0A>
<01>
|dk
r<>td<0F>
<01>
|dk
r<>td<10>
<01>
|<00>|||<06>|_||_||_||_||_dS)Nr(rhg$@Z
linthreshxg@riZ	linscalexg<00>?rkZ
linthreshyrlZ	linscaleyz#'basex/basey' must be larger than 1gz('linthreshx/linthreshy' must be positivez''linscalex/linthreshy' must be positive)	r-rnr6rwrBrSryrzrq)rrrrSryrqrzrrrr:s,


















zSymmetricalLogScale.__init__cCsH|
<01>t
|<00><02><00>
<01>

|
<01>t|j<05>
<01>

|
<01>t
|<00><02>|j<07><02>

|
<01>t	<09><00>

d
S)zn
        Set the locators and formatters to specialized versions for
        symmetrical log scaling.
        N)
r*rrr+rrSr.rqr,r)rrrrrrVs





z7SymmetricalLogScale.set_default_locators_and_formattersc


Cs|jS)
zE
        Return a :class:`SymmetricalLogTransform` instance.
        )
rB)
rrrrrasz!SymmetricalLogScale.get_transformN)
r r!r"r#r/rwr<>rrrrrrrr<>s

r<>c@s>eZ
dZd
Zd
ZdZdZd
dd<05>
Zdd<07>Zdd	<09>Z	d
d<0B>Z
dS)<0E>LogitTransformr2TrIcCs$t<00>
|<00>

|
|_d
dd<03>|
|_dS)NTF)rHrI)rr<00>_nonposrJ)rrKrrrrns



zLogitTransform.__init__c	CsNtj
d
d
d<02><02>
t<00>|
d|
<00>
}WdQRX|jrJd||
dk
<d|d|
k
<|S)z,logit transform (base 10), masked or clippedr\)r]r^r2Ni<18><><EFBFBD>r
i<>)rZrardrJ)rrLrfrrrr:ss




z#LogitTransform.transform_non_affinec

Cs
t|j
<01>
S)
N)<02>LogisticTransformr<6D>)
rrrrr;|s
zLogitTransform.invertedc

Csd
<01>t
|<00>
j|jrdnd<03>S)Nz{}({!r})rHrI)rMrNr rJ)
rrrrrOs

zLogitTransform.__str__N)
rI)r r!r"r<r=r>r?rr:r;rOrrrrr<>hs




	r<>c@s>eZ
dZd
Zd
ZdZdZd
dd<05>
Zdd<07>Zdd	<09>Z	d
d<0B>Z
dS)r<>r2TrIcCst<00>
|<00>

|
|_dS)
N)rrr<>)rrKrrrr<00>s


zLogisticTransform.__init__cCsd
dd|
S)zlogistic transform (base 10)g<00>?r2r`r)rrLrrrr:<00>sz&LogisticTransform.transform_non_affinec

Cs
t|j
<01>
S)
N)r<>r<>)
rrrrr;<00>s
zLogisticTransform.invertedc

Csd
<01>t
|<00>
j|j<03>S)Nz{}({!r}))rMrNr r<>)
rrrrrO<00>s
zLogisticTransform.__str__N)
rI)r r!r"r<r=r>r?rr:r;rOrrrrr<><00>s




r<>c@s6eZ
dZd
ZdZd
dd<05>
Zdd<07>Zdd	<09>Zd
d<0B>ZdS)<0E>
LogitScalez<EFBFBD>
    Logit scale for data between zero and one, both excluded.

    This scale is similar to a log scale close to zero and to one, and almost
    linear around 0.5. It maps the interval ]0, 1[ onto ]-infty, +infty[.
    <20>logitrIcCs tj
d
dg|d<03>
t|<02>
|_dS)z<>
        *nonpos*: {'mask', 'clip'}
          values beyond ]0, 1[ can be masked as invalid, or clipped to a number
          very close to 0 or 1
        rIrH)
rKN)rror<>rB)rrrKrrrr<00>s
zLogitScale.__init__c


Cs|jS)
z<
        Return a :class:`LogitTransform` instance.
        )
rB)
rrrrr<00>szLogitScale.get_transformcCs8|
<01>t
<01><00>

|
<01>t<03><00>

|
<01>t
d
d<02>
<01>

|
<01>t<03><00>

dS)NT)
<01>minor)r*rr+r	r.r,)rrrrrr<00>s


z.LogitScale.set_default_locators_and_formatterscCs2t<00>
|<03>
sd
}|
dk
r|n|
|dkr,d|n|fS)zH
        Limit the domain to values between 0 and 1 (excluded).
        gH<67><48><EFBFBD><EFBFBD><EFBFBD>z>r
r2)rZrr)rrrrrrrr<00>s


z LogitScale.limit_range_for_scaleN)
rI)	r r!r"r#r/rrrrrrrrr<><00>s

	r<>)r%rbr<>r<>rArucCstt
<01>
S)
N)<02>sorted<65>_scale_mappingrrrr<00>get_scale_names<65>s
r<>cKs,|<00><00>}|t
krtd
|<00>
<01>
t
||
f
|<02>
S)zn
    Return a scale class by name.

    Parameters
    ----------
    scale : {%(names)s}
    axis : Axis
    zUnknown scale type '%s')<03>lowerr<72>r6)<03>scalerrrrr<00>
scale_factory<72>s	


r<><00>namesz, c

Cs|t|j
<d
S)zd
    Register a new kind of scale.

    *scale_class* must be a subclass of :class:`ScaleBase`.
    N)r<>r/)
<01>scale_classrrr<00>register_scale<6C>sr<>zdget_scale_docs() is considered private API since 3.1 and will be removed from the public API in 3.3.)
<01>messagec
Cst<00>S)
zF
    Helper function for generating docstrings related to scales.
    )
<01>_get_scale_docsrrrr<00>get_scale_docs<63>sr<>c
CsLg}x<t<00>
<01>D]0\}
}|<00>d
|
<01><02>dt<03>t<05>|j<07>
d<03>dg<04>

qWd<04>|<00>
S)zF
    Helper function for generating docstrings related to scales.
    z    <20>z        <20>

)	r<><00>items<6D>extend<6E>textwrap<61>indent<6E>inspect<63>getdocr<00>join)Zdocsr/r<>rrrr<><00>s





r<>z | c
Csg|]}
t|
<01>
<01>qSr)
<01>repr)<02>.0r(rrr<00>
<listcomp>sr<>)r<>Z
scale_docs):r<>r<>ZnumpyrZrZ
matplotlibrrrZmatplotlib.tickerrrrr	r
rrr
rrZmatplotlib.transformsrr<00>objectrr$r1r@<00>
deprecatedrGrQrTrUrVrWrXrYrErPrgrtrwr<>r<>r<>r<>r<>r<>r<>r<>r#r<>r<>r<>r<>Zinterpd<70>update<74>rstriprrrr<00><module>
sl


08&)0








)\*S+