a Eb0T@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. cCsdS)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. NselfaxisrrP/home/ja/django-apps/lartica_env/lib/python3.9/site-packages/matplotlib/scale.py__init__4szScaleBase.__init__cCs tdS)zL Return the `.Transform` object associated with this scale. NNotImplementedErrorrrrr get_transformBszScaleBase.get_transformcCs tdS)zi Set the locators and formatters of *axis* to instances suitable for this scale. Nrrrrr#set_default_locators_and_formattersHsz-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__rrrrrrrrrs rc@s,eZdZdZdZddZddZddZd S) LinearScalez# The default linear scale. linearcCsdS)z NrrrrrraszLinearScale.__init__cCsj|t|t|t|jdkr8tjdsL|jdkrZtjdrZ| t n | t dSNxzxtick.minor.visibleyzytick.minor.visible set_major_locatorr set_major_formatterrset_minor_formatterrZ axis_namemplZrcParamsset_minor_locatorr r rrrrrhs   z/LinearScale.set_default_locators_and_formatterscCstS)z Return the transform for linear scaling, which is just the `~matplotlib.transforms.IdentityTransform`. )rrrrrrtszLinearScale.get_transformN)rr r!r"namerrrrrrrr#Zs  r#cs8eZdZdZdZZfddZddZddZZ S) FuncTransformzi A simple transform that takes and arbitrary function for the forward and inverse transform. cs4tt|r(t|r(||_||_ntddS)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)r3)rvaluesrrrtransform_non_affinesz"FuncTransform.transform_non_affinecCst|j|jSr:)r/r4r3rrrrinvertedszFuncTransform.inverted) rr r!r" input_dims output_dimsrr<r= __classcell__rrr8rr/|s  r/c@s,eZdZdZdZddZddZddZd S) 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)r/ _transform)rr functionsr6r7 transformrrrrs zFuncScale.__init__cCs|jS)z7Return the `.FuncTransform` associated with this scale.rCrrrrrszFuncScale.get_transformcCsj|t|t|t|jdkr8tjdsL|jdkrZtjdrZ| t n | t dSr%r(rrrrrs   z-FuncScale.set_default_locators_and_formattersN)rr r!r"r.rrrrrrrrAs rAcs>eZdZdZZd fdd ZddZddZd d ZZ S) LogTransformr0clipcsBt|dks|dkr"td||_tjddd|d|_dS)Nrr0z#The log base cannot be <= 0 or == 1TFrHmask nonpositive)r1rr5baser check_getitem_clip)rrMrLr8rrrs  zLogTransform.__init__cCs dt|j|j|jrdndS)Nz{}(base={}, nonpositive={!r})rHrJ)formattyperrMrOrrrr__str__szLogTransform.__str__cCstjdddjtjtjdtjdtji|j}|r>||}nt|}|t|j}|jrjd||dk<Wdn1s~0Y|S)Nignoredivideinvalid r) nperrstateeloglog2log10getrMrO)rar]outrrrr<s    *z!LogTransform.transform_non_affinecCs t|jSr:)InvertedLogTransformrMrrrrr=szLogTransform.inverted)rH rr r!r>r?rrRr<r=r@rrr8rrGs rGcs<eZdZdZZfddZddZddZdd ZZ S) rcr0cst||_dSr:)r1rrM)rrMr8rrrs zInvertedLogTransform.__init__cCsdt|j|jS)Nz {}(base={}))rPrQrrMrrrrrRszInvertedLogTransform.__str__cCst|j|Sr:)rpowerrMrrarrrr<sz)InvertedLogTransform.transform_non_affinecCs t|jSr:)rGrMrrrrr=szInvertedLogTransform.invertedrdrrr8rrcs  rcc@sJeZdZdZdZddddddZed d Zd d Zd dZ ddZ dS)LogScalezT A standard logarithmic scale. Care is taken to only plot positive values. r]rXNrH)rMsubsrLcCst|||_||_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)rGrCrh)rrrMrhrLrrrr s zLogScale.__init__cCs|jjSr:rCrMrrrrzLogScale.cCsR|t|j|t|j|t|j|j|t|j|jduddS)N)Z labelOnlyBase)r)r rMr*rr-rhr+rrrrrsz,LogScale.set_default_locators_and_formatterscCs|jS)z6Return the `.LogTransform` associated with this scale.rFrrrrr(szLogScale.get_transformcCs.t|sd}|dkr|n||dkr(|n|fS)z$Limit the domain to positive values.gYnrrZisfiniterrrrr,s  zLogScale.limit_range_for_scale) rr r!r"r.rpropertyrMrrrrrrrrgs  rgc@s2eZdZdZdZd ddZeddZdd Zd S) FuncScaleLogzu Provide an arbitrary scale with user-supplied function for the axis and then put on a logarithmic axes. functionlogrXcCs&|\}}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)rhr/rGrC)rrrDrMr6r7rrrr=szFuncScaleLog.__init__cCs |jjjSr:)rC_brMrrrrrMRszFuncScaleLog.basecCs|jS)z3Return the `.Transform` associated with this scale.rFrrrrrVszFuncScaleLog.get_transformN)rX) rr r!r"r.rrnrMrrrrrro5s   rocs4eZdZdZZfddZddZddZZS)SymmetricalLogTransformr0cspt|dkrtd|dkr*td|dkr:td||_||_||_|d|jd|_t||_ dS)N?z'base' must be larger than 1gz'linthresh' must be positivez'linscale' must be positive) r1rr5rM linthreshlinscale _linscale_adjrZr] _log_base)rrMrurvr8rrr^s z SymmetricalLogTransform.__init__cCst|}tjdddFt||j|jt||j|j}||jk}Wdn1sd0Y|||j||<|SNrSrT)rZabsr[signrurwr]rxrraZabs_arbZinsiderrrr<ls (z,SymmetricalLogTransform.transform_non_affinecCst|j|j|jSr:)InvertedSymmetricalLogTransformrMrurvrrrrr=vs z SymmetricalLogTransform.inverted rr r!r>r?rr<r=r@rrr8rrr[s  rrcs4eZdZdZZfddZddZddZZS)r}r0csLtt|||}||_||_|||_||_|d|jd|_dS)Nrsrt) r1rrrrMrurE invlinthreshrvrw)rrMrurvsymlogr8rrr~s   z(InvertedSymmetricalLogTransform.__init__cCst|}tjdddDt||jt|j||j|j}||jk}Wdn1sb0Y|||j||<|Sry) rZrzr[r{rurerMrwrr|rrrr<s (z4InvertedSymmetricalLogTransform.transform_non_affinecCst|j|j|jSr:)rrrMrurvrrrrr=sz(InvertedSymmetricalLogTransform.invertedr~rrr8rr}{s  r}c@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. rrXrWNr0)rMrurhrvcCst||||_||_dSr:)rrrCrh)rrrMrurhrvrrrrszSymmetricalLogScale.__init__cCs|jjSr:rirrrrrjrkzSymmetricalLogScale.cCs|jjSr:)rCrurrrrrjrkcCs|jjSr:)rCrvrrrrrjrkcCsH|t||t|j|t||j|t dSr:) r)r rr*rrMr-rhr+rrrrrrs  z7SymmetricalLogScale.set_default_locators_and_formatterscCs|jS)zAReturn the `.SymmetricalLogTransform` associated with this scale.rFrrrrrsz!SymmetricalLogScale.get_transform) rr r!r"r.rrnrMrurvrrrrrrrs   rcs>eZdZdZZd fdd ZddZddZd d ZZ S) LogitTransformr0rJcs6ttjddg|d||_ddd||_dS)NrJrHrKTFrI)r1rrZ check_in_list _nonpositiverOrrLr8rrrs zLogitTransform.__init__cCsbtjddd"t|d|}Wdn1s60Y|jr^d||dk<d|d|k<|S)z,logit transform (base 10), masked or clippedrSrTr0NrYri)rZr[r_rO)rrarbrrrr<s 0  z#LogitTransform.transform_non_affinecCs t|jSr:)LogisticTransformrrrrrr=szLogitTransform.invertedcCsdt|j|jSNz{}({!r})rPrQrrrrrrrRszLogitTransform.__str__)rJ rr r!r>r?rr<r=rRr@rrr8rrs  rcs>eZdZdZZd fdd ZddZddZd d ZZ S) rr0rJcst||_dSr:)r1rrrr8rrrs zLogisticTransform.__init__cCsddd| S)zlogistic transform (base 10)rsr0rXrrfrrrr<sz&LogisticTransform.transform_non_affinecCs t|jSr:)rrrrrrr=szLogisticTransform.invertedcCsdt|j|jSrrrrrrrRszLogisticTransform.__str__)rJrrrr8rrs 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[. logitrJz \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)rrC _use_overline _one_half)rrrLrrrrrrs zLogitScale.__init__cCs|jS)z8Return the `.LogitTransform` associated with this scale.rFrrrrrszLogitScale.get_transformcCsN|t|t|j|jd|tdd|td|j|jddS)NrT)minor)rrr)r)rr*rrrr-r+rrrrrs z.LogitScale.set_default_locators_and_formatterscCs2t|sd}|dkr|n||dkr,d|n|fS)zH Limit the domain to values between 0 and 1 (excluded). gHz>rr0rlrrrrr-s  z LogitScale.limit_range_for_scaleN)rJ) rr r!r"r.rrrrrrrrrs r)r$r]rrrBrpcCsttS)z)Return the names of the available scales.)sorted_scale_mappingrrrrget_scale_namesAsrcKs@||kr"tjddd|}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_deprecatedrNr)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)rr.) scale_classrrrregister_scale]s rc CsPg}tD]8\}}t|jp"d}|d|dt|ddgq d|S)zF Helper function for generating docstrings related to scales. z z  ) ritemsinspectgetdocrextendtextwrapindentjoin)docsr.rrrrr_get_scale_docsis rz{%s}cCsg|] }t|qSr)repr).0r&rrr zrkr)Z scale_typeZ scale_docs)1r"rrnumpyrZrZ matplotlibr,rrZmatplotlib.tickerrrrrr r r r r rZmatplotlib.transformsrrrr#r/rArGrcrgrorrr}rrrrrrrrmaprrrZinterpdupdaterstriprrrrsR 0<"$*)1& 7@