o :a0T@sdZddlZddlZddlZddlmZddlZddlmZm Z ddl m Z m Z m Z mZmZmZmZmZmZmZddlmZmZGdddZGd d d eZGd d d eZGd ddeZGdddeZGdddeZGdddeZGdddeZGdddeZ GdddeZ!GdddeZ"GdddeZ#Gdd d eZ$Gd!d"d"eZ%eee"e%eed#Z&d$d%Z'd&d'Z(e(jre(jd(d))e*e+e'ie(_d*d+Z,d,d-Z-e j.j/d.d))d/d0e'De-0d1dS)2a Scales define the distribution of data values on an axis, e.g. a log scaling. They are defined as subclasses of `ScaleBase`. See also `.axes.Axes.set_xscale` and the scales examples in the documentation. See :doc:`/gallery/scales/custom_scale` for a full example of defining a custom scale. Matplotlib also supports non-separable transformations that operate on both `~.axis.Axis` at the same time. They are known as projections, and defined in `matplotlib.projections`. N)ma)_api docstring) NullFormatterScalarFormatterLogFormatterSciNotationLogitFormatter NullLocator LogLocator AutoLocatorAutoMinorLocatorSymmetricalLogLocator LogitLocator) TransformIdentityTransformc@s0eZdZdZddZddZddZdd Zd S) ScaleBasea The base class for all scales. Scales are separable transformations, working on a single dimension. Subclasses should override :attr:`name` The scale's name. :meth:`get_transform` A method returning a `.Transform`, which converts data coordinates to scaled coordinates. This transform should be invertible, so that e.g. mouse positions can be converted back to data coordinates. :meth:`set_default_locators_and_formatters` A method that sets default locators and formatters for an `~.axis.Axis` that uses this scale. :meth:`limit_range_for_scale` An optional method that "fixes" the axis range to acceptable values, e.g. restricting log-scaled axes to positive values. cCdS)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. Nselfaxisrr2/usr/lib/python3/dist-packages/matplotlib/scale.py__init__4zScaleBase.__init__cCt)zL Return the `.Transform` object associated with this scale. NotImplementedErrorrrrr get_transformBszScaleBase.get_transformcCr)zi Set the locators and formatters of *axis* to instances suitable for this scale. rrrrr#set_default_locators_and_formattersHz-ScaleBase.set_default_locators_and_formatterscCs||fS)z Return the range *vmin*, *vmax*, restricted to the domain supported by this scale (if any). *minpos* should be the minimum positive value in the data. This is used by log scales to determine a minimum value. rrZvminZvmaxZminposrrrlimit_range_for_scaleOszScaleBase.limit_range_for_scaleN)__name__ __module__ __qualname____doc__rrrr"rrrrrs  rc@,eZdZdZdZddZddZddZd S) LinearScalez# The default linear scale. linearcCr)z NrrrrrrarzLinearScale.__init__cCl|t|t|t|jdkrtjds&|jdkr.tjdr.| t dS| t dSNxzxtick.minor.visibleyzytick.minor.visible set_major_locatorr set_major_formatterrset_minor_formatterrZ axis_namemplZrcParamsset_minor_locatorr r rrrrrh   z/LinearScale.set_default_locators_and_formatterscCstS)z Return the transform for linear scaling, which is just the `~matplotlib.transforms.IdentityTransform`. )rrrrrrtr zLinearScale.get_transformN)r#r$r%r&namerrrrrrrr(Zs  r(cs8eZdZdZdZZfddZddZddZZ S) FuncTransformzi A simple transform that takes and arbitrary function for the forward and inverse transform. cs2tt|rt|r||_||_dStd)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)superrcallable_forward_inverse ValueError)rforwardinverse __class__rrrs  zFuncTransform.__init__cCs ||SN)r:)rvaluesrrrtransform_non_affine z"FuncTransform.transform_non_affinecCst|j|jSrA)r6r;r:rrrrinvertedzFuncTransform.inverted) r#r$r%r& input_dims output_dimsrrCrE __classcell__rrr?rr6|s  r6c@r') FuncScalezN Provide an arbitrary scale with user-supplied function for the axis. functioncCs|\}}t||}||_dS)a Parameters ---------- axis : `~matplotlib.axis.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)r6 _transform)rr functionsr=r> transformrrrrs  zFuncScale.__init__cC|jS)z7Return the `.FuncTransform` associated with this scale.rLrrrrrzFuncScale.get_transformcCr*r+r.rrrrrr4z-FuncScale.set_default_locators_and_formattersN)r#r$r%r&r5rrrrrrrrJs  rJc>eZdZdZZd fdd ZddZddZd d ZZ S) LogTransformr7clipcsBt|dks |dkrtd||_tjddd|d|_dS)Nrr7z#The log base cannot be <= 0 or == 1TFrTmask nonpositive)r8rr<baser check_getitem_clip)rrYrXr?rrrs   zLogTransform.__init__cCs"dt|j|j|jrdSdS)Nz{}(base={}, nonpositive={!r})rTrV)formattyper#rYr[rrrr__str__s zLogTransform.__str__cCstjddd>tjtjdtjdtji|j}|r||}n t|}|t|j}|jr=d||dk<Wd|SWd|S1sHwY|S)NignoreZdivideZinvalid r) nperrstateelogZlog2log10getrYr[)rargoutrrrrCs     z!LogTransform.transform_non_affinecC t|jSrA)InvertedLogTransformrYrrrrrErDzLogTransform.inverted)rT r#r$r%rGrHrr^rCrErIrrr?rrSs rScs<eZdZdZZfddZddZddZdd ZZ S) rmr7ct||_dSrA)r8rrY)rrYr?rrr  zInvertedLogTransform.__init__cCdt|j|jS)Nz {}(base={}))r\r]r#rYrrrrr^zInvertedLogTransform.__str__cCst|j|SrA)rpowerrYrrjrrrrCrFz)InvertedLogTransform.transform_non_affinecCrlrA)rSrYrrrrrErDzInvertedLogTransform.invertedrnrrr?rrms  rmc@sJeZdZdZdZddddddZed d Zd d Zd dZ ddZ dS)LogScalezT A standard logarithmic scale. Care is taken to only plot positive values. rgrbNrT)rYsubsrXcCst|||_||_dS)a Parameters ---------- axis : `~matplotlib.axis.Axis` The axis for the scale. base : float, default: 10 The base of the logarithm. nonpositive : {'clip', 'mask'}, default: 'clip' Determines the behavior for non-positive values. They can either be masked as invalid, or clipped to a very small positive number. subs : sequence of int, default: None 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. N)rSrLrv)rrrYrvrXrrrr s  zLogScale.__init__cC|jjSrArLrYrrrrzLogScale.cCsR|t|j|t|j|t|j|j|t|j|jduddS)N)Z labelOnlyBase)r/r rYr0rr3rvr1rrrrrsz,LogScale.set_default_locators_and_formatterscCrO)z6Return the `.LogTransform` associated with this scale.rPrrrrr(rQzLogScale.get_transformcCs0t|sd}|dkr |n||dkr|fS|fS)z$Limit the domain to positive values.gYnrrdZisfiniter!rrrr",s  zLogScale.limit_range_for_scale) r#r$r%r&r5rpropertyrYrrr"rrrrrus  ruc@s2eZdZdZdZd ddZeddZdd Zd S) FuncScaleLogzu Provide an arbitrary scale with user-supplied function for the axis and then put on a logarithmic axes. functionlogrbcCs&|\}}d|_t||t||_dS)a Parameters ---------- axis : `matplotlib.axis.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, default: 10 Logarithmic base of the scale. N)rvr6rSrL)rrrMrYr=r>rrrr=szFuncScaleLog.__init__cCs |jjjSrA)rLZ_brYrrrrrYRs zFuncScaleLog.basecCrO)z3Return the `.Transform` associated with this scale.rPrrrrrVrQzFuncScaleLog.get_transformN)rb) r#r$r%r&r5rr|rYrrrrrr}5s   r}c4eZdZdZZfddZddZddZZS)SymmetricalLogTransformr7cspt|dkr td|dkrtd|dkrtd||_||_||_|d|jd|_t||_ dS)N?z'base' must be larger than 1gz'linthresh' must be positivez'linscale' must be positive) r8rr<rY linthreshlinscale _linscale_adjrdrg _log_base)rrYrrr?rrr^s z SymmetricalLogTransform.__init__cCst|}tjddd#t||j|jt||j|j}||jk}Wdn1s2wY|||j||<|SNr_r`)rdabsresignrrrgrrrjZabs_arkZinsiderrrrCls  z,SymmetricalLogTransform.transform_non_affinecCt|j|j|jSrA)InvertedSymmetricalLogTransformrYrrrrrrrEvs z SymmetricalLogTransform.inverted r#r$r%rGrHrrCrErIrrr?rr[s   rcr)rr7csLtt|||}||_||_|||_||_|d|jd|_dS)Nrr) r8rrrYrrN invlinthreshrr)rrYrrsymlogr?rrr~s   z(InvertedSymmetricalLogTransform.__init__cCst|}tjddd"t||jt|j||j|j}||jk}Wdn1s1wY|||j||<|Sr) rdrrerrrsrYrrrrrrrCs  z4InvertedSymmetricalLogTransform.transform_non_affinecCrrA)rrYrrrrrrrEsz(InvertedSymmetricalLogTransform.invertedrrrr?rr{s    rc@s\eZdZdZdZddddddd Zed d Zed d Zed d Z ddZ ddZ dS)SymmetricalLogScalea 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 ---------- base : float, default: 10 The base of the logarithm. linthresh : float, default: 2 Defines the range ``(-x, x)``, within which the plot is linear. This avoids having the plot go to infinity around zero. subs : 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. linscale : 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. rrbraNr7)rYrrvrcCst||||_||_dSrA)rrLrv)rrrYrrvrrrrrs zSymmetricalLogScale.__init__cCrwrArxrrrrryrzzSymmetricalLogScale.cCrwrA)rLrrrrrryrzcCrwrA)rLrrrrrryrzcCsH|t||t|j|t||j|t dSrA) r/r rr0rrYr3rvr1rrrrrrs  z7SymmetricalLogScale.set_default_locators_and_formatterscCrO)zAReturn the `.SymmetricalLogTransform` associated with this scale.rPrrrrrrQz!SymmetricalLogScale.get_transform) r#r$r%r&r5rr|rYrrrrrrrrrs    rcrR) LogitTransformr7rVcs6ttjddg|d||_ddd||_dS)NrVrTrWTFrU)r8rrZ check_in_list _nonpositiver[rrXr?rrrs zLogitTransform.__init__cCsbtjdddt|d|}Wdn1swY|jr/d||dk<d|d|k<|S)z,logit transform (base 10), masked or clippedr_r`r7Nrcri)rdrerhr[)rrjrkrrrrCs  z#LogitTransform.transform_non_affinecCrlrA)LogisticTransformrrrrrrErDzLogitTransform.invertedcCrqNz{}({!r})r\r]r#rrrrrr^rrzLogitTransform.__str__rV r#r$r%rGrHrrCrEr^rIrrr?rrs  rcrR) rr7rVcrorA)r8rrrr?rrrrpzLogisticTransform.__init__cCsddd| S)zlogistic transform (base 10)rr7rbrrtrrrrCsz&LogisticTransform.transform_non_affinecCrlrA)rrrrrrrErDzLogisticTransform.invertedcCrqrrrrrrr^rrzLogisticTransform.__str__rrrrr?rrs rc@s>eZdZdZdZddddddZd d Zd d Zd dZdS) LogitScalez 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[. logitrVz \frac{1}{2}Fone_half use_overlinecCst||_||_||_dS)a Parameters ---------- axis : `matplotlib.axis.Axis` Currently unused. nonpositive : {'mask', 'clip'} Determines the behavior for values beyond the open interval ]0, 1[. They can either be masked as invalid, or clipped to a number very close to 0 or 1. use_overline : bool, default: False Indicate the usage of survival notation (\overline{x}) in place of standard notation (1-x) for probability close to one. one_half : str, default: r"\frac{1}{2}" The string used for ticks formatter to represent 1/2. N)rrL _use_overline _one_half)rrrXrrrrrrs  zLogitScale.__init__cCrO)z8Return the `.LogitTransform` associated with this scale.rPrrrrrrQzLogitScale.get_transformcCsN|t|t|j|jd|tdd|td|j|jddS)NrT)minor)rrr)r/rr0rrrr3r1rrrrrs z.LogitScale.set_default_locators_and_formatterscCs4t|sd}|dkr |n||dkrd|fS|fS)zH Limit the domain to values between 0 and 1 (excluded). gHz>rr7r{r!rrrr"-s z LogitScale.limit_range_for_scaleNr) r#r$r%r&r5rrrr"rrrrrs  r)r)rgrrrKr~cCsttS)z)Return the names of the available scales.)sorted_scale_mappingrrrrget_scale_namesAsrcKs@||krtjddd|}tjt|d}||fi|S)z Return a scale class by name. Parameters ---------- scale : {%(names)s} axis : `matplotlib.axis.Axis` z3.5zjSupport for case-insensitive scales is deprecated since %(since)s and support will be removed %(removal)s.)message)scale)lowerrZwarn_deprecatedrZr)rrkwargsZ scale_clsrrr scale_factoryFs rnamesz, cCs|t|j<dS)z Register a new kind of scale. Parameters ---------- scale_class : subclass of `ScaleBase` The scale to register. N)rr5) scale_classrrrregister_scale]s rc CsPg}tD]\}}t|jpd}|d|dt|ddgqd|S)zF Helper function for generating docstrings related to scales. z z  ) ritemsinspectZgetdocrextendtextwrapindentjoin)Zdocsr5rrrrr_get_scale_docsis  rz{%s}cCsg|]}t|qSr)repr).0r,rrr zsr)Z scale_typeZ scale_docs)1r&rrZnumpyrdrZ matplotlibr2rrZmatplotlib.tickerrrrrr r r r r rZmatplotlib.transformsrrrr(r6rJrSrmrur}rrrrrrrrrrmaprrrZinterpdupdaterstriprrrrsT 0<"$*)1& 7@