a BCCfRC@snddlmZddlZddlZddlZddlZddlZddlm Z ddl m Z ddl m Z mZddlmZddlmZmZdd lmZdd lmZdd lmZdd lmZdd lmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+ddlZ,ddl-m.Z.m/Z/ddl0m1Z1ddl2m3Z3ddddZ4dZ5dZ6dZ7dZ8dZ9dZ:dZ;dZdZ?d Z@d!ZAd"ZBd#ZCd$ZDd%ZEd&ZFd'ZGd(ZHd)ZId*ZJd+Ke4d,e5e6e7e:e;ee?e@eAeBeCeDeFeGeHeIeJgZLd-ZMd.ZNd/ZOd0ZPd+KeMeLd1eOgZQd+KeMeLgZRe5e6e7e:e;ee?eAeBeCe@eDeJeGeIeHeFeLeMeNeOeQeRePd2ZSeSTZUe8eUd3<e9eUd4<eEeUd5<gd6ZVeVD]ZWeUeWXd7d+eUeW<qXgd8ZYeYD]ZWeUeWXd9d:eUeW<qeUZd;eUZd<d+Kd=d>eVDZLe4d,eLeUd?<eMXd@dAeUdB<dCZNeNeUdD<dEZ[dFZ\e[eUdG<e\eUdH<d+KeUdBeUd?gZReReUdI<d+KeUdBeUd?eUdDeUdGgZ]e]eUdJ<dKd>e^DD]ZWe_dLeWq`[Wd|dMdNZ`dOdPZadQdRZbdSdTZcdUdVZddWdXZeGdYdZdZZfGd[d\d\efZgGd]d^d^efZhd_d`ZidaZjGdbdcdcZkGdddedeZldfdgZmGdhd@d@ekZndidjZodkdlZpGdmdAdAekZqd}dqdrZrd~dtduZsGdvdwdweqZtdxdyZudzd{ZvdS))getfullargspec_no_selfN) zip_longest)doccer)distcont distdiscrete)check_random_state)combentr)optimize) integrate) _derivative)stats)arangeputmaskonesshapendarrayzerosfloor logical_andlogsqrtplaceargmax vectorizeasarraynaninfisinfempty)_XMAX_LOGXMAX) CensoredData)FitErrorz Methods ------- z Notes ----- z Examples -------- )methodsnotesZexampleszPrvs(%(shapes)s, loc=0, scale=1, size=1, random_state=None) Random variates. zEpdf(x, %(shapes)s, loc=0, scale=1) Probability density function. zSlogpdf(x, %(shapes)s, loc=0, scale=1) Log of the probability density function. zBpmf(k, %(shapes)s, loc=0, scale=1) Probability mass function. zPlogpmf(k, %(shapes)s, loc=0, scale=1) Log of the probability mass function. zIcdf(x, %(shapes)s, loc=0, scale=1) Cumulative distribution function. zWlogcdf(x, %(shapes)s, loc=0, scale=1) Log of the cumulative distribution function. z}sf(x, %(shapes)s, loc=0, scale=1) Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate). zGlogsf(x, %(shapes)s, loc=0, scale=1) Log of the survival function. zdppf(q, %(shapes)s, loc=0, scale=1) Percent point function (inverse of ``cdf`` --- percentiles). zVisf(q, %(shapes)s, loc=0, scale=1) Inverse survival function (inverse of ``sf``). zYmoment(order, %(shapes)s, loc=0, scale=1) Non-central moment of the specified order. zostats(%(shapes)s, loc=0, scale=1, moments='mv') Mean('m'), variance('v'), skew('s'), and/or kurtosis('k'). zJentropy(%(shapes)s, loc=0, scale=1) (Differential) entropy of the RV. afit(data) Parameter estimates for generic data. See `scipy.stats.rv_continuous.fit `__ for detailed documentation of the keyword arguments. zexpect(func, args=(%(shapes_)s), loc=0, scale=1, lb=None, ub=None, conditional=False, **kwds) Expected value of a function (of one argument) with respect to the distribution. zexpect(func, args=(%(shapes_)s), loc=0, lb=None, ub=None, conditional=False) Expected value of a function (of one argument) with respect to the distribution. zCmedian(%(shapes)s, loc=0, scale=1) Median of the distribution. z?mean(%(shapes)s, loc=0, scale=1) Mean of the distribution. zBvar(%(shapes)s, loc=0, scale=1) Variance of the distribution. zLstd(%(shapes)s, loc=0, scale=1) Standard deviation of the distribution. zminterval(confidence, %(shapes)s, loc=0, scale=1) Confidence interval with equal areas around the median. r%zAs an instance of the `rv_continuous` class, `%(name)s` object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution. a+ Alternatively, the object may be called (as a function) to fix the shape, location, and scale parameters returning a "frozen" continuous RV object: rv = %(name)s(%(shapes)s, loc=0, scale=1) - Frozen RV object with the same methods but holding the given shape, location, and scale fixed. aExamples -------- >>> import numpy as np >>> from scipy.stats import %(name)s >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1) Calculate the first four moments: %(set_vals_stmt)s >>> mean, var, skew, kurt = %(name)s.stats(%(shapes)s, moments='mvsk') Display the probability density function (``pdf``): >>> x = np.linspace(%(name)s.ppf(0.01, %(shapes)s), ... %(name)s.ppf(0.99, %(shapes)s), 100) >>> ax.plot(x, %(name)s.pdf(x, %(shapes)s), ... 'r-', lw=5, alpha=0.6, label='%(name)s pdf') Alternatively, the distribution object can be called (as a function) to fix the shape, location and scale parameters. This returns a "frozen" RV object holding the given parameters fixed. Freeze the distribution and display the frozen ``pdf``: >>> rv = %(name)s(%(shapes)s) >>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf') Check accuracy of ``cdf`` and ``ppf``: >>> vals = %(name)s.ppf([0.001, 0.5, 0.999], %(shapes)s) >>> np.allclose([0.001, 0.5, 0.999], %(name)s.cdf(vals, %(shapes)s)) True Generate random numbers: >>> r = %(name)s.rvs(%(shapes)s, size=1000) And compare the histogram: >>> ax.hist(r, density=True, bins='auto', histtype='stepfilled', alpha=0.2) >>> ax.set_xlim([x[0], x[-1]]) >>> ax.legend(loc='best', frameon=False) >>> plt.show() aThe probability density above is defined in the "standardized" form. To shift and/or scale the distribution use the ``loc`` and ``scale`` parameters. Specifically, ``%(name)s.pdf(x, %(shapes)s, loc, scale)`` is identically equivalent to ``%(name)s.pdf(y, %(shapes)s) / scale`` with ``y = (x - loc) / scale``. Note that shifting the location of a distribution does not make it a "noncentral" distribution; noncentral generalizations of some distributions are available in separate classes.  )rvspdflogpdfcdflogcdfsflogsfppfisfrentropyfitmomentexpectintervalmeanstdvarmedian allmethods longsummary frozennoteexampledefault before_notes after_notespmflogpmfr5)r)rBrCr,r-r.r/r0r1rr2r5r:r7r9r8r6z , scale=1)r,r-r.r/z(x, z(k, r*r+cCsg|] }t|qS)docdict_discrete).0objrDrD]/var/www/html/django/DPS/env/lib/python3.9/site-packages/scipy/stats/_distn_infrastructure.py rIr; rv_continuous rv_discreter<a Alternatively, the object may be called (as a function) to fix the shape and location parameters returning a "frozen" discrete RV object: rv = %(name)s(%(shapes)s, loc=0) - Frozen RV object with the same methods but holding the given shape and location fixed. r=aExamples -------- >>> import numpy as np >>> from scipy.stats import %(name)s >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1) Calculate the first four moments: %(set_vals_stmt)s >>> mean, var, skew, kurt = %(name)s.stats(%(shapes)s, moments='mvsk') Display the probability mass function (``pmf``): >>> x = np.arange(%(name)s.ppf(0.01, %(shapes)s), ... %(name)s.ppf(0.99, %(shapes)s)) >>> ax.plot(x, %(name)s.pmf(x, %(shapes)s), 'bo', ms=8, label='%(name)s pmf') >>> ax.vlines(x, 0, %(name)s.pmf(x, %(shapes)s), colors='b', lw=5, alpha=0.5) Alternatively, the distribution object can be called (as a function) to fix the shape and location. This returns a "frozen" RV object holding the given parameters fixed. Freeze the distribution and display the frozen ``pmf``: >>> rv = %(name)s(%(shapes)s) >>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1, ... label='frozen pmf') >>> ax.legend(loc='best', frameon=False) >>> plt.show() Check accuracy of ``cdf`` and ``ppf``: >>> prob = %(name)s.cdf(x, %(shapes)s) >>> np.allclose(x, %(name)s.ppf(prob, %(shapes)s)) True Generate random numbers: >>> r = %(name)s.rvs(%(shapes)s, size=1000) zThe probability mass function above is defined in the "standardized" form. To shift distribution use the ``loc`` parameter. Specifically, ``%(name)s.pmf(k, %(shapes)s, loc)`` is identically equivalent to ``%(name)s.pmf(k - loc, %(shapes)s)``. r>rAr@r?cCsg|]}|dr|qS)Z_doc_) startswith)rFsrDrDrHrIfrJzdel cCs |dur|}|||SN)r7)datanmurDrDrH_momentksrSc Csz|dkr dS|dkr6|dur.|dg|R}n|}n@|dkrp|dusN|dur`|dg|R}n |||}n|dkr|dus|dus|dur|dg|R}n,|t|d}|d|||||}n|dkrf|dus|dus|dus|dur|dg|R}nP|d|d } |t|d}| d||d |||||||}n||g|R}|S) Nr?r?@@)nppower) rQrRmu2g1g2Z moment_funcargsvalmu3mu4rDrDrH_moment_from_statsqs. (2recCsBt|}|}||d}||d}|t|dS)z8 skew is third central moment / variance**(1.5) rUrVrW)r\ravelr7r])rPrRm2Zm3rDrDrH_skews  rhcCsBt|}|}||d}||d}||ddS)z4kurtosis is fourth central moment / variance**2 - 3.rUrXrV)r\rfr7)rPrRrgZm4rDrDrH _kurtosiss  ric Csvt|srt|trr|ds$d|}|dkr0d}ztt|}Wn2typ}ztd||WYd}~n d}~00|S)NZfmin_fminz%s is not a valid optimizer)callable isinstancestrrMgetattrr AttributeError ValueError) optimizererDrDrH_fit_determine_optimizers $rscCs,t|}|jt|}t|||fS)a For a 1D array x, return a tuple containing the sum of the finite values of x and the number of nonfinite values. This is a utility function used when evaluating the negative loglikelihood for a distribution and an array of samples. Examples -------- >>> import numpy as np >>> from scipy.stats._distn_infrastructure import _sum_finite >>> tot, nbad = _sum_finite(np.array([-2, -np.inf, 5, 1])) >>> tot 4.0 >>> nbad 1 )r\isfinitesize count_nonzerosum)xZfinite_xZ bad_countrDrDrH _sum_finites ryc@seZdZddZeddZejddZddZdd Zd d Z d d Z d+ddZ ddZ ddZ d,ddZddZddZddZddZd-d d!Zd"d#Zd.d$d%Zd/d'd(Zd)d*ZdS)0 rv_frozencOsR||_||_|jfi||_|jj|i|\}}}|jj|\|_|_dSrO) rakwds __class___updated_ctor_paramdist _parse_args _get_supportab)selfr~rar{shapes_rDrDrH__init__s zrv_frozen.__init__cCs|jjSrO)r~ _random_staterrDrDrH random_stateszrv_frozen.random_statecCst||j_dSrO)rr~rrseedrDrDrHrscCs|jj|g|jRi|jSrO)r~r,rar{rrxrDrDrHr,sz rv_frozen.cdfcCs|jj|g|jRi|jSrO)r~r-rar{rrDrDrHr-szrv_frozen.logcdfcCs|jj|g|jRi|jSrO)r~r0rar{rqrDrDrHr0sz rv_frozen.ppfcCs|jj|g|jRi|jSrO)r~r1rar{rrDrDrHr1sz rv_frozen.isfNcCs.|j}|||d|jj|ji|S)Nrur)r{copyupdater~r)ra)rrurr{rDrDrHr)s z rv_frozen.rvscCs|jj|g|jRi|jSrO)r~r.rar{rrDrDrHr.sz rv_frozen.sfcCs|jj|g|jRi|jSrO)r~r/rar{rrDrDrHr/szrv_frozen.logsfmvcCs,|j}|d|i|jj|ji|SNmoments)r{rrr~rra)rrr{rDrDrHrs zrv_frozen.statscCs|jj|ji|jSrO)r~r:rar{rrDrDrHr:szrv_frozen.mediancCs|jj|ji|jSrO)r~r7rar{rrDrDrHr7szrv_frozen.meancCs|jj|ji|jSrO)r~r9rar{rrDrDrHr9sz rv_frozen.varcCs|jj|ji|jSrO)r~r8rar{rrDrDrHr8sz rv_frozen.stdcCs|jj|g|jRi|jSrO)r~r4rar{)rorderrDrDrHr4szrv_frozen.momentcCs|jj|ji|jSrO)r~r2rar{rrDrDrHr2 szrv_frozen.entropycCs|jj|g|jRi|jSrO)r~r6rar{)r confidencerDrDrHr6 szrv_frozen.intervalFc Ksj|jj|ji|j\}}}t|jtrF|jj||||||fi|S|jj|||||||fi|SdSrO)r~rrar{rlrLr5) rfunclbub conditionalr{rlocscalerDrDrHr5s zrv_frozen.expectcCs|jj|ji|jSrO)r~supportrar{rrDrDrHrszrv_frozen.support)NN)r)N)N)NNNF)__name__ __module__ __qualname__rpropertyrsetterr,r-r0r1r)r.r/rr:r7r9r8r4r2r6r5rrDrDrDrHrzs,        rzc@seZdZddZddZdS)rv_discrete_frozencCs|jj|g|jRi|jSrO)r~rBrar{rkrDrDrHrB!szrv_discrete_frozen.pmfcCs|jj|g|jRi|jSrO)r~rCrar{rrDrDrHrC$szrv_discrete_frozen.logpmfN)rrrrBrCrDrDrDrHrsrc@seZdZddZddZdS)rv_continuous_frozencCs|jj|g|jRi|jSrO)r~r*rar{rrDrDrHr**szrv_continuous_frozen.pdfcCs|jj|g|jRi|jSrO)r~r+rar{rrDrDrHr+-szrv_continuous_frozen.logpdfN)rrrr*r+rDrDrDrHr(srcsjtj|}t|ttfs|f}trPtjg|R^}dd|DSjfdd|DS)aClean arguments to: 1. Ensure all arguments are iterable (arrays of dimension at least one 2. If cond != True and size > 1, ravel(args[i]) where ravel(condition) is True, in 1D. Return list of processed arguments. Examples -------- >>> import numpy as np >>> from scipy.stats._distn_infrastructure import argsreduce >>> rng = np.random.default_rng() >>> A = rng.random((4, 5)) >>> B = 2 >>> C = rng.random((1, 5)) >>> cond = np.ones(A.shape) >>> [A1, B1, C1] = argsreduce(cond, A, B, C) >>> A1.shape (4, 5) >>> B1.shape (1,) >>> C1.shape (1, 5) >>> cond[2,:] = 0 >>> [A1, B1, C1] = argsreduce(cond, A, B, C) >>> A1.shape (15,) >>> B1.shape (1,) >>> C1.shape (15,) cSsg|] }|qSrD)rfrFargrDrDrHrI_rJzargsreduce..c s2g|]*}t|dkr|ntt|qSr)r\ruextractZ broadcast_torcondrNrDrHrIds)r\ atleast_1drllisttupleallbroadcast_arraysr)rraZnewargsrDrrH argsreduce1s$   ra def _parse_args(self, %(shape_arg_str)s %(locscale_in)s): return (%(shape_arg_str)s), %(locscale_out)s def _parse_args_rvs(self, %(shape_arg_str)s %(locscale_in)s, size=None): return self._argcheck_rvs(%(shape_arg_str)s %(locscale_out)s, size=size) def _parse_args_stats(self, %(shape_arg_str)s %(locscale_in)s, moments='mv'): return (%(shape_arg_str)s), %(locscale_out)s, moments cspeZdZdZdRfdd ZeddZejddZdd Zd d Z d d Z ddZ dSddZ dTddZ ddZddZeje_ddZddZddZdd Zd!d"Zd#d$Zd%d&Zddd'd(d)Zd*d+Zd,d-Zd.d/Zd0d1Zd2d3Zd4d5Zd6d7Zd8d9Zd:d;Z dd?Z"d@dAZ#dBdCZ$dDdEZ%dFdGZ&dHdIZ'dJdKZ(dLdMZ)dNdOZ*dPdQZ+Z,S)U rv_genericz^Class which encapsulates common functionality between rv_discrete and rv_continuous. NcsBtt|j}|jdup0d|jvp0d|jv|_t||_ dSr) superr_getfullargspec_statsvarkwra kwonlyargs_stats_has_momentsrr)rrsigr|rDrHr{s   zrv_generic.__init__cCs|jS)aGet or set the generator object for generating random variates. If `random_state` is None (or `np.random`), the `numpy.random.RandomState` singleton is used. If `random_state` is an int, a new ``RandomState`` instance is used, seeded with `random_state`. If `random_state` is already a ``Generator`` or ``RandomState`` instance, that instance is used. )rrrDrDrHrs zrv_generic.random_statecCst||_dSrO)rrrrDrDrHrscCsLz|j||Wn.tyF|d|_|d|_|Yn0dSNrr)__dict__r_attach_methodsrp _ctor_paramrr)rstaterDrDrH __setstate__s     zrv_generic.__setstate__cCstdS)aAttaches dynamically created methods to the rv_* instance. This method must be overridden by subclasses, and must itself call _attach_argparser_methods. This method is called in __init__ in subclasses, and in __setstate__ N)NotImplementedErrorrrDrDrHrszrv_generic._attach_methodscCs6i}t|j|dD]}t||t|||qdS)z Generates the argument-parsing functions dynamically and attaches them to the instance. Should be called from `_attach_methods`, typically in __init__ and during unpickling (__setstate__) r_parse_args_stats_parse_args_rvsN)exec_parse_arg_templatesetattrtypes MethodType)rnsnamerDrDrH_attach_argparser_methodss z$rv_generic._attach_argparser_methodsc Cs`|jr^t|jtstd|jdd}|D]*}t|rFtdt d|s0tdq0ng}|D]l}t |}|j dd} | rf| | |jdurtd |jdurtd |jrtd |jdurftd qf|r|d }|D]} | |krtdqng}|rd|dnd} t| ||d} t| |_|r@d|nd|_t|ds\t||_dS)aConstruct the parser string for the shape arguments. This method should be called in __init__ of a class for each distribution. It creates the `_parse_arg_template` attribute that is then used by `_attach_argparser_methods` to dynamically create and attach the `_parse_args`, `_parse_args_stats`, `_parse_args_rvs` methods to the instance. If self.shapes is a non-empty string, interprets it as a comma-separated list of shape parameters. Otherwise inspects the call signatures of `meths_to_inspect` and constructs the argument-parsing functions from these. In this case also sets `shapes` and `numargs`. zshapes must be a string., z"keywords cannot be used as shapes.z^[_a-zA-Z][_a-zA-Z0-9]*$z'shapes must be valid python identifiersrNz+*args are not allowed w/out explicit shapesz,**kwds are not allowed w/out explicit shapesz1kwonly args are not allowed w/out explicit shapesz#defaults are not allowed for shapesrz!Shape arguments are inconsistent., r')Z shape_arg_str locscale_in locscale_outnumargs)rrlrm TypeErrorreplacesplitkeyword iskeyword SyntaxErrorrematchrraappendvarargsrrdefaultsjoindictparse_arg_templaterhasattrlenr) rmeths_to_inspectrrrfieldZ shapes_listmethZ shapes_argsraitemZ shapes_strdctrDrDrH_construct_argparsers\           zrv_generic._construct_argparserc Csd|}|jpd|d<|jpd|d<|dur0d}ddd |D}||d <|jpTd|d <|jrz|jd krz|d d 7<|jrd|jd||d<nd|d<|jdurdD]}||dd||<qtdD]v}|jdur|jdd|_zt |j||_Wqt yD}z(t d|jdt ||WYd}~qd}~00q|jdddd|_dS)z;Construct the instance docstring with string substitutions.distnamerr'rNrDrcss|]}d|VqdS)z%.3gNrD)rFrbrDrDrH rJz,rv_generic._construct_doc..valsZshapes_rrz>>> z = Z set_vals_stmt)r?r@z- %(shapes)s : array_like shape parametersrUz %(shapes)s, z0Unable to construct docstring for distribution "z": z(, (z, ))) rrrrrrrange__doc__rZ docformatr Exceptionrepr)rdocdictZ shapes_valsZtempdictrrirrrDrDrH_construct_docs@    zrv_generic._construct_doc continuouscCs>|dur d}d|d|ddtddg|_||dS) z7Construct instance docstring from the default template.NAr'rz random variable.z %(before_notes)s r&z %(example)s)r docheadersrr)rlongnamerdiscreterDrDrH_construct_default_doc4sz!rv_generic._construct_default_doccOs:t|tr t|g|Ri|St|g|Ri|SdS)aFreeze the distribution for the given arguments. Parameters ---------- arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution. Should include all the non-optional arguments, may include ``loc`` and ``scale``. Returns ------- rv_frozen : rv_frozen instance The frozen distribution. N)rlrKrrrrar{rDrDrHfreeze>s zrv_generic.freezecOs|j|i|SrO)rrrDrDrH__call__Rszrv_generic.__call__cOsdS)NNNNNrDrrDrDrHrYszrv_generic._statscGsBtjdd"|j|g|R}Wdn1s40Y|S)Nignore)r)r\errstategeneric_moment)rrQrarrDrDrH_munp_s0zrv_generic._munpc s|dd}tj|}ddfdd|D}|dj}|dj}|durR|}ntt|}|t|}|dkrd| |}n|dkrd||}tddt ||D} | st d |d |d ||dd } |d } |d } | | | |fS) NrucSs&|jdkr"|jddkr"|d}q|Sr)ndimr)rrDrDrH squeeze_leftss z.rv_generic._argcheck_rvs..squeeze_leftcsg|] }|qSrDrD)rFrrrDrHrIrJz,rv_generic._argcheck_rvs..rrcSs g|]\}}|dkp||kqSrrD)rFZbcdimZszdimrDrDrHrIsz;size does not match the broadcast shape of the parameters. r) getr\rrrrrrrziprp) rrakwargsruZ all_bcastZ bcast_shapeZ bcast_ndimZsize_ZndiffokZ param_bcastZ loc_bcastZ scale_bcastrDrrH _argcheck_rvses:       zrv_generic._argcheck_rvscGs$d}|D]}t|t|dk}q|S)zDefault check for correct values on args and keywords. Returns condition array of 1's where arguments are correct and 0's where they are not. rr)rr)rrarrrDrDrH _argcheckszrv_generic._argcheckcOs |j|jfS)aReturn the support of the (unscaled, unshifted) distribution. *Must* be overridden by distributions which have support dependent upon the shape parameters of the distribution. Any such override *must not* set or change any of the class members, as these members are shared amongst all instances of the distribution. Parameters ---------- arg1, arg2, ... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information). Returns ------- a, b : numeric (float, or int or +/-np.inf) end-points of the distribution's support for the specified shape parameters. rrrrar rDrDrHrszrv_generic._get_supportcGsN|j|\}}tjdd ||k||k@WdS1s@0YdSNrinvalidrr\rrrxrarrrDrDrH _support_maskszrv_generic._support_maskcGsN|j|\}}tjdd ||k||k@WdS1s@0YdSrrrrDrDrH_open_support_maskszrv_generic._open_support_maskrcGs"|j|d}|j|g|R}|S)Nru)uniform_ppf)rrurraUYrDrDrH_rvss zrv_generic._rvscGsFtjdd&t|j|g|RWdS1s80YdSNr)divide)r\rr_cdfrrxrarDrDrH_logcdfszrv_generic._logcdfcGsd|j|g|RSNrTr r!rDrDrH_sfszrv_generic._sfcGsFtjdd&t|j|g|RWdS1s80YdSr)r\rrr%r!rDrDrH_logsfszrv_generic._logsfcGs|j|g|RSrO)_ppfvecrrrarDrDrHrszrv_generic._ppfcGs|jd|g|RSr#)rr(rDrDrH_isfszrv_generic._isfc Os|dd}|dd}|j|i|\}}}}t|j||dk}t|sdd|jd} t| t|dkr|t|dS|dur|j } t |} n|j } |j ||| d} | ||} |dur| |_ |rt |t s|d krt| } n | tj} | S) aVRandom variates of given type. Parameters ---------- arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information). loc : array_like, optional Location parameter (default=0). scale : array_like, optional Scale parameter (default=1). size : int or tuple of ints, optional Defining number of random variates (default is 1). random_state : {None, int, `numpy.random.Generator`, `numpy.random.RandomState`}, optional If `random_state` is None (or `np.random`), the `numpy.random.RandomState` singleton is used. If `random_state` is an int, a new ``RandomState`` instance is used, seeded with `random_state`. If `random_state` is already a ``Generator`` or ``RandomState`` instance, that instance is used. Returns ------- rvs : ndarray or scalar Random variates of given `size`. rNrrzDomain error in arguments. The `scale` parameter must be positive for all distributions, and many distributions have restrictions on shape parameters. Please see the `scipy.stats.z` documentation for details.drrD)poprrrr\rrrprrrrrl rv_sampleintastypeZint64) rrar{rZrndmrrrurmessageZrandom_state_savedrrrDrDrHr)s0       zrv_generic.rvscs|j|i|\}}}}tt||f\}}ttt|}|j||dk@||k@}g}tjt||jdt |rt |g|||fR}|d|d|dd}}}|j r|j |id|i\} } } } n|j |\} } } } d|vr0| dur |j dg|R} } t| || |||| d |vr| dur|j d g|R}| durr|j dg|R} tjd d 0tt| || d tj} Wdn1s0Y} t| || |||| d |vr| dur|j dg|R}| dur(|j dg|R} | dur~|j d g|R}tjd d || | } Wdn1st0Ytjd d :| | d| | |}|t| d} Wdn1s0Y} t| || || d|vr| durt|j dg|R}| dur6|j dg|R} | dur|j d g|R}tjd d || | } Wdn1s0Y| durd}n| t| d}|dur|j dg|R}tjd d *| | d| | |}Wdn1s0Ytjd d F| d  d| | d|| |}|| dd} Wdn1sj0Y} t| || || nfdd|D}dd|D}t|dkr|dSt|SdS)aSome statistics of the given RV. Parameters ---------- arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information) loc : array_like, optional location parameter (default=0) scale : array_like, optional (continuous RVs only) scale parameter (default=1) moments : str, optional composed of letters ['mvsk'] defining which moments to compute: 'm' = mean, 'v' = variance, 's' = (Fisher's) skew, 'k' = (Fisher's) kurtosis. (default is 'mv') Returns ------- stats : sequence of requested moments. r fill_valuerrNrmrvrUrrrNrVrWrrXr[rZrYcsg|] }qSrD)r)rFrr?rDrHrIrJz$rv_generic.stats..cSsg|] }|dqS)rDrD)rFoutrDrDrHrIrJ)rmaprrrr\fullrbadvalueanyrrrrrrrrwhererrr]r)rrar{rrrroutputgoodargsrRr^r_r`Zout0Zmu2pZmu3prcZmu4prdrDr4rHr>s        @     ,0      ,  :&0  zrv_generic.statsc Os|j|i|\}}}tt||f\}}ttt|}|j||dk@||k@}tt|d}t|d||jt ||g|R}|d}|dd}t|||j |t ||dS)aDifferential entropy of the RV. Parameters ---------- arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information). loc : array_like, optional Location parameter (default=0). scale : array_like, optional (continuous distributions only). Scale parameter (default=1). Notes ----- Entropy is defined base `e`: >>> import numpy as np >>> from scipy.stats._distn_infrastructure import rv_discrete >>> drv = rv_discrete(values=((0, 1), (0.5, 0.5))) >>> np.allclose(drv.entropy(), np.log(2.0)) True rr*rNrD) rr6rrrrrrr8r vecentropyr) rrar{rrcond0r;r<Z goodscalerDrDrHr2s zrv_generic.entropyc s|}|j|i|\}}}tjg|||R}|^}}}t|j||dk}t||dk} t||dk} t|g|||R}|^}}}t||krtd|dkrtdd\} } } }|dkr|dkr|jrdddd d d |i}ni}|j |i|\} } } }t |j }t || | | ||j ||d <t|j }t|||j| r||dk|||dk}t|| || r| | | |gd dD}fddtdD}t|rt|dkg|R}d}|D]}|||<|d7}q\} } } }t|dkg||||R}|^}}}}t|j dd}||}t|D]:}t || | | ||j |}|t||dd|||7}q\||||7}|||9}t|| ||dS)anon-central moment of distribution of specified order. Parameters ---------- order : int, order >= 1 Order of moment. arg1, arg2, arg3,... : float The shape parameter(s) for the distribution (see docstring of the instance object for more information). loc : array_like, optional location parameter (default=0) scale : array_like, optional scale parameter (default=1) rzMoment must be an integer.zMoment must be positive.rrr2r3vsZmvsk)rrUrVrX.cSsg|]}|dur|qSrOrDrFrrDrDrHrI rJz%rv_generic.moment..csg|]}|dur|qSrOrDrAZmomrDrHrI rJrXrr*dtypeT)exactrD)rr\rrrrrrprrr rrerrrr8r9rr )rrrar{rQrrrZi0i1i2rRr^r_r`ZmdictrbresultZres1arrsidxjrZres2ZfacrZvalkrDrBrHr4sd                "  zrv_generic.momentcOs|jdg|Ri|S)aUMedian of the distribution. Parameters ---------- arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information) loc : array_like, optional Location parameter, Default is 0. scale : array_like, optional Scale parameter, Default is 1. Returns ------- median : float The median of the distribution. See Also -------- rv_discrete.ppf Inverse of the CDF ?r0rrDrDrHr:!szrv_generic.mediancOs8d|d<|j|i|}t|tr4|jdkr4|dS|S)aMean of the distribution. Parameters ---------- arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information) loc : array_like, optional location parameter (default=0) scale : array_like, optional scale parameter (default=1) Returns ------- mean : float the mean of the distribution r2rrrDrrlrrrrar{resrDrDrHr7;s zrv_generic.meancOs8d|d<|j|i|}t|tr4|jdkr4|dS|S)aVariance of the distribution. Parameters ---------- arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information) loc : array_like, optional location parameter (default=0) scale : array_like, optional scale parameter (default=1) Returns ------- var : float the variance of the distribution r3rrrDrNrOrDrDrHr9Ts zrv_generic.varcOs d|d<t|j|i|}|S)aStandard deviation of the distribution. Parameters ---------- arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information) loc : array_like, optional location parameter (default=0) scale : array_like, optional scale parameter (default=1) Returns ------- std : float standard deviation of the distribution r3r)rrrOrDrDrHr8mszrv_generic.stdc Osz|}t|}t|dk|dkBr*tdd|d}d|d}|j|g|Ri|}|j|g|Ri|}||fS)a|Confidence interval with equal areas around the median. Parameters ---------- confidence : array_like of float Probability that an rv will be drawn from the returned range. Each value should be in the range [0, 1]. arg1, arg2, ... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information). loc : array_like, optional location parameter, Default is 0. scale : array_like, optional scale parameter, Default is 1. Returns ------- a, b : ndarray of float end-points of range that contain ``100 * alpha %`` of the rv's possible values. Notes ----- This is implemented as ``ppf([p_tail, 1-p_tail])``, where ``ppf`` is the inverse cumulative distribution function and ``p_tail = (1-confidence)/2``. Suppose ``[c, d]`` is the support of a discrete distribution; then ``ppf([0, 1]) == (c-1, d)``. Therefore, when ``confidence=1`` and the distribution is discrete, the left end of the interval will be beyond the support of the distribution. For discrete distributions, the interval will limit the probability in each tail to be less than or equal to ``p_tail`` (usually strictly less). rrz'alpha must be between 0 and 1 inclusiverTrU)rr\r9rpr0) rrrar{alphaq1q2rrrDrDrHr6s#  zrv_generic.intervalc Os |j|i|\}}}tjg|||R}|dd|d|d}}}|j||dk@}|j|\}}|r||||||fS|jdkr|j|jfSt| dt| d}}||||||} } t | d||jt | d||j| | fS)aSupport of the distribution. Parameters ---------- arg1, arg2, ... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information). loc : array_like, optional location parameter, Default is 0. scale : array_like, optional scale parameter, Default is 1. Returns ------- a, b : array_like end-points of the distribution's support. Nrrrr*r) rr\rrrrrr8rr.r) rrar rrrIr_a_bZout_aZout_brDrDrHrs   "zrv_generic.supportcCsz||\}}}|j|r"|dkr&tSt|||}t|t|}t|j|g|RrdtS|j |g|R|S)zNegative loglikelihood function. Notes ----- This is ``-sum(log pdf(x, theta), axis=0)`` where `theta` are the parameters (including loc and scale). r) _unpack_loc_scalerrrrrr\r9r_nnlfrthetarxrrraZ n_log_scalerDrDrHnnlfszrv_generic.nnlfcGstj|j|g|Rdd S)NrZaxis)r\rw_logpxfr!rDrDrHrWszrv_generic._nnlfc Cs|j|g|R}tj|dd}|dkr:t||d}||g|R}t|}|tj|dd7}|dkr|ttd}tj||dd |Stj|dd S)Nrr[d)rr\rvrrtrwrr!) rrxraZ log_fitfunr>n_badZlogffZ finite_logffZpenaltyrDrDrH_nlff_and_penaltys zrv_generic._nlff_and_penaltycCsZ||\}}}|j|r"|dkr&tSt|||}t|t|}||||j|S)zPenalized negative loglikelihood function. i.e., - sum (log pdf(x, theta), axis=0) + penalty where theta are the parameters (including loc and scale) r)rVrrrrrr_r\rXrDrDrH_penalized_nnlfs zrv_generic._penalized_nnlfcsR|\}}}j|r"|dkr&tSt|||}fdd}|||S)zPenalized negative log product spacing function. i.e., - sum (log (diff (cdf (x, theta))), axis=0) + penalty where theta are the parameters (including loc and scale) Follows reference [1] of scipy.stats.fit rcstj|dd\}}|jr*j|g|Rng}|jrDd|ddksjtdg|dgf}t|dgf}ntdg|f}|tt||S)NT)Z return_countsrrr)r\uniquerur Z concatenaterdiff)rxraZljZcdf_datar,rrDrHlog_psf sz,rv_generic._penalized_nlpsf..log_psf)rVrrr\sortr_)rrYrxrrrarcrDrrH_penalized_nlpsfs  zrv_generic._penalized_nlpsf)N)N)NNr)-rrrrrrrrrrrrrrrrrrr rrrrrr"r%r&rr)r)rr2r4r:r7r9r8r6rrZrWr_r`re __classcell__rDrDrrHrusZ    Q & J  Eq%M.# rc@s&eZdZdej ejfdfddZdS) _ShapeInfoF)TTcCsx||_||_t|}t|dr@|ds@t|dtj|d<t|drn|dsnt|dtj |d<||_dSr)r integralityrr\rt nextafterrdomain)rrrhrjZ inclusiverDrDrHrsz_ShapeInfo.__init__N)rrrr\rrrDrDrDrHrgsrgcsRfdd|D}t|dkr>dd|D}tdd||rN|ddSdS) a$ Given names such as `['f0', 'fa', 'fix_a']`, check that there is at most one non-None value in `kwds` associaed with those names. Return that value, or None if none of the names occur in `kwds`. As a side effect, all occurrences of those names in `kwds` are removed. cs"g|]}|vr||fqSrDr+)rFrr{rDrHrI2rJz(_get_fixed_fit_value..rcSsg|] \}}|qSrDrD)rFrrbrDrDrHrI4rJzOfit method got multiple keyword arguments to specify the same fixed parameter: rrN)rrpr)r{namesrZrepeatedrDrlrH_get_fixed_fit_value*s rnc sHeZdZdZdQfdd ZddZd d Zd d Zd dZddZ ddZ ddZ ddZ ddZ ddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd3d4Zd5d6Zd7d8ZdRd9d:ZdSd;d<Zd=d>Z d?d@Z!dAdBZ"dCdDZ#dEdFZ$dTdJdKZ%dLdMZ&dHddNdOdPZ'Z(S)UrKaA generic continuous random variable class meant for subclassing. `rv_continuous` is a base class to construct specific distribution classes and instances for continuous random variables. It cannot be used directly as a distribution. Parameters ---------- momtype : int, optional The type of generic moment calculation to use: 0 for pdf, 1 (default) for ppf. a : float, optional Lower bound of the support of the distribution, default is minus infinity. b : float, optional Upper bound of the support of the distribution, default is plus infinity. xtol : float, optional The tolerance for fixed point calculation for generic ppf. badvalue : float, optional The value in a result arrays that indicates a value that for which some argument restriction is violated, default is np.nan. name : str, optional The name of the instance. This string is used to construct the default example for distributions. longname : str, optional This string is used as part of the first line of the docstring returned when a subclass has no docstring of its own. Note: `longname` exists for backwards compatibility, do not use for new subclasses. shapes : str, optional The shape of the distribution. For example ``"m, n"`` for a distribution that takes two integers as the two shape arguments for all its methods. If not provided, shape parameters will be inferred from the signature of the private methods, ``_pdf`` and ``_cdf`` of the instance. seed : {None, int, `numpy.random.Generator`, `numpy.random.RandomState`}, optional If `seed` is None (or `np.random`), the `numpy.random.RandomState` singleton is used. If `seed` is an int, a new ``RandomState`` instance is used, seeded with `seed`. If `seed` is already a ``Generator`` or ``RandomState`` instance then that instance is used. Methods ------- rvs pdf logpdf cdf logcdf sf logsf ppf isf moment stats entropy expect median mean std var interval __call__ fit fit_loc_scale nnlf support Notes ----- Public methods of an instance of a distribution class (e.g., ``pdf``, ``cdf``) check their arguments and pass valid arguments to private, computational methods (``_pdf``, ``_cdf``). For ``pdf(x)``, ``x`` is valid if it is within the support of the distribution. Whether a shape parameter is valid is decided by an ``_argcheck`` method (which defaults to checking that its arguments are strictly positive.) **Subclassing** New random variables can be defined by subclassing the `rv_continuous` class and re-defining at least the ``_pdf`` or the ``_cdf`` method (normalized to location 0 and scale 1). If positive argument checking is not correct for your RV then you will also need to re-define the ``_argcheck`` method. For most of the scipy.stats distributions, the support interval doesn't depend on the shape parameters. ``x`` being in the support interval is equivalent to ``self.a <= x <= self.b``. If either of the endpoints of the support do depend on the shape parameters, then i) the distribution must implement the ``_get_support`` method; and ii) those dependent endpoints must be omitted from the distribution's call to the ``rv_continuous`` initializer. Correct, but potentially slow defaults exist for the remaining methods but for speed and/or accuracy you can over-ride:: _logpdf, _cdf, _logcdf, _ppf, _rvs, _isf, _sf, _logsf The default method ``_rvs`` relies on the inverse of the cdf, ``_ppf``, applied to a uniform random variate. In order to generate random variates efficiently, either the default ``_ppf`` needs to be overwritten (e.g. if the inverse cdf can expressed in an explicit form) or a sampling method needs to be implemented in a custom ``_rvs`` method. If possible, you should override ``_isf``, ``_sf`` or ``_logsf``. The main reason would be to improve numerical accuracy: for example, the survival function ``_sf`` is computed as ``1 - _cdf`` which can result in loss of precision if ``_cdf(x)`` is close to one. **Methods that can be overwritten by subclasses** :: _rvs _pdf _cdf _sf _ppf _isf _stats _munp _entropy _argcheck _get_support There are additional (internal and private) generic methods that can be useful for cross-checking and for debugging, but might work in all cases when directly called. A note on ``shapes``: subclasses need not specify them explicitly. In this case, `shapes` will be automatically deduced from the signatures of the overridden methods (`pdf`, `cdf` etc). If, for some reason, you prefer to avoid relying on introspection, you can specify ``shapes`` explicitly as an argument to the instance constructor. **Frozen Distributions** Normally, you must provide shape parameters (and, optionally, location and scale parameters to each call of a method of a distribution. Alternatively, the object may be called (as a function) to fix the shape, location, and scale parameters returning a "frozen" continuous RV object: rv = generic(, loc=0, scale=1) `rv_frozen` object with the same methods but holding the given shape, location, and scale fixed **Statistics** Statistics are computed using numerical integration by default. For speed you can redefine this using ``_stats``: - take shape parameters and return mu, mu2, g1, g2 - If you can't compute one of these, return it as None - Can also be defined with a keyword argument ``moments``, which is a string composed of "m", "v", "s", and/or "k". Only the components appearing in string should be computed and returned in the order "m", "v", "s", or "k" with missing values returned as None. Alternatively, you can override ``_munp``, which takes ``n`` and shape parameters and returns the n-th non-central moment of the distribution. **Deepcopying / Pickling** If a distribution or frozen distribution is deepcopied (pickled/unpickled, etc.), any underlying random number generator is deepcopied with it. An implication is that if a distribution relies on the singleton RandomState before copying, it will rely on a copy of that random state after copying, and ``np.random.seed`` will no longer control the state. Examples -------- To create a new Gaussian distribution, we would do the following: >>> from scipy.stats import rv_continuous >>> class gaussian_gen(rv_continuous): ... "Gaussian distribution" ... def _pdf(self, x): ... return np.exp(-x**2 / 2.) / np.sqrt(2.0 * np.pi) >>> gaussian = gaussian_gen(name='gaussian') ``scipy.stats`` distributions are *instances*, so here we subclass `rv_continuous` and create an instance. With this, we now have a fully functional distribution with all relevant methods automagically generated by the framework. Note that above we defined a standard normal distribution, with zero mean and unit variance. Shifting and scaling of the distribution can be done by using ``loc`` and ``scale`` parameters: ``gaussian.pdf(x, loc, scale)`` essentially computes ``y = (x - loc) / scale`` and ``gaussian._pdf(y) / scale``. rN+=c st| t||||||||| d |_|dur4t}|dur@d}||_||_||_||_|durht |_|durvt |_||_ ||_ ||_ |j |j|jgddd||dur|ddvrd} nd } | |}tjjd kr|jdur|j|td d ntt} |t| |jdS) N) momtyperrxtolr8rrrr Distributionzloc=0, scale=1z loc, scalerrrrZ aeiouAEIOUAn A rUrrrr)rrrrrr8rrrrrq moment_typerr_pdfr rsysflagsr rrrrrr ) rrprrrqr8rrrrhstrrrrDrHr sN   zrv_continuous.__init__cs(|jgd}fdd|DS)N)rrr_cdfvecr'r=rcsg|]}|dqSrOrkrFattrrrDrHrICrJz.rv_continuous.__getstate__..rrrattrsrDrrH __getstate__<s zrv_continuous.__getstate__cCs|t|jdd|_|jd|j_t|jdd|_t|jdd|_ |jd|j _|j dkrpt|j dd|_ nt|j dd|_ |jd|j _dS)zU Attaches dynamically created methods to the rv_continuous instance. r*ZotypesrrN)rr _ppf_singler'rnin_entropyr= _cdf_singler}rx_mom0_scr_mom1_scrrDrDrHrFs zrv_continuous._attach_methodscCsJ|j}|j|d<|j|d<|j|d<|j|d<|j|d<|j|d<|S)Return the current version of _ctor_param, possibly updated by user. Used by freezing. Keep this in sync with the signature of __init__. rrrqr8rr)rrrrrqr8rrrrrDrDrHr}\s       z!rv_continuous._updated_ctor_paramcGs|j|f||SrO)r,)rrxrrarDrDrH _ppf_to_solvekszrv_continuous._ppf_to_solvecGsd}|j|\}}t|rPt| |}|j||g|RdkrP|||}}q(t|rt||}|j||g|Rdkr|||}}qdtj|j|||f||jdS)Ng$@)rarq) rr\rminrmaxr Zbrentqrq)rrrafactorleftrightrDrDrHrns    zrv_continuous._ppf_singlecGs|||j|g|RSrOr*)rrxr2rarDrDrH _mom_integ0szrv_continuous._mom_integ0cGs,|j|\}}tj|j|||f|ddSNrar)rr quadr)rr2rarTrUrDrDrHrs  zrv_continuous._mom0_sccGs|j|g|R|SrOrM)rrr2rarDrDrH _mom_integ1szrv_continuous._mom_integ1cGstj|jdd|f|ddS)Nrrr)r rr)rr2rarDrDrHrszrv_continuous._mom1_sccGst|j|d|ddS)Ngh㈵>r?)Zdxrar)r r r!rDrDrHryszrv_continuous._pdfcGsJ|j|g|R}tjddt|WdS1s<0YdSr)ryr\rr)rrxraprDrDrH_logpdfszrv_continuous._logpdfcGs|j|g|RSrO)rr!rDrDrHr\szrv_continuous._logpxfcGs&|j|\}}tj|j|||ddSr)rr rry)rrxrarTrUrDrDrHrszrv_continuous._cdf_singlecGs|j|g|RSrO)r}r!rDrDrHr szrv_continuous._cdfc Os*|j|i|\}}}tt|||f\}}}ttt|}t|jtj}tj||||d}|j||dk@}|j |g|R|dk@}||@} t t | |} t | d|t ||jt| rt| g|f||fR} | d| dd}} t| | |j| || jdkr&| dS| S)aDProbability density function at x of the given RV. Parameters ---------- x : array_like quantiles arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information) loc : array_like, optional location parameter (default=0) scale : array_like, optional scale parameter (default=1) Returns ------- pdf : ndarray Probability density function evaluated at x rCrrrNrD)rr6rrr\ promote_typesrDfloat64rrrrrisnanr8r9rrryr rrxrar{rrdtypr>cond1rr;r<rDrDrHr*s"  zrv_continuous.pdfc Os:|j|i|\}}}tt|||f\}}}ttt|}t|jtj}tj||||d}|j||dk@}|j |g|R|dk@}||@} t t | |} | t t| d|t||jt| r"t| g|f||fR} | d| dd}} t| | |j| t|| jdkr6| dS| S)aLog of the probability density function at x of the given RV. This uses a more numerically accurate calculation if available. Parameters ---------- x : array_like quantiles arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information) loc : array_like, optional location parameter (default=0) scale : array_like, optional scale parameter (default=1) Returns ------- logpdf : array_like Log of the probability density function evaluated at x rCrrrNrD)rr6rrr\rrDrrrr rfillrrrr8r9rrrrrrrDrDrHr+s$   zrv_continuous.logpdfcOs6|j|i|\}}}tt|||f\}}}ttt|}|j|\}}t|jtj}tj||||d}|j ||dk@} |j |g|R|dk@} |t|k| @} | | @} t t | |} t | d| t||jt | | dt| rt| g|f|R}t | | |j|| jdkr2| dS| S)aR Cumulative distribution function of the given RV. Parameters ---------- x : array_like quantiles arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information) loc : array_like, optional location parameter (default=0) scale : array_like, optional scale parameter (default=1) Returns ------- cdf : ndarray Cumulative distribution function evaluated at `x` rCrrrTrD)rr6rrrr\rrDrrrrrrrr8r9rr rrrxrar{rrrTrUrr>rcond2rr;r<rDrDrHr,s&   zrv_continuous.cdfcOsD|j|i|\}}}tt|||f\}}}ttt|}|j|\}}t|jtj}tj||||d}|j ||dk@} |j |g|R|dk@} ||k| @} | | @} t t | |} | t t| d| | | kt||jt| | dt| r,t| g|f|R}t| | |j|| jdkr@| dS| S)ahLog of the cumulative distribution function at x of the given RV. Parameters ---------- x : array_like quantiles arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information) loc : array_like, optional location parameter (default=0) scale : array_like, optional scale parameter (default=1) Returns ------- logcdf : array_like Log of the cumulative distribution function evaluated at x rCrrrrD)rr6rrrr\rrDrrrr rrrrrr8r9rr"rrrDrDrHr-&s(  $   zrv_continuous.logcdfcOs0|j|i|\}}}tt|||f\}}}ttt|}|j|\}}t|jtj}tj||||d}|j ||dk@} |j |g|R|dk@} | ||k@} | | @} t t | |} t | d| t||jt | | dt| rt| g|f|R}t | | |j|| jdkr,| dS| S)a<Survival function (1 - `cdf`) at x of the given RV. Parameters ---------- x : array_like quantiles arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information) loc : array_like, optional location parameter (default=0) scale : array_like, optional scale parameter (default=1) Returns ------- sf : array_like Survival function evaluated at x rCrrrTrD)rr6rrrr\rrDrrrrrrrr8r9rr%rrrDrDrHr.Ps&    zrv_continuous.sfcOs<|j|i|\}}}tt|||f\}}}ttt|}|j|\}}t|jtj}tj||||d}|j ||dk@} |j |g|R|dk@} | ||k@} | | @} t t | |} | t t| d| t||jt| | dt| r$t| g|f|R}t| | |j|| jdkr8| dS| S)aLog of the survival function of the given RV. Returns the log of the "survival function," defined as (1 - `cdf`), evaluated at `x`. Parameters ---------- x : array_like quantiles arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information) loc : array_like, optional location parameter (default=0) scale : array_like, optional scale parameter (default=1) Returns ------- logsf : ndarray Log of the survival function evaluated at `x`. rCrrrrD)rr6rrrr\rrDrrrr rrrrrr8r9rr&rrrDrDrHr/ys(     zrv_continuous.logsfcOsf|j|i|\}}}tt|||f\}}}ttt|}|j|\}}|j||dk@||k@}d|k|dk@} ||dk@} ||dk@} || @} tjt| |j d} |||}|||}t | | t | |dt | | t | |dt | rNt | g|f|||fR}|d|d|dd}}}t | | |j |||| jdkrb| dS| S)akPercent point function (inverse of `cdf`) at q of the given RV. Parameters ---------- q : array_like lower tail probability arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information) loc : array_like, optional location parameter (default=0) scale : array_like, optional scale parameter (default=1) Returns ------- x : array_like quantile corresponding to the lower tail probability q. rrr0rrNrD)rr6rrrrr\r7rr8rrr9rrrrrar{rrrTrUr>rrcond3rr; lower_bound upper_boundr<rDrDrHr0s*       zrv_continuous.ppfcOsf|j|i|\}}}tt|||f\}}}ttt|}|j|\}}|j||dk@||k@}d|k|dk@} ||dk@} ||dk@} || @} tjt| |j d} |||}|||}t | | t | |dt | | t | |dt | rNt | g|f|||fR}|d|d|dd}}}t | | |j |||| jdkrb| dS| S)atInverse survival function (inverse of `sf`) at q of the given RV. Parameters ---------- q : array_like upper tail probability arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information) loc : array_like, optional location parameter (default=0) scale : array_like, optional scale parameter (default=1) Returns ------- x : ndarray or scalar Quantile corresponding to the upper tail probability q. rrr0rrNrD)rr6rrrrr\r7rr8rrr9r)rrrDrDrHr1s*       zrv_continuous.isfc Cs^z$|d}|d}t|dd}Wn.tyR}ztd|WYd}~n d}~00|||fS)NrrNot enough input arguments.r IndexErrorrprrYrrrarrrDrDrHrV s zrv_continuous._unpack_loc_scalec Cst|tr|j|j|}t|t|}|jj\}}|j|jg|R|j |j g|R|j |j g|Rt |j||g|Rg}nJ|j|g|R}t |}|dkrt||d}|j|g|Rg}tdd|D\} } t| } |t| 7}| |tdS)a Compute the penalized negative log-likelihood for the "standardized" data (i.e. already shifted by loc and scaled by scale) for the shape parameters in `args`. `x` can be a 1D numpy array or a CensoredData instance. rcSsg|] }t|qSrD)ry)rFtermrDrDrHrI' rJz3rv_continuous._nnlf_and_penalty..r])rlr#Z _supportedrrZ _intervalTr _uncensoredr"_leftr&_rightr\r _delta_cdfrrvrr rwr") rrxraZxsr^rFrGZtermsr>ZtotalsZ bad_countstotalrDrDrH_nnlf_and_penalty s$     zrv_continuous._nnlf_and_penaltycCs||\}}}|j|r"|dkr&tSt|trV|||}t||t|}n|||}t|t|}||||S)zPenalized negative loglikelihood function. i.e., - sum (log pdf(x, theta), axis=0) + penalty where theta are the parameters (including loc and scale) r) rVrrrlr#r num_censoredrrrXrDrDrHr`- s   zrv_continuous._penalized_nnlfcCs4|durd|j}|j|g|R\}}|||fS)z7Starting point for fit (shape arguments + loc + scale).N)rT)r_fit_loc_scale_support)rrPrarrrDrDrH _fitstart? s zrv_continuous._fitstartcsg}jrfjdd}t|D]@\}}dt|}|d|d|g}t||} | dur$| ||<q$ttgddtdDd d g}g} t|D]8\} }||vrΈ | | || <q| | qd d h} | d d  } | d krht|dt}t d|dddt jf}t j|dddf|t|ddfddn&| d krzjntd| d| tdkr}dn4tkrtdfddfdd}| |fS)z Return the (possibly reduced) function to optimize in order to find MLE estimates for the .fit method. rrfZfix_NcSsg|] }d|qS)zf%drD)rFrQrDrDrHrI\ rJz.rv_continuous._reduce_func..rUZflocZfscalemlemmmethodrr[cs||SrO) _moment_error)rYrx) data_momentsrrDrH objectivel sz-rv_continuous._reduce_func..objectivezMethod 'z ' not available; must be one of rz3All parameters fixed. There is nothing to optimize.cs2d}tD] }|vr ||||<|d7}q |Sr)r)rarYrrQ)NargsfixednrDrHrestore} s    z+rv_continuous._reduce_func..restorecsdd|}||SrOrD)rYrxZnewtheta)rarrrDrHr sz(rv_continuous._reduce_func..func)rrr enumeratermrnrrrrr+lowerr\rnewaxisrwr`rp)rrar{rPrrKrNkeyrmrbx0rQr%rZn_paramsZ exponentsrrD)rrarrrrrrH _reduce_funcF sR      &   zrv_continuous._reduce_funccs|\jr"dkr&tStfddtt|D}tt|rdt d||t t |dd S)Nrcs*g|]"}j|dgRdqS)rrr)r4rArarrrrDrHrI sz/rv_continuous._moment_error..zqMethod of moments encountered a non-finite distribution moment and cannot continue. Consider trying method='MLE'.:0yE>rU) rVrrr\arrayrrr9rrpmaximumabsrw)rrYrxrZ dist_momentsrDrrHr s zrv_continuous._moment_errorcOs|dd}t|t}|rD|dkr.td|dkrD|j}d}t|}||jkr^t d|st | }t |stddgd }||jksd |vrd |vs||}|||d 7}|d |d }|d |d } ||| f7}|j|||d\} } } }|dtj} t| } |r0t d|| | | |fdd}| ||}| dur`| ||}t|}||\}} }t |j|r| dkstd|dkrt |std|S)a Return estimates of shape (if applicable), location, and scale parameters from data. The default estimation method is Maximum Likelihood Estimation (MLE), but Method of Moments (MM) is also available. Starting estimates for the fit are given by input arguments; for any arguments not provided with starting estimates, ``self._fitstart(data)`` is called to generate such. One can hold some parameters fixed to specific values by passing in keyword arguments ``f0``, ``f1``, ..., ``fn`` (for shape parameters) and ``floc`` and ``fscale`` (for location and scale parameters, respectively). Parameters ---------- data : array_like or `CensoredData` instance Data to use in estimating the distribution parameters. arg1, arg2, arg3,... : floats, optional Starting value(s) for any shape-characterizing arguments (those not provided will be determined by a call to ``_fitstart(data)``). No default value. **kwds : floats, optional - `loc`: initial guess of the distribution's location parameter. - `scale`: initial guess of the distribution's scale parameter. Special keyword arguments are recognized as holding certain parameters fixed: - f0...fn : hold respective shape parameters fixed. Alternatively, shape parameters to fix can be specified by name. For example, if ``self.shapes == "a, b"``, ``fa`` and ``fix_a`` are equivalent to ``f0``, and ``fb`` and ``fix_b`` are equivalent to ``f1``. - floc : hold location parameter fixed to specified value. - fscale : hold scale parameter fixed to specified value. - optimizer : The optimizer to use. The optimizer must take ``func`` and starting position as the first two arguments, plus ``args`` (for extra arguments to pass to the function to be optimized) and ``disp``. The ``fit`` method calls the optimizer with ``disp=0`` to suppress output. The optimizer must return the estimated parameters. - method : The method to use. The default is "MLE" (Maximum Likelihood Estimate); "MM" (Method of Moments) is also available. Raises ------ TypeError, ValueError If an input is invalid `~scipy.stats.FitError` If fitting fails or the fit produced would be invalid Returns ------- parameter_tuple : tuple of floats Estimates for any shape parameters (if applicable), followed by those for location and scale. For most random variables, shape statistics will be returned, but there are exceptions (e.g. ``norm``). Notes ----- With ``method="MLE"`` (default), the fit is computed by minimizing the negative log-likelihood function. A large, finite penalty (rather than infinite negative log-likelihood) is applied for observations beyond the support of the distribution. With ``method="MM"``, the fit is computed by minimizing the L2 norm of the relative errors between the first *k* raw (about zero) data moments and the corresponding distribution moments, where *k* is the number of non-fixed parameters. More precisely, the objective function is:: (((data_moments - dist_moments) / np.maximum(np.abs(data_moments), 1e-8))**2).sum() where the constant ``1e-8`` avoids division by zero in case of vanishing data moments. Typically, this error norm can be reduced to zero. Note that the standard method of moments can produce parameters for which some data are outside the support of the fitted distribution; this implementation does nothing to prevent this. For either method, the returned answer is not guaranteed to be globally optimal; it may only be locally optimal, or the optimization may fail altogether. If the data contain any of ``np.nan``, ``np.inf``, or ``-np.inf``, the `fit` method will raise a ``RuntimeError``. When passing a ``CensoredData`` instance to ``data``, the log-likelihood function is defined as: .. math:: l(\pmb{\theta}; k) & = \sum \log(f(k_u; \pmb{\theta})) + \sum \log(F(k_l; \pmb{\theta})) \\ & + \sum \log(1 - F(k_r; \pmb{\theta})) \\ & + \sum \log(F(k_{\text{high}, i}; \pmb{\theta}) - F(k_{\text{low}, i}; \pmb{\theta})) where :math:`f` and :math:`F` are the pdf and cdf, respectively, of the function being fitted, :math:`\pmb{\theta}` is the parameter vector, :math:`u` are the indices of uncensored observations, :math:`l` are the indices of left-censored observations, :math:`r` are the indices of right-censored observations, subscripts "low"/"high" denote endpoints of interval-censored observations, and :math:`i` are the indices of interval-censored observations. Examples -------- Generate some data to fit: draw random variates from the `beta` distribution >>> import numpy as np >>> from scipy.stats import beta >>> a, b = 1., 2. >>> rng = np.random.default_rng(172786373191770012695001057628748821561) >>> x = beta.rvs(a, b, size=1000, random_state=rng) Now we can fit all four parameters (``a``, ``b``, ``loc`` and ``scale``): >>> a1, b1, loc1, scale1 = beta.fit(x) >>> a1, b1, loc1, scale1 (1.0198945204435628, 1.9484708982737828, 4.372241314917588e-05, 0.9979078845964814) The fit can be done also using a custom optimizer: >>> from scipy.optimize import minimize >>> def custom_optimizer(func, x0, args=(), disp=0): ... res = minimize(func, x0, args, method="slsqp", options={"disp": disp}) ... if res.success: ... return res.x ... raise RuntimeError('optimization routine failed') >>> a1, b1, loc1, scale1 = beta.fit(x, method="MLE", optimizer=custom_optimizer) >>> a1, b1, loc1, scale1 (1.0198821087258905, 1.948484145914738, 4.3705304486881485e-05, 0.9979104663953395) We can also use some prior knowledge about the dataset: let's keep ``loc`` and ``scale`` fixed: >>> a1, b1, loc1, scale1 = beta.fit(x, floc=0, fscale=1) >>> loc1, scale1 (0, 1) We can also keep shape parameters fixed by using ``f``-keywords. To keep the zero-th shape parameter ``a`` equal 1, use ``f0=1`` or, equivalently, ``fa=1``: >>> a1, b1, loc1, scale1 = beta.fit(x, fa=1, floc=0, fscale=1) >>> a1 1 Not all distributions return estimates for the shape parameters. ``norm`` for example just returns estimates for location and scale: >>> from scipy.stats import norm >>> x = norm.rvs(a, b, size=1000, random_state=123) >>> loc1, scale1 = norm.fit(x) >>> loc1, scale1 (0.92087172783841631, 2.0015750750324668) rrz,For censored data, the method must be "MLE".rFzToo many input arguments.z$The data contains non-finite values.NrUrrrr)rPrqzUnknown arguments: %s.)raZdispz\Optimization converged to parameters that are outside the range allowed by the distribution.rzVOptimization failed: either a data moment or fitted distribution moment is non-finite.)r rrlr#rprrrrrr\rrfrtrrr+rr rjrsrrVrr$)rrPrar{rZcensoredZNargstartrrrrrrqrrGrrDrDrHr3 sT/            zrv_continuous.fitcGs6t|tr|}n t|}|j|g|R\}}|j||j|\}}||}}||} | dkrn||fS|||} |||} t|} t |} | | kr| | kr||fS| | }d}||}| tj kr| ||}|d|| }||fS|tj kr| ||dfS|tj kr.| ||dfSt dS)aEstimate loc and scale parameters from data accounting for support. Parameters ---------- data : array_like Data to fit. arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information). Returns ------- Lhat : float Estimated location parameter for the data. Shat : float Estimated scale parameter for the data. rg?rUrN) rlr#Z _uncensorr\r fit_loc_scalerrrrr RuntimeError)rrPraZloc_hatZ scale_hatrTrUrrZ support_widthZa_hatZb_hatZdata_aZdata_bZ data_widthZ rel_marginmarginrDrDrHr s8            z$rv_continuous._fit_loc_scale_supportc Gs|j|iddi\}}t|}|}|}t||}tjdd|||} Wdn1sj0Yt| sd} t|rd|ksd}| |fS)a Estimate loc and scale parameters from data using 1st and 2nd moments. Parameters ---------- data : array_like Data to fit. arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information). Returns ------- Lhat : float Estimated location parameter for the data. Shat : float Estimated scale parameter for the data. rrrrNrr)rrr7r9rr\rrt) rrPrarRr^tmpZmuhatZmu2hatZShatZLhatrDrDrHr s * zrv_continuous.fit_loc_scalec sfdd}j\}}tjdd"t|||d}Wdn1sP0Yt|sh|SjddggR\}}t|r|}n|}t|r|} n|} t|| |dSdS)Ncsj|gR}t|SrO)ryr )rxrbrarrDrHinteg sz%rv_continuous._entropy..integr)Zoverr绽|=gA?)rr\rr rrr0r) rrarrTrUhlowZuppupperrrDrrHr s0   zrv_continuous._entropyrDrFc s`||dj|j|\} } dur:fdd} nfdd} |dur^|| |}|durr|| |}j||gg|Ri} | d| d} ||d<d }t|d|g}| d| |}|j|g|R|\}}tj| ||fi|d}tj| ||fi|d}tj| ||fi|d}|||}|rR|| }t|d S) aCalculate expected value of a function with respect to the distribution by numerical integration. The expected value of a function ``f(x)`` with respect to a distribution ``dist`` is defined as:: ub E[f(x)] = Integral(f(x) * dist.pdf(x)), lb where ``ub`` and ``lb`` are arguments and ``x`` has the ``dist.pdf(x)`` distribution. If the bounds ``lb`` and ``ub`` correspond to the support of the distribution, e.g. ``[-inf, inf]`` in the default case, then the integral is the unrestricted expectation of ``f(x)``. Also, the function ``f(x)`` may be defined such that ``f(x)`` is ``0`` outside a finite interval in which case the expectation is calculated within the finite range ``[lb, ub]``. Parameters ---------- func : callable, optional Function for which integral is calculated. Takes only one argument. The default is the identity mapping f(x) = x. args : tuple, optional Shape parameters of the distribution. loc : float, optional Location parameter (default=0). scale : float, optional Scale parameter (default=1). lb, ub : scalar, optional Lower and upper bound for integration. Default is set to the support of the distribution. conditional : bool, optional If True, the integral is corrected by the conditional probability of the integration interval. The return value is the expectation of the function, conditional on being in the given interval. Default is False. Additional keyword arguments are passed to the integration routine. Returns ------- expect : float The calculated expected value. Notes ----- The integration behavior of this function is inherited from `scipy.integrate.quad`. Neither this function nor `scipy.integrate.quad` can verify whether the integral exists or is finite. For example ``cauchy(0).mean()`` returns ``np.nan`` and ``cauchy(0).expect()`` returns ``0.0``. Likewise, the accuracy of results is not verified by the function. `scipy.integrate.quad` is typically reliable for integrals that are numerically favorable, but it is not guaranteed to converge to a correct value for all possible intervals and integrands. This function is provided for convenience; for critical applications, check results against other integration methods. The function is not vectorized. Examples -------- To understand the effect of the bounds of integration consider >>> from scipy.stats import expon >>> expon(1).expect(lambda x: 1, lb=0.0, ub=2.0) 0.6321205588285578 This is close to >>> expon(1).cdf(2.0) - expon(1).cdf(0.0) 0.6321205588285577 If ``conditional=True`` >>> expon(1).expect(lambda x: 1, lb=0.0, ub=2.0, conditional=True) 1.0000000000000002 The slight deviation from 1 is due to numerical integration. The integrand can be treated as a complex-valued function by passing ``complex_func=True`` to `scipy.integrate.quad` . >>> import numpy as np >>> from scipy.stats import vonmises >>> res = vonmises(loc=2, kappa=1).expect(lambda x: np.exp(1j*x), ... complex_func=True) >>> res (-0.18576377217422957+0.40590124735052263j) >>> np.angle(res) # location of the (circular) distribution 2.0 rNcs|j|g|RiSrOrrxra)lockwdsrrDrHfunw sz!rv_continuous.expect..funcs |j|g|RiSrOrrrrrrDrHrz srrrag?rD)rrr,r\rrr r)rrrarrrrrr{rTrUrZ cdf_boundsinvfacrQZ inner_boundsZcdf_inner_boundscr*ZlbccdZdubrrDrrHr5 s4c    zrv_continuous.expectcCsD|}tddtj tjfd}tdddtjfd}|||g}|S)NrFFFrrZ _shape_inforgr\r)r shape_infoloc_infoZ scale_info param_inforDrDrH _param_info s  zrv_continuous._param_inforc Gs|j|g|R||d}t|dk|j|g|R||d|j|g|R||d|j|g|R||d|}|jdkr|d}|S)a8 Compute CDF(x2) - CDF(x1). Where x1 is greater than the median, compute SF(x1) - SF(x2), otherwise compute CDF(x2) - CDF(x1). This function is only useful if `dist.sf(x, ...)` has an implementation that is numerically more accurate than `1 - dist.cdf(x, ...)`. rrLrrD)r,r\r:r.r)rx1Zx2rrraZcdf1rHrDrDrHr s   zrv_continuous._delta_cdf) rNNroNNNNN)N)N)NrDrrNNF))rrrrrrrr}rrrrrrryrr\rr r*r+r,r-r.r/r0r1rVrr`rrrr3rrrr5rrrfrDrDrrHrKDsZF2 '***)--- $  HrG! cs>fdd}j\}}t|||jdgRjS)z,Non-central moment of discrete distribution.cst|j|gRSrO)r\r]_pmfrxrarQrrDrHr sz_drv2_moment..funrL)r_expectr0inc)rrQrarrTrUrDrrH _drv2_moment src Gs|j|\}}|}|}t|rhttd|d}||kr>d}ql|j|g|R}||krf|d7}q0qlq0nd}t|rttd|d}||krd}q|j|g|R}||kr|d8}qqqn|j|g|R}||kr|S||kr|S||dkr||kr|S|St||d} |j| g|R} | |krR|| krD| }ntd | }q| |krz|| krl| }ntd | }q| SqdS) Nr] rTiirrrZzupdating stopped, endless loop)rrr-rr rr) rrrarTrUrrZqbZqarZqcrDrDrH_drv2_ppfsingle sX       rc seZdZdZdeddddddddf fdd Zdeddddddddf fdd Zd d Zd d ZddZ ddZ ddZ ddZ ddZ ddZddZddZddZfd d!Zd"d#Zd$d%Zd&d'Zd(d)Zd*d+Zd,d-Zd.d/Zd0d1Zd2d3Zd=d9d:Zd;d<ZZS)>rLaiA generic discrete random variable class meant for subclassing. `rv_discrete` is a base class to construct specific distribution classes and instances for discrete random variables. It can also be used to construct an arbitrary distribution defined by a list of support points and corresponding probabilities. Parameters ---------- a : float, optional Lower bound of the support of the distribution, default: 0 b : float, optional Upper bound of the support of the distribution, default: plus infinity moment_tol : float, optional The tolerance for the generic calculation of moments. values : tuple of two array_like, optional ``(xk, pk)`` where ``xk`` are integers and ``pk`` are the non-zero probabilities between 0 and 1 with ``sum(pk) = 1``. ``xk`` and ``pk`` must have the same shape, and ``xk`` must be unique. inc : integer, optional Increment for the support of the distribution. Default is 1. (other values have not been tested) badvalue : float, optional The value in a result arrays that indicates a value that for which some argument restriction is violated, default is np.nan. name : str, optional The name of the instance. This string is used to construct the default example for distributions. longname : str, optional This string is used as part of the first line of the docstring returned when a subclass has no docstring of its own. Note: `longname` exists for backwards compatibility, do not use for new subclasses. shapes : str, optional The shape of the distribution. For example "m, n" for a distribution that takes two integers as the two shape arguments for all its methods If not provided, shape parameters will be inferred from the signatures of the private methods, ``_pmf`` and ``_cdf`` of the instance. seed : {None, int, `numpy.random.Generator`, `numpy.random.RandomState`}, optional If `seed` is None (or `np.random`), the `numpy.random.RandomState` singleton is used. If `seed` is an int, a new ``RandomState`` instance is used, seeded with `seed`. If `seed` is already a ``Generator`` or ``RandomState`` instance then that instance is used. Methods ------- rvs pmf logpmf cdf logcdf sf logsf ppf isf moment stats entropy expect median mean std var interval __call__ support Notes ----- This class is similar to `rv_continuous`. Whether a shape parameter is valid is decided by an ``_argcheck`` method (which defaults to checking that its arguments are strictly positive.) The main differences are as follows. - The support of the distribution is a set of integers. - Instead of the probability density function, ``pdf`` (and the corresponding private ``_pdf``), this class defines the *probability mass function*, `pmf` (and the corresponding private ``_pmf``.) - There is no ``scale`` parameter. - The default implementations of methods (e.g. ``_cdf``) are not designed for distributions with support that is unbounded below (i.e. ``a=-np.inf``), so they must be overridden. To create a new discrete distribution, we would do the following: >>> from scipy.stats import rv_discrete >>> class poisson_gen(rv_discrete): ... "Poisson distribution" ... def _pmf(self, k, mu): ... return exp(-mu) * mu**k / factorial(k) and create an instance:: >>> poisson = poisson_gen(name="poisson") Note that above we defined the Poisson distribution in the standard form. Shifting the distribution can be done by providing the ``loc`` parameter to the methods of the instance. For example, ``poisson.pmf(x, mu, loc)`` delegates the work to ``poisson._pmf(x-loc, mu)``. **Discrete distributions from a list of probabilities** Alternatively, you can construct an arbitrary discrete rv defined on a finite set of values ``xk`` with ``Prob{X=xk} = pk`` by using the ``values`` keyword argument to the `rv_discrete` constructor. **Deepcopying / Pickling** If a distribution or frozen distribution is deepcopied (pickled/unpickled, etc.), any underlying random number generator is deepcopied with it. An implication is that if a distribution relies on the singleton RandomState before copying, it will rely on a copy of that random state after copying, and ``np.random.seed`` will no longer control the state. Examples -------- Custom made discrete distribution: >>> import numpy as np >>> from scipy import stats >>> xk = np.arange(7) >>> pk = (0.1, 0.2, 0.3, 0.1, 0.1, 0.0, 0.2) >>> custm = stats.rv_discrete(name='custm', values=(xk, pk)) >>> >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1) >>> ax.plot(xk, custm.pmf(xk), 'ro', ms=12, mec='r') >>> ax.vlines(xk, 0, custm.pmf(xk), colors='r', lw=4) >>> plt.show() Random number generation: >>> R = custm.rvs(size=100) rNrrc s$|durttSt|SdSrO)r__new__r,) clsrrrr8 moment_tolvaluesrrrrrrDrHr s zrv_discrete.__new__c st| t||||||||| | d |_|dur6t}||_||_||_||_||_ | |_ |durjt d|j |j |jgddd||||dS)N rrrr8rrrrrrz.rv_discrete.__init__(..., values != None, ...)loc=0loc, 1rs)rrrrrr8rrrrrrprrr r_construct_docstrings) rrrrr8rrrrrrrrDrHr s, zrv_discrete.__init__cs(|jgd}fdd|DS)N)rrrr}r'rcsg|]}|dqSrOrkr~rrDrHrI rJz,rv_discrete.__getstate__..rrrDrrHr s zrv_discrete.__getstate__cCst|jdd|_t|j|_|ttdd}|jd|_t |||_ tt dd}|jd|_t |||_ |jd|j_dS)zAAttaches dynamically created methods to the rv_discrete instance.r*rrUrN)rrr}rr=rrrrrrrrr')rZ_vec_generic_momentZ_vppfrDrDrHr s     zrv_discrete._attach_methodscCs|dur d}||_|dur8|ddvr,d}nd}||}tjjdkr|jdur`|j|tddntt}| t| |j|j d d |_dS) NrrrrtrurvrUrrwzE scale : array_like, optional scale parameter (default=1)r') rrzr{r rrrErrrr r)rrrr|rrDrDrHr s(   z!rv_discrete._construct_docstringscCsT|j}|j|d<|j|d<|j|d<|j|d<|j|d<|j|d<|j|d<|S)rrrr8rrrr) rrrrr8rrrrrrDrDrHr} s        zrv_discrete._updated_ctor_paramcGs t||kSrO)rrrrarDrDrH_nonzero szrv_discrete._nonzerocGs(|j|g|R|j|dg|RS)Nrr$rrDrDrHr szrv_discrete._pmfcGst|j|g|RSrO)rrrrDrDrH_logpmf szrv_discrete._logpmfcGs|j|g|RSrO)rrrDrDrHr\ szrv_discrete._logpxfc CsZz |d}d}t|dd}Wn.tyN}ztd|WYd}~n d}~00|||fS)NrrrrrrDrDrHrV s zrv_discrete._unpack_loc_scalecGs<|j|\}}tt||d}tj|j|g|RddS)Nrrr[)rrr-r\rwr)rrrarTrUr2rDrDrHr szrv_discrete._cdf_singlecGst|}|j|g|RSrO)rr})rrxrarrDrDrHr  szrv_discrete._cdfcsd|d<tj|i|S)a]Random variates of given type. Parameters ---------- arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information). loc : array_like, optional Location parameter (default=0). size : int or tuple of ints, optional Defining number of random variates (Default is 1). Note that `size` has to be given as keyword, not as positional argument. random_state : {None, int, `numpy.random.Generator`, `numpy.random.RandomState`}, optional If `random_state` is None (or `np.random`), the `numpy.random.RandomState` singleton is used. If `random_state` is an int, a new ``RandomState`` instance is used, seeded with `random_state`. If `random_state` is already a ``Generator`` or ``RandomState`` instance, that instance is used. Returns ------- rvs : ndarray or scalar Random variates of given `size`. Tr)rr)rrrDrHr)! szrv_discrete.rvsc Os|j|i|\}}}tt||f\}}ttt|}|j|\}}t||}|j|}||k||k@} t|ts| |j|g|R@} || @} t t | d} t | d|t ||jt | rt| g|f|R} t | | t |j| dd| jdkr | dS| S)aProbability mass function at k of the given RV. Parameters ---------- k : array_like Quantiles. arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information) loc : array_like, optional Location parameter (default=0). Returns ------- pmf : array_like Probability mass function evaluated at k r*rrrD)rr6rrrrrlr,rrrrr\rr8r9rcliprr rrrar{rrrTrUr>rrr;r<rDrDrHrBA s$     zrv_discrete.pmfc Os|j|i|\}}}tt||f\}}ttt|}|j|\}}t||}|j|}||k||k@} t|ts| |j|g|R@} || @} t t | d} | t t | d|t||jt| rt| g|f|R} t | | |j| | jdkr| dS| S)aLog of the probability mass function at k of the given RV. Parameters ---------- k : array_like Quantiles. arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information). loc : array_like, optional Location parameter. Default is 0. Returns ------- logpmf : array_like Log of the probability mass function evaluated at k. r*rrrD)rr6rrrrrlr,rr rrrrr\rr8r9rrrrrDrDrHrCg s&      zrv_discrete.logpmfcOs6|j|i|\}}}tt||f\}}ttt|}|j|\}}t||}|j|}||k||k@} ||k} t|} || @t|@} t t | d} t | | ||kdt | | ||kdt | d|t ||j t| rt| g|f|R}t | | t|j|dd| jdkr2| dS| S)aCumulative distribution function of the given RV. Parameters ---------- k : array_like, int Quantiles. arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information). loc : array_like, optional Location parameter (default=0). Returns ------- cdf : ndarray Cumulative distribution function evaluated at `k`. r*rTrrrrD)rr6rrrrr\isneginfrtrrrrr8r9rrr r)rrrar{rrrTrUr>rrrrr;r<rDrDrHr, s(     zrv_discrete.cdfcOs|j|i|\}}}tt||f\}}ttt|}|j|\}}t||}|j|}||k||k@} ||k} || @} tt| d} | t t | d|t ||j t | | ||kdt | rt| g|f|R} t | | |j| | jdkr | dS| S)a$Log of the cumulative distribution function at k of the given RV. Parameters ---------- k : array_like, int Quantiles. arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information). loc : array_like, optional Location parameter (default=0). Returns ------- logcdf : array_like Log of the cumulative distribution function evaluated at k. r*rrrrD)rr6rrrrr rrrrr\rr8r9rr"rrrrar{rrrTrUr>rrrr;r<rDrDrHr- s&     zrv_discrete.logcdfcOs|j|i|\}}}tt||f\}}ttt|}|j|\}}t||}|j|}||k||k@} ||kt|B|@} || @t|@} t t | d} t | d|t ||j t | | dt| rt| g|f|R} t | | t|j| dd| jdkr| dS| S)aSurvival function (1 - `cdf`) at k of the given RV. Parameters ---------- k : array_like Quantiles. arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information). loc : array_like, optional Location parameter (default=0). Returns ------- sf : array_like Survival function evaluated at k. r*rrTrrD)rr6rrrrr\rrtrrrrr8r9rrr%rrrDrDrHr. s$     zrv_discrete.sfcOs |j|i|\}}}tt||f\}}ttt|}|j|\}}t||}|j|}||k||k@} ||k|@} || @} tt| d} | t t | d|t ||j t | | dt | rt| g|f|R} t | | |j| | jdkr| dS| S)a_Log of the survival function of the given RV. Returns the log of the "survival function," defined as 1 - `cdf`, evaluated at `k`. Parameters ---------- k : array_like Quantiles. arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information). loc : array_like, optional Location parameter (default=0). Returns ------- logsf : ndarray Log of the survival function evaluated at `k`. r*rrrrD)rr6rrrrr rrrrr\rr8r9rr&rrrDrDrHr/s&       zrv_discrete.logsfcOs,|j|i|\}}}tt||f\}}ttt|}|j|\}}|j|||k@}|dk|dk@} |dk|@} || @} tjt| |j dd} t | |dk| | k|d|t | | ||t | rt | g|f||fR} | d| dd}} t | | |j | || jdkr(| dS| S)a"Percent point function (inverse of `cdf`) at q of the given RV. Parameters ---------- q : array_like Lower tail probability. arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information). loc : array_like, optional Location parameter (default=0). Returns ------- k : array_like Quantile corresponding to the lower tail probability, q. rrr*r1rDrNrD)rr6rrrrr\r7rr8rr9rrr)rrrar{rrrTrUr>rrrr;r<rDrDrHr00s$    zrv_discrete.ppfcOsD|j|i|\}}}tt||f\}}ttt|}|j|\}}|j|||k@}|dk|dk@} |dk|@} |dk|@} || @} tjt| |j dd} |d|}||}t | | | | k|t | | | | k|t | r,t | g|f||fR}|d|dd}}t | | |j ||| jdkr@| dS| S)a+Inverse survival function (inverse of `sf`) at q of the given RV. Parameters ---------- q : array_like Upper tail probability. arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information). loc : array_like, optional Location parameter (default=0). Returns ------- k : ndarray or scalar Quantile corresponding to the upper tail probability, q. rrr*rrNrD)rr6rrrrr\r7rr8rr9rr)r)rrrar{rrrTrUr>rrrrr;rrr<rDrDrHr1Xs*     zrv_discrete.isfcsRtdrtjSj\}}tfdd||jdgRjSdS)Npkcstj|gRSrO)r rBrrrDrHrJz&rv_discrete._entropy..rL)rrr2rrrr0r)rrarTrUrDrrHrs   zrv_discrete._entropyrDFr c  sdurfdd} nfdd} j\} } |durH| }n|}|dur^| }n|}|rj|dgRj|gR} nd} ttr| ||}|| SjdgR}t| |||j||| }|| S)a) Calculate expected value of a function with respect to the distribution for discrete distribution by numerical summation. Parameters ---------- func : callable, optional Function for which the expectation value is calculated. Takes only one argument. The default is the identity mapping f(k) = k. args : tuple, optional Shape parameters of the distribution. loc : float, optional Location parameter. Default is 0. lb, ub : int, optional Lower and upper bound for the summation, default is set to the support of the distribution, inclusive (``lb <= k <= ub``). conditional : bool, optional If true then the expectation is corrected by the conditional probability of the summation interval. The return value is the expectation of the function, `func`, conditional on being in the given interval (k such that ``lb <= k <= ub``). Default is False. maxcount : int, optional Maximal number of terms to evaluate (to avoid an endless loop for an infinite sum). Default is 1000. tolerance : float, optional Absolute tolerance for the summation. Default is 1e-10. chunksize : int, optional Iterate over the support of a distributions in chunks of this size. Default is 32. Returns ------- expect : float Expected value. Notes ----- For heavy-tailed distributions, the expected value may or may not exist, depending on the function, `func`. If it does exist, but the sum converges slowly, the accuracy of the result may be rather low. For instance, for ``zipf(4)``, accuracy for mean, variance in example is only 1e-5. increasing `maxcount` and/or `chunksize` may improve the result, but may also make zipf very slow. The function is not vectorized. Ncs|j|gRSrOrr)rarrrDrHrszrv_discrete.expect..funcs|j|gRSrOrrrarrrrDrHrsrrTrL)rr.rlr,rr0r)rrrarrrrmaxcount tolerance chunksizerrTrUrrPrrDrrHr5s&6* zrv_discrete.expectcCs.|}tddtj tjfd}||g}|S)NrTrr)rrrrrDrDrHrs zrv_discrete._param_info) NrDrNNFrrr)rrrrrrrrrrr}rrrr\rVrr r)rBrCr,r-r.r/r0r1rr5rrfrDrDrrHrL sF    &'*(&*(0 YrrrcCs<|||kr0t||d|}||} t| S||kr<|}||krH|}d\} } t||d||dD]Z} | | j7} t|| } | | 7} t| || jkrq| |krdtjdtdd| Sqdt|d|d|| dD]\} | | j7} t|| } | | 7} t| || jkrq8| |krtjdtddq8q| S)z4Helper for computing the expectation value of `fun`.r)rr)rrzexpect(): sum did not convergerV) stacklevel) r\rrw _iter_chunkedrurwarningswarnRuntimeWarning)rrrrrrrrsupprcountZtotrxdeltarDrDrHrs@     rrXc cs|dkrtd|dkr$td||dkr0dnd}t||}|}|||dkrt|t||}||}t||||} ||7}| VqDdS)aIterate from x0 to x1 in chunks of chunksize and steps inc. x0 must be finite, x1 need not be. In the latter case, the iterator is infinite. Handles both x0 < x1 and x0 > x1. In the latter case, iterates downwards (make sure to set inc < 0.) >>> from scipy.stats._distn_infrastructure import _iter_chunked >>> [x for x in _iter_chunked(2, 5, inc=2)] [array([2, 4])] >>> [x for x in _iter_chunked(2, 11, inc=2)] [array([2, 4, 6, 8]), array([10])] >>> [x for x in _iter_chunked(2, -5, inc=-2)] [array([ 2, 0, -2, -4])] >>> [x for x in _iter_chunked(2, -9, inc=-2)] [array([ 2, 0, -2, -4]), array([-6, -8])] rzCannot increment by zero.z$Chunk size must be positive; got %s.rrN)rprrr\r) rrrrrNZstepsizerxrsteprrDrDrHr s  r c seZdZdZdeddddddddf fdd Zdd Zd d Zd d ZddZ ddZ ddZ dddZ ddZ ddZddZZS)r,zA 'sample' discrete distribution defined by the support and values. The ctor ignores most of the arguments, only needs the `values` argument. rNrrc  s|tt|| |dur tdt||||||||| | d |_|durJt}||_||_||_ | |_ |j |_ |\} } t | t | krtdt | drtdt t | dstdttt | t | kstdt t | } t t | | d |_t t | | d |_|jd |_|jd |_t j|jd d |_d |_ |j|j gd dd|!|"||dS)Nz(rv_sample.__init__(..., values=None,...)rz#xk and pk must have the same shape.rz(All elements of pk must be non-negative.rz The sum of provided pk is not 1.z$xk may not contain duplicate values.rrr[rrrrs)#rrLrrprrrr8rrrrr=r\rlessr9ZallcloserwrsetrfruZargsortZtakexkrrrZcumsumqvalsrrrr)rrrrr8rrrrrrrrindxrrDrHrEsJ   zrv_sample.__init__cs(|jgd}fdd|DS)Nrcsg|]}|dqSrOrkr~rrDrHrIrJz*rv_sample.__getstate__..rrrDrrHrzs zrv_sample.__getstate__cCs |dS)z/Attaches dynamically created argparser methods.N)rrrDrDrHrszrv_sample._attach_methodscGs |j|jfS)aReturn the support of the (unscaled, unshifted) distribution. Parameters ---------- arg1, arg2, ... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information). Returns ------- a, b : numeric (float, or int or +/-np.inf) end-points of the distribution's support. r)rrarDrDrHrszrv_sample._get_supportcs.tfdd|jDfdd|jDdS)Ncsg|] }|kqSrDrD)rFrrrDrHrIrJz"rv_sample._pmf..csg|]}t|dqS)r)r\r)rFrrrDrHrIrJr)r\selectrrrrDrrHrszrv_sample._pmfcCs>t|dddf|j\}}tj||kddd}|j|S)Nrr[r)r\rrrr)rrxxxZxxkrrDrDrHr szrv_sample._cdfcCs0t|d|j\}}t||kdd}|j|S)N).Nrr[)r\rrrr)rrZqqZsqqrrDrDrHrszrv_sample._ppfcCs@|j|d}|dur2tj|dd}||d}n ||}|S)Nrr)Zndminr)rr\rr)rrurrrrDrDrHrs   zrv_sample._rvscCs t|jSrO)rr2rrrDrDrHrszrv_sample._entropycCs,t|}tj|j|tjdf|jddS)N.rr[)rr\rwrrr)rrQrDrDrHrszrv_sample.generic_momentcOs,|j||jk|j|k@}||}t|SrO)rr\rw)rrrrrar{rrrDrDrHrszrv_sample._expect)NN)rrrrrrrrrrr rrrrrrfrDrDrrHr,?s5  r,cCsg}g}t|ddd|dddddD]H\}}||ksR||krNdkrhnn|||dq*|dq*t|dddt|dddfS)a This is a utility function used by `_rvs()` in the class geninvgauss_gen. It compares the tuple argshape to the tuple size. Parameters ---------- argshape : tuple of integers Shape of the arguments. size : tuple of integers or integer Size argument of rvs(). Returns ------- The function returns two tuples, scalar_shape and bc. scalar_shape : tuple Shape to which the 1-d array of random variates returned by _rvs_scalar() is converted when it is copied into the output array of _rvs(). bc : tuple of booleans bc is an tuple the same length as size. bc[j] is True if the data associated with that index is generated in one call of _rvs_scalar(). Nrr) fillvalueTF)rrr)ZargshaperuZ scalar_shapebcZargdimZsizedimrDrDrH _check_shapes    rcCs\g}g}|D]F\}}|dr q |dr>t||r>||t||r ||q ||fS)awCollect names of statistical distributions and their generators. Parameters ---------- namespace_pairs : sequence A snapshot of (name, value) pairs in the namespace of a module. rv_base_class : class The base class of random variable generator classes in a module. Returns ------- distn_names : list of strings Names of the statistical distributions. distn_gen_names : list of strings Names of the generators of the statistical distributions. Note that these are not simply the names of the statistical distributions, with a _gen suffix added. rZ_gen)rMendswith issubclassrrl)Znamespace_pairsZ rv_base_classZ distn_namesZdistn_gen_namesrvaluerDrDrHget_distribution_namess     r)N)rrr)rXr)wZscipy._lib._utilrrrzrrrr  itertoolsrZ scipy._librZ _distr_paramsrrrZ scipy.specialr r Zscipyr r Zscipy._lib._finite_differencesr rnumpyrrrrrrrrrrrrrrrrrr r\ _constantsr!r"Z_censored_datar#Zscipy.stats._warnings_errorsr$rZ_doc_rvsZ_doc_pdfZ _doc_logpdfZ_doc_pmfZ _doc_logpmfZ_doc_cdfZ _doc_logcdfZ_doc_sfZ _doc_logsfZ_doc_ppfZ_doc_isfZ _doc_momentZ _doc_statsZ _doc_entropyZ_doc_fitZ _doc_expectZ_doc_expect_discreteZ _doc_medianZ _doc_meanZ_doc_varZ_doc_stdZ _doc_intervalrZ_doc_allmethodsZ_doc_default_longsummaryZ_doc_default_frozen_noteZ_doc_default_exampleZ_doc_default_locscaleZ _doc_defaultZ_doc_default_before_notesrrrEZ_doc_disc_methodsrGrZ_doc_disc_methods_err_varnamer+Z_doc_default_discrete_exampleZ_doc_default_discrete_locscaleZ_doc_default_discdirrrSrerhrirsryrzrrrrrrgrnrKrrrLrr r,rrrDrDrDrHs^        P  0   ,       U  8 .} ?v + $&