3 ƽhG\@sdZddlZddlZddlZddlmZddlZddlmZm Z ddl m Z m Z m Z mZmZmZmZmZmZmZddlmZmZddlmZGdd d ZGd d d eZGd d d eZGdddeZGdddeZGdddeZGdddeZ Gddde Z!GdddeZ"GdddeZ#GdddeZ$GdddeZ%Gd d!d!eZ&Gd"d#d#eZ'ee e$e'ee!d$Z(d%d&Z)d'd(Z*e*jre*jd)d*j+e,e-e)ie*_d+d,Z.d-d.Z/e j0j1d/d*j+d0d1e)De/j2d2dS)3a Scales define the distribution of data values on an axis, e.g. a log scaling. They are attached to an `~.axis.Axis` and hold a `.Transform`, which is responsible for the actual data transformation. See also `.axes.Axes.set_xscale` and the scales examples in the documentation. N)ma)cbook docstring) NullFormatterScalarFormatterLogFormatterSciNotationLogitFormatter NullLocator LogLocator AutoLocatorAutoMinorLocatorSymmetricalLogLocator LogitLocator) TransformIdentityTransform)warn_deprecatedc@s0eZdZdZddZddZddZdd Zd S) 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` cKs&|r"tdddtt|dddS)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. z3.2z3.4z-ScaleBase got an unexpected keyword argument z(. This will become an error %(removal)s.)removalmessageN)rnextiter)selfaxiskwargsr6/tmp/pip-build-7iwl8md4/matplotlib/matplotlib/scale.py__init__,s zScaleBase.__init__cCs tdS)zq Return the :class:`~matplotlib.transforms.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_formattersIsz-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_scalePszScaleBase.limit_range_for_scaleN)__name__ __module__ __qualname____doc__rrrr#rrrrrs rcs4eZdZdZdZfddZddZddZZS) LinearScalez# The default linear scale. linearc stj|f|dS)z N)superr)rrr) __class__rrrbszLinearScale.__init__cCsj|jt|jt|jt|jdkr8tjdsL|jdkrZtjdrZ|j t n |j t dS)Nxzxtick.minor.visibleyzytick.minor.visible) set_major_locatorr set_major_formatterrset_minor_formatterr axis_namemplrcParamsset_minor_locatorr r )rrrrrrjs   z/LinearScale.set_default_locators_and_formatterscCstS)z Return the transform for linear scaling, which is just the `~matplotlib.transforms.IdentityTransform`. )r)rrrrrvszLinearScale.get_transform) r$r%r&r'namerrr __classcell__rr)r+rr([s   r(cs8eZdZdZdZZfddZddZddZZ S) FuncTransformzi A simple transform that takes and arbitrary function for the forward and inverse transform. cs4tjt|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)r*rcallable_forward_inverse ValueError)rforwardinverse)r+rrrs  zFuncTransform.__init__cCs |j|S)N)r:)rvaluesrrrtransform_non_affinesz"FuncTransform.transform_non_affinecCst|j|jS)N)r7r;r:)rrrrinvertedszFuncTransform.inverted) r$r%r&r' input_dims output_dimsrr@rAr6rr)r+rr7~s  r7c@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)r7 _transform)rr functionsr=r> transformrrrrs zFuncScale.__init__cCs|jS)z7Return the `.FuncTransform` associated with this scale.)rF)rrrrrszFuncScale.get_transformcCsj|jt|jt|jt|jdkr8tjdsL|jdkrZtjdrZ|j t n |j t dS)Nr,zxtick.minor.visibler-zytick.minor.visible) r.r r/rr0rr1r2r3r4r r )rrrrrrs   z-FuncScale.set_default_locators_and_formattersN)r$r%r&r'r5rrrrrrrrDs rDc@sDeZdZdZZejddddddZdd Zd d Z d d Z dS) LogTransformr8z3.3nonpos nonpositiveclipcCsBtj||dks|dkr"td||_tjddd|d|_dS)Nrr8z#The log base cannot be <= 0 or == 1TF)rLmask)rK)rrr<baserZ_check_getitem_clip)rrNrKrrrrs  zLogTransform.__init__cCs djt|j|j|jrdndS)Nz{}(base={}, nonpositive={!r})rLrM)formattyper$rNrO)rrrr__str__szLogTransform.__str__c Csxtjddd`tjtjdtjdtjij|j}|r>||}ntj|}|tj|j}|jrjd||dk<WdQRX|S)Nignore)divideinvalid iri) nperrstateeloglog2log10getrNrO)rar[outrrrr@s    z!LogTransform.transform_non_affinecCs t|jS)N)InvertedLogTransformrN)rrrrrAszLogTransform.invertedN)rL) r$r%r&rBrCr_rename_parameterrrRr@rArrrrrIs   rIc@s4eZdZdZZddZddZddZdd Zd S) rar8cCstj|||_dS)N)rrrN)rrNrrrrs zInvertedLogTransform.__init__cCsdjt|j|jS)Nz {}(base={}))rPrQr$rN)rrrrrRszInvertedLogTransform.__str__cCstj|j|S)N)rpowerrN)rr_rrrr@sz)InvertedLogTransform.transform_non_affinecCs t|jS)N)rIrN)rrrrrAszInvertedLogTransform.invertedN) r$r%r&rBrCrrRr@rArrrrras rac@steZdZdZdZejdddeddZejddded d Z d d Z ed dZ ddZ ddZ ddZdS)LogScalezT A standard logarithmic scale. Care is taken to only plot positive values. r[z3.3zscale.LogTransform) alternativecCstS)N)rI)rrrrrI szLogScale.LogTransformzscale.InvertedLogTransformcCstS)N)ra)rrrrraszLogScale.InvertedLogTransformcKst|dd}tjdd|dtjdd|dtjdd|ddd d d d d }|f|\}}}t|||_||_d S)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. r1r,z3.3rNsubsrJrKrWNrL)rNrfrKcSs |||fS)Nr)rNrfrKrrrr,sz#LogScale.__init__..__init__)getattrrrbrIrFrf)rrrr1rrNrfrKrrrrs  zLogScale.__init__cCs|jjS)N)rFrN)rrrr6szLogScale.cCsR|jt|j|jt|j|jt|j|j|jt|j|jdk ddS)N)Z labelOnlyBase)r.r rNr/rr4rfr0)rrrrrr8s z,LogScale.set_default_locators_and_formatterscCs|jS)z6Return the `.LogTransform` associated with this scale.)rF)rrrrrAszLogScale.get_transformcCs.tj|sd}|dkr|n||dkr(|n|fS)z$Limit the domain to positive values.gYnr)rXisfinite)rr r!r"rrrr#Es zLogScale.limit_range_for_scaleN)r$r%r&r'r5r deprecatedpropertyrIrarrNrrr#rrrrrds    rdc@s2eZdZdZdZd ddZeddZdd Zd S) FuncScaleLogzu Provide an arbitrary scale with user-supplied function for the axis and then put on a logarithmic axes. functionlogrWcCs&|\}}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)rfr7rIrF)rrrGrNr=r>rrrrVszFuncScaleLog.__init__cCs |jjjS)N)rF_brN)rrrrrNkszFuncScaleLog.basecCs|jS)z3Return the `.Transform` associated with this scale.)rF)rrrrroszFuncScaleLog.get_transformN)rW) r$r%r&r'r5rrkrNrrrrrrlNs   rlc@s,eZdZdZZddZddZddZdS) SymmetricalLogTransformr8cCsptj||dkrtd|dkr*td|dkr:td||_||_||_|d|jd|_tj||_ dS)Ng?z'base' must be larger than 1gz'linthresh' must be positivez'linscale' must be positiver8) rrr<rN linthreshlinscale _linscale_adjrXr[ _log_base)rrNrqrrrrrrws z SymmetricalLogTransform.__init__c Csptj|}tjddd<tj||j|jtj||j|j}||jk}WdQRX|||j||<|S)NrS)rTrU)rXabsrYsignrqrsr[rt)rr_abs_ar`insiderrrr@s z,SymmetricalLogTransform.transform_non_affinecCst|j|j|jS)N)InvertedSymmetricalLogTransformrNrqrr)rrrrrAs z SymmetricalLogTransform.invertedN)r$r%r&rBrCrr@rArrrrrots roc@s,eZdZdZZddZddZddZdS) ryr8cCsLtj|t|||}||_||_|j||_||_|d|jd|_dS)Ng?r8rp) rrrorNrqrH invlinthreshrrrs)rrNrqrrsymlogrrrrs   z(InvertedSymmetricalLogTransform.__init__c Csntj|}tjddd:tj||jtj|j||j|j}||jk}WdQRX|||j||<|S)NrS)rTrU) rXrurYrvrqrcrNrsrz)rr_rwr`rxrrrr@s z4InvertedSymmetricalLogTransform.transform_non_affinecCst|j|j|jS)N)rorNrqrr)rrrrrAsz(InvertedSymmetricalLogTransform.invertedN)r$r%r&rBrCrr@rArrrrrys  ryc@seZdZdZdZejdddeddZejddded d Z d d Z ed dZ eddZ eddZ ddZddZdS)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. r{z3.3zscale.SymmetricalLogTransform)recCstS)N)ro)rrrrrosz+SymmetricalLogScale.SymmetricalLogTransformz%scale.InvertedSymmetricalLogTransformcCstS)N)ry)rrrrrysz3SymmetricalLogScale.InvertedSymmetricalLogTransformc Kst|dd}tjdd|dtjdd|dtjdd|dtjdd|ddd dd d d d }|f|\}}}}t||||_||_dS)Nr1r,z3.3rNrqrfrrrWrVr8)rNrqrfrrc[s.|r"tdddtt|dd||||fS)Nz3.2z3.4z7SymmetricalLogScale got an unexpected keyword argument z(. This will become an error %(removal)s.)rr)rrr)rNrqrfrrrrrrrs z.SymmetricalLogScale.__init__..__init__)rgrrbrorFrf) rrrr1rrNrqrfrrrrrrs  zSymmetricalLogScale.__init__cCs|jjS)N)rFrN)rrrrrhszSymmetricalLogScale.cCs|jjS)N)rFrq)rrrrrhscCs|jjS)N)rFrr)rrrrrhscCsH|jt|j|jt|j|jt|j|j|jt dS)N) r.r rr/rrNr4rfr0r)rrrrrrs   z7SymmetricalLogScale.set_default_locators_and_formatterscCs|jS)zAReturn the `.SymmetricalLogTransform` associated with this scale.)rF)rrrrrsz!SymmetricalLogScale.get_transformN)r$r%r&r'r5rrjrkroryrrNrqrrrrrrrrr|s    r|c@sDeZdZdZZejddddddZdd Zd d Z d d Z dS)LogitTransformr8z3.3rJrKrMcCs6tj|tjddg|d||_ddd||_dS)NrMrL)rKTF)rLrM)rrr_check_in_list _nonpositiverO)rrKrrrrs zLogitTransform.__init__c CsNtjdddtj|d|}WdQRX|jrJd||dk<d|d|k<|S)z,logit transform (base 10), masked or clippedrS)rTrUr8Niri)rXrYr]rO)rr_r`rrrr@ s   z#LogitTransform.transform_non_affinecCs t|jS)N)LogisticTransformr)rrrrrAszLogitTransform.invertedcCsdjt|j|jS)Nz{}({!r}))rPrQr$r)rrrrrRszLogitTransform.__str__N)rM) r$r%r&rBrCrrbrr@rArRrrrrr}s    r}c@sDeZdZdZZejddddddZdd Zd d Z d d Z dS)rr8z3.3rJrKrMcCstj|||_dS)N)rrr)rrKrrrr s zLogisticTransform.__init__cCsddd| S)zlogistic transform (base 10)g?r8rWr)rr_rrrr@%sz&LogisticTransform.transform_non_affinecCs t|jS)N)r}r)rrrrrA)szLogisticTransform.invertedcCsdjt|j|jS)Nz{}({!r}))rPrQr$r)rrrrrR,szLogisticTransform.__str__N)rM) r$r%r&rBrCrrbrr@rArRrrrrrs   rc@sLeZdZdZdZejddddddd d d Zd d ZddZ ddZ dS) 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[. logitz3.3rJrKrMz \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)r}rF _use_overline _one_half)rrrKrrrrrr9s zLogitScale.__init__cCs|jS)z8Return the `.LogitTransform` associated with this scale.)rF)rrrrrOszLogitScale.get_transformcCsN|jt|jt|j|jd|jtdd|jtd|j|jddS)N)rrT)minor)rrr)r.rr/rrrr4r0)rrrrrrSs  z.LogitScale.set_default_locators_and_formatterscCs2tj|sd}|dkr|n||dkr,d|n|fS)zH Limit the domain to values between 0 and 1 (excluded). gHz>rr8)rXri)rr r!r"rrrr#fs z LogitScale.limit_range_for_scaleN)rM) r$r%r&r'r5rrbrrrr#rrrrr0s r)r)r[r{rrErmcCsttS)z)Return the names of the available scales.)sorted_scale_mappingrrrrget_scale_nameszsrcKs&|j}tjt|dt||f|S)z Return a scale class by name. Parameters ---------- scale : {%(names)s} axis : `matplotlib.axis.Axis` )scale)lowerrr~r)rrrrrr scale_factorys 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_scales rcCsLg}xsr)Z scale_typeZ scale_docs)3r'rrnumpyrXrZ matplotlibr2rrZmatplotlib.tickerrrrrr r r r r rZmatplotlib.transformsrrZmatplotlib.cbookrrr(r7rDrIrardrlroryr|r}rrrrrrmaprrrZinterpdupdaterstriprrrrsN 0 A#$**G& TA