B d0T@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. N)selfaxisrr]/work/yifan.wang/ringdown/master-ringdown-env/lib/python3.7/site-packages/matplotlib/scale.py__init__4s zScaleBase.__init__cCs tdS)zL Return the `.Transform` object associated with this scale. N)NotImplementedError)rrrr get_transformBszScaleBase.get_transformcCs tdS)zi Set the locators and formatters of *axis* to instances suitable for this scale. N)r)rrrrr#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. r)rvminvmaxminposrrrlimit_range_for_scaleOszScaleBase.limit_range_for_scaleN)__name__ __module__ __qualname____doc__rrrrrrrrrs rc@s,eZdZdZdZddZddZddZd S) LinearScalez# The default linear scale. linearcCsdS)z Nr)rrrrrraszLinearScale.__init__cCsj|t|t|t|jdkr8tjdsL|jdkrZtjdrZ| t n | t dS)Nxzxtick.minor.visibleyzytick.minor.visible) set_major_locatorr set_major_formatterrset_minor_formatterr axis_namemplrcParamsset_minor_locatorr r )rrrrrrhs   z/LinearScale.set_default_locators_and_formatterscCstS)z Return the transform for linear scaling, which is just the `~matplotlib.transforms.IdentityTransform`. )r)rrrrrtszLinearScale.get_transformN)rrr 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 ||S)N)r2)rvaluesrrrtransform_non_affinesz"FuncTransform.transform_non_affinecCst|j|jS)N)r.r3r2)rrrrinvertedszFuncTransform.inverted) rrr r! input_dims output_dimsrr9r: __classcell__rr)r7rr.|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 functionsr5r6 transformrrrrs zFuncScale.__init__cCs|jS)z7Return the `.FuncTransform` associated with this scale.)r@)rrrrrszFuncScale.get_transformcCsj|t|t|t|jdkr8tjdsL|jdkrZtjdrZ| t n | t dS)Nr$zxtick.minor.visibler%zytick.minor.visible) r&r r'rr(rr)r*r+r,r r )rrrrrrs   z-FuncScale.set_default_locators_and_formattersN)rrr r!r-rrrrrrrr>s r>cs>eZdZdZZd fdd ZddZddZd d ZZ S) LogTransformr/clipcsBt|dks|dkr"td||_tjddd|d|_dS)Nrr/z#The log base cannot be <= 0 or == 1TF)rDmask) nonpositive)r0rr4baser check_getitem_clip)rrGrF)r7rrrs  zLogTransform.__init__cCs dt|j|j|jrdndS)Nz{}(base={}, nonpositive={!r})rDrE)formattyperrGrI)rrrr__str__szLogTransform.__str__c Csxtjddd`tjtjdtjdtji|j}|r>||}nt|}|t|j}|jrjd||dk<WdQRX|S)Nignore)divideinvalid ir) nperrstateeloglog2log10getrGrI)rarUoutrrrr9s    z!LogTransform.transform_non_affinecCs t|jS)N)InvertedLogTransformrG)rrrrr:szLogTransform.inverted)rD) rrr r;r<rrLr9r:r=rr)r7rrCs rCcs<eZdZdZZfddZddZddZdd ZZ S) r[r/cst||_dS)N)r0rrG)rrG)r7rrrs zInvertedLogTransform.__init__cCsdt|j|jS)Nz {}(base={}))rJrKrrG)rrrrrLszInvertedLogTransform.__str__cCst|j|S)N)rpowerrG)rrYrrrr9sz)InvertedLogTransform.transform_non_affinecCs t|jS)N)rCrG)rrrrr:szInvertedLogTransform.inverted) rrr r;r<rrLr9r:r=rr)r7rr[s  r[c@sJeZdZdZdZddddddZed d Zd d Zd dZ ddZ dS)LogScalezT A standard logarithmic scale. Care is taken to only plot positive values. rUrQNrD)rGsubsrFcCst|||_||_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)rCr@r^)rrrGr^rFrrrr s zLogScale.__init__cCs|jjS)N)r@rG)rrrrzLogScale.cCsR|t|j|t|j|t|j|j|t|j|jdk ddS)N)Z labelOnlyBase)r&r rGr'rr,r^r()rrrrrrs z,LogScale.set_default_locators_and_formatterscCs|jS)z6Return the `.LogTransform` associated with this scale.)r@)rrrrr(szLogScale.get_transformcCs.t|sd}|dkr|n||dkr(|n|fS)z$Limit the domain to positive values.gYnr)rRisfinite)rrrrrrrr,s zLogScale.limit_range_for_scale) rrr r!r-rpropertyrGrrrrrrrr]s  r]c@s2eZdZdZdZd ddZeddZdd Zd S) FuncScaleLogzu Provide an arbitrary scale with user-supplied function for the axis and then put on a logarithmic axes. functionlogrQcCs&|\}}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)r^r.rCr@)rrrArGr5r6rrrr=szFuncScaleLog.__init__cCs |jjjS)N)r@_brG)rrrrrGRszFuncScaleLog.basecCs|jS)z3Return the `.Transform` associated with this scale.)r@)rrrrrVszFuncScaleLog.get_transformN)rQ) rrr r!r-rrbrGrrrrrrc5s   rccs4eZdZdZZfddZddZddZZS)SymmetricalLogTransformr/cspt|dkrtd|dkr*td|dkr:td||_||_||_|d|jd|_t||_ dS)Ng?z'base' must be larger than 1gz'linthresh' must be positivez'linscale' must be positive) r0rr4rG linthreshlinscale _linscale_adjrRrU _log_base)rrGrhri)r7rrr^s z SymmetricalLogTransform.__init__c Cspt|}tjddd<t||j|jt||j|j}||jk}WdQRX|||j||<|S)NrM)rNrO)rRabsrSsignrhrjrUrk)rrYabs_arZinsiderrrr9ls z,SymmetricalLogTransform.transform_non_affinecCst|j|j|jS)N)InvertedSymmetricalLogTransformrGrhri)rrrrr:vs z SymmetricalLogTransform.inverted) rrr r;r<rr9r:r=rr)r7rrf[s  rfcs4eZdZdZZfddZddZddZZS)rpr/csLtt|||}||_||_|||_||_|d|jd|_dS)Ng?rg) r0rrfrGrhrB invlinthreshrirj)rrGrhrisymlog)r7rrr~s   z(InvertedSymmetricalLogTransform.__init__c Csnt|}tjddd:t||jt|j||j|j}||jk}WdQRX|||j||<|S)NrM)rNrO) rRrlrSrmrhr\rGrjrq)rrYrnrZrorrrr9s z4InvertedSymmetricalLogTransform.transform_non_affinecCst|j|j|jS)N)rfrGrhri)rrrrr:sz(InvertedSymmetricalLogTransform.inverted) rrr r;r<rr9r:r=rr)r7rrp{s  rpc@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. rrrQrPNr/)rGrhr^ricCst||||_||_dS)N)rfr@r^)rrrGrhr^rirrrrszSymmetricalLogScale.__init__cCs|jjS)N)r@rG)rrrrr_r`zSymmetricalLogScale.cCs|jjS)N)r@rh)rrrrr_r`cCs|jjS)N)r@ri)rrrrr_r`cCsH|t||t|j|t||j|t dS)N) r&r rr'rrGr,r^r(r)rrrrrrs   z7SymmetricalLogScale.set_default_locators_and_formatterscCs|jS)zAReturn the `.SymmetricalLogTransform` associated with this scale.)r@)rrrrrsz!SymmetricalLogScale.get_transform) rrr r!r-rrbrGrhrirrrrrrrss   rscs>eZdZdZZd fdd ZddZddZd d ZZ S) LogitTransformr/rEcs6ttjddg|d||_ddd||_dS)NrErD)rFTF)rDrE)r0rrZ check_in_list _nonpositiverI)rrF)r7rrrs zLogitTransform.__init__c CsNtjdddt|d|}WdQRX|jrJd||dk<d|d|k<|S)z,logit transform (base 10), masked or clippedrM)rNrOr/Niri)rRrSrWrI)rrYrZrrrr9s   z#LogitTransform.transform_non_affinecCs t|jS)N)LogisticTransformru)rrrrr:szLogitTransform.invertedcCsdt|j|jS)Nz{}({!r}))rJrKrru)rrrrrLszLogitTransform.__str__)rE) rrr r;r<rr9r:rLr=rr)r7rrts  rtcs>eZdZdZZd fdd ZddZddZd d ZZ S) rvr/rEcst||_dS)N)r0rru)rrF)r7rrrs zLogisticTransform.__init__cCsddd| S)zlogistic transform (base 10)g?r/rQr)rrYrrrr9sz&LogisticTransform.transform_non_affinecCs t|jS)N)rtru)rrrrr:szLogisticTransform.invertedcCsdt|j|jS)Nz{}({!r}))rJrKrru)rrrrrLszLogisticTransform.__str__)rE) rrr r;r<rr9r:rLr=rr)r7rrvs rvc@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[. logitrEz \frac{1}{2}F)one_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)rtr@ _use_overline _one_half)rrrFryrzrrrrs zLogitScale.__init__cCs|jS)z8Return the `.LogitTransform` associated with this scale.)r@)rrrrrszLogitScale.get_transformcCsN|t|t|j|jd|tdd|td|j|jddS)N)ryrzT)minor)r}ryrz)r&rr'rr|r{r,r()rrrrrrs  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>rr/)rRra)rrrrrrrr-s z LogitScale.limit_range_for_scaleN)rE) rrr r!r-rrrrrrrrrwsrw)r#rUrrrxr?rdcCsttS)z)Return the names of the available scales.)sorted_scale_mappingrrrrget_scale_namesAsrcKs<||kr"tjddd|}tjt|d}||f|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_deprecatedrHr)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 CsTg}xDtD]8\}}t|jp$d}|d|dt|ddgqWd|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 zsr)Z scale_typeZ scale_docs)1r!rrnumpyrRrZ matplotlibr*rrZmatplotlib.tickerrrrrr r r r r rZmatplotlib.transformsrrrr"r.r>rCr[r]rcrfrprsrtrvrwrrrrmaprrrZinterpdupdaterstriprrrr sL 0<"$*)1& 7@