&]\c@`sddlmZmZmZddlmZmZmZddlm Z ddl Z ddl Z ddl Z ddlZddlZddlmZddlmZmZddlmZdd lmZdd lmZmZmZmZmZmZdd lm Z dd lm!Z!dd lm"Z"ddl#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7ddl#Z8ddl9m:Z:erdZ;n ej<Z;idd6dd6dd6Z=dZ>dZ?dZ@dZAdZBdZCdZDdZEdZFd ZGd!ZHd"ZId#ZJd$ZKd%ZLd&ZMd'ZNd(ZOd)ZPd*ZQd+ZRd,ZSd-jTe=de>e?e@eCeDeEeFeGeHeIeJeKeLeMeOePeQeReSgZUd.ZVd/ZWd0ZXd1ZYd-jTeVeUd2eXgZZd-jTeVeUgZ[ie>d36e?d46e@d56eCd66eDd76eEd86eFd96eGd:6eHd;6eJd<6eKd=6eLd>6eId?6eMd@6eSdA6ePdB6eRdC6eQdD6eOdE6eUdF6eVdG6eWdH6eXdI6eZdJ6e[dK6eYdL6Z\e\j]Z^eAe^dM>> from scipy.stats import %(name)s >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1) Calculate a few first 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, histtype='stepfilled', alpha=0.2) >>> ax.legend(loc='best', frameon=False) >>> plt.show() s5The 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``. s trvstpdftlogpdftcdftlogcdftsftlogsftppftisftstatstentropytfittmomenttexpecttintervaltmeantstdtvartmediant allmethodst longsummaryt frozennotetexampletdefaultt before_notest after_notestpmftlogpmfs , scale=1s(x, s(k, t rv_continuoust rv_discretes 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. sExamples -------- >>> from scipy.stats import %(name)s >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1) Calculate a few first 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) sThe 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)``. t_doc_sdel cC`s-|dkr|j}n|||jS(N(tNoneRC(tdatatntmu((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt_momentls c C`s|dkrdS|dkrC|dkr:|d|}q|}nz|dkr|dksg|dkry|d|}q|||}n3|dkr|dks|dks|dkr|d|}q|tj|d}|d|||||}n|dkr|dks?|dks?|dks?|dkrQ|d|}q|d|d } |tj|d}| d||d |||||||}n|||}|S( Nig?iiig?ig@g@i(RStnptpower( RURVtmu2tg1tg2t moment_functargstvaltmu3tmu4((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt_moment_from_statsrs.      $! 05cC`sWtj|}|j}||dj}||dj}|tj|dS(s8 skew is third central moment / variance**(1.5) iig?(RXRRCRY(RTRVtm2tm3((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt_skews  cC`sStj|}|j}||dj}||dj}||ddS(s= kurtosis is fourth central moment / variance**2 - 3 iii(RXRRC(RTRVRctm4((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt _kurtosiss  t rv_frozencB`seZdZedZejdZdZdZdZdZ dZ dZ ddd Z d Zd Zd d ZdZdZdZdZdZdZdZdZdZdddedZRS(cO`s{||_||_|j|j|_|jj||\}}}|jj||jj|jj|_|_dS(N( R^tkwdst __class__t_updated_ctor_paramtdistt _parse_argst _argchecktatb(tselfRlR^Ritshapest_((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt__init__s   cC`s |jjS(N(Rlt _random_state(Rq((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt random_statescC`st||j_dS(N(R RlRu(Rqtseed((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyRvscC`s|jj||j|jS(N(RlR5R^Ri(Rqtx((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR5scC`s|jj||j|jS(N(RlR6R^Ri(RqRx((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR6scC`s|jj||j|jS(N(RlR7R^Ri(RqRx((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR7scC`s|jj||j|jS(N(RlR8R^Ri(RqRx((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR8scC`s|jj||j|jS(N(RlR;R^Ri(Rqtq((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR;scC`s|jj||j|jS(N(RlR<R^Ri(RqRy((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR<scC`s@|jj}|ji|d6|d6|jj|j|S(NtsizeRv(RitcopytupdateRlR4R^(RqRzRvRi((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR4scC`s|jj||j|jS(N(RlR9R^Ri(RqRx((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR9scC`s|jj||j|jS(N(RlR:R^Ri(RqRx((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR:stmvcC`s9|jj}|ji|d6|jj|j|S(Ntmoments(RiR{R|RlR=R^(RqR~Ri((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR=scC`s|jj|j|jS(N(RlRFR^Ri(Rq((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyRFscC`s|jj|j|jS(N(RlRCR^Ri(Rq((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyRCscC`s|jj|j|jS(N(RlRER^Ri(Rq((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyREscC`s|jj|j|jS(N(RlRDR^Ri(Rq((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyRDscC`s|jj||j|jS(N(RlR@R^Ri(RqRU((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR@scC`s|jj|j|jS(N(RlR>R^Ri(Rq((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR>scC`s|jj||j|jS(N(RlRNR^Ri(Rqtk((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyRNscC`s|jj||j|jS(N(RlROR^Ri(RqR((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyROscC`s|jj||j|jS(N(RlRBR^Ri(Rqtalpha((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyRBsc K`s|jj|j|j\}}}t|jtrX|jj|||||||S|jj||||||||SdS(N(RlRmR^Rit isinstanceRQRA( RqR,tlbtubt conditionalRiRotloctscale((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyRAs $"N(t__name__t __module__RttpropertyRvtsetterR5R6R7R8R;R<RSR4R9R:R=RFRCRERDR@R>RNRORBtFalseRA(((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyRhs.                   cG`s]tj|}t|ts*|g}n||k}g|D]}tj|||^q=S(sReturn the sequence of ravel(args[i]) where ravel(condition) is True in 1D. Examples -------- >>> import numpy as np >>> rand = np.random.random_sample >>> A = rand((4, 5)) >>> B = 2 >>> C = rand((1, 5)) >>> cond = np.ones(A.shape) >>> [A1, B1, C1] = argsreduce(cond, A, B, C) >>> B1.shape (20,) >>> cond[2,:] = 0 >>> [A2, B2, C2] = argsreduce(cond, A, B, C) >>> B2.shape (15,) (RXt atleast_1dRtlisttextract(tcondR^tnewargst expand_arrtarr1((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt argsreduce s   s 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 cC`s||dd}tj|tj|}}t|d||d||d}|tjt|||d7}|S(Ng@g?g?i(RXRRRR(Rxtdftnctdf2txstnstres((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt _ncx2_log_pdf5s '$cC`stjt|||S(N(RXtexpR(RxRR((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt _ncx2_pdf@scC`st|||S(N(R (RxRR((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt _ncx2_cdfDst rv_genericcB`sReZdZd!dZedZejdZdZdZ dZ d!dZ d!d!d!dd Z d Z d Ze je_d Zd ZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZ dZ!dZ"d Z#RS("s^Class which encapsulates common functionality between rv_discrete and rv_continuous. cC`sXtt|jt|j}|ddk p?d|dk|_t||_dS(NiR~i( tsuperRRtt _getargspect_statsRSt_stats_has_momentsR Ru(RqRwtsign((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyRtMs cC`s|jS(sY Get or set the RandomState object for generating random variates. This can be either None or an existing RandomState object. If None (or np.random), use the RandomState singleton used by np.random. If already a RandomState instance, use it. If an int, use a new RandomState instance seeded with seed. (Ru(Rq((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyRvVs cC`st||_dS(N(R Ru(RqRw((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyRvcscC`s|j|jfS(N(RkRu(Rq((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt __getstate__gscC`s&|\}}|j|||_|S(N(RtRu(Rqtstatet ctor_paramtr((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt __setstate__js   cC`sN|jrt|jts*tdn|jjddj}x5|D]E}tj|rptdnt j d|sLtdqLqLWng}x|D]}t |}|j d} | r|j | |jdk rtdn|jdk rtd n|jdk r4td q4qqW|rw|d }x2|D]!} | |krOtd qOqOWng}|rd j|d nd} td| d|d|} i} tt| | x:dddgD])}t||t| |||jqW|r d j|nd|_t|dsJt||_ndS(s!Construct the parser for the shape arguments. Generates the argument-parsing functions dynamically and attaches them to the instance. Is supposed to be called in __init__ of a class for each distribution. 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`. sshapes must be a string.t,t s"keywords cannot be used as shapes.s^[_a-zA-Z][_a-zA-Z0-9]*$s'shapes must be valid python identifiersis+*args are not allowed w/out explicit shapess,**kwds are not allowed w/out explicit shapess#defaults are not allowed for shapesis!Shape arguments are inconsistent.s, R3t shape_arg_strt locscale_int locscale_outRmt_parse_args_statst_parse_args_rvstnumargsN(RrRRt TypeErrortreplacetsplittkeywordt iskeywordt SyntaxErrortretmatchRR^tappendtvarargsRStkeywordstdefaultstjointdictRtparse_arg_templatetsetattrR/RjthasattrtlenR(Rqtmeths_to_inspectRRRrtfieldt shapes_listtmetht shapes_argsR^titemt shapes_strtdctRtname((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt_construct_argparserpsT              cC`s|j}|jpd|d<|jp+d|d<|dkrGd}ndjd|D}||d<|jpvd|d<|jr|jd kr|dcd 7stvalstshapes_iRs >>> %s = %st set_vals_stmtRKRLs- %(shapes)s : array_like shape parametersis %(shapes)s, s(, t(s, )t)N(( R{RRrRSRRRtranget__doc__Rt docformat(Rqtdocdictt shapes_valsttempdictRRti((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt_construct_docs,       t continuouscC`s|d krd}n|d kr*d}n|jdrF|d}ndjd||fdtd|dg|_|j|d S( s7Construct instance docstring from the default template.tAR3s is%s %s random variable.s %(before_notes)s R1s %(example)sN(RSt startswithRt docheadersRR(RqtlongnametextradocRtdiscrete((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt_construct_default_docs      cO`st|||S(sFreeze 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. (Rh(RqR^Ri((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pytfreezescO`s|j||S(N(R(RqR^Ri((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt__call__scO`sdS(N(NNNN(RS(RqR^Ri((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyRscG`s5tjdd}|j||}tj||S(Ntalltignore(RXtseterrtgeneric_moment(RqRUR^tolderrR((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt_munp s cO`s[|jdd}tj|}d}g|D]}||^q1}|dj}|dj}|dkrx|} nttj|} |t| } | dkrd| |}n| dkrd | | } nt gt || D]$\} } | dkp | | k^q} | s-t dn|d }|d}|d}|||| fS( NRzcS`s7x0|jdkr2|jddkr2|d}qW|S(Nii(tndimR(Ro((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt squeeze_left!s%iis:size does not match the broadcast shape of the parameters.ii(i(i( tgetRSRXtbroadcast_arraysRRttupleRRRtzipt ValueError(RqR^tkwargsRzt all_bcastRRot bcast_shapet bcast_ndimtsize_tndifftbcdimtszdimtokt param_bcastt loc_bcastt scale_bcast((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt _argcheck_rvss,         :   cG`s6d}x)|D]!}t|t|dk}q W|S(sDefault 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. ii(RR#(RqR^Rtarg((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyRn]s cC`s|j|k||jk@S(N(RoRp(RqRx((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt _support_maskiscC`s|j|k||jk@S(N(RoRp(RqRx((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt_open_support_masklscG`s+|jj|j}|j||}|S(N(Rut random_samplet_sizet_ppf(RqR^tUtY((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt_rvsoscG`st|j||S(N(Rt_cdf(RqRxR^((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt_logcdfzscG`sd|j||S(Ng?(R (RqRxR^((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt_sf}scG`st|j||S(N(RR (RqRxR^((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt_logsfscG`s|j||S(N(t_ppfvec(RqRyR^((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyRscG`s|jd||S(Ng?(R(RqRyR^((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt_isfsc O`s@|jdd}|jdd}|j||\}}}}t|j||dk}tj|s~tdntj|dkr|t|dS|dk r|j } t ||_ n||_ |j |} | ||} |dk r | |_ n|r<|dkr*t | } q<| jt } n| S(sj 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). 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 or int or ``np.random.RandomState`` instance, optional If int or RandomState, use it for drawing the random variates. If None, rely on ``self.random_state``. Default is None. Returns ------- rvs : ndarray or scalar Random variates of given `size`. RRvisDomain error in arguments.tdN((tpopRSRRRnRXRRRRuR RRtinttastype( RqR^RiRtrndmRRRzRtrandom_state_savedR((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR4s*      c O`s)|j||\}}}}tt||f\}}ttt|}|j||dk@||k@}g}tt||j}tj |rt ||||f} | d| d| d }}} |j r|j | i|d6\} } } } n|j | \} } } } | dkr8d}nF| dkrY|jd| } n| dkr~| tj| d}nd|kr| dkr|jd| } n|j}t||| |||j|nd |kr| dkrV|jd| }| dkr*|jd| } n|| | } tj| rVtj} qVn|j}t||| |||j|nd |kr|| dkrP|jd | }| dkr|jd| } n| dkr|jd| }|| | } ntjd d 5|d | | | d }|tj| d} WdQXn|j}t||| |j|nd|kr| dkr|jd| }| dkr|jd| } n| dkr|jd| }|| | } n|dkrJ|jd | }tjd d |d | | | d }WdQXntjd d A|d| |d| | | | d}|| dd} WdQXn|j}t||| |j|qn0g}x'|D]}|j}|j|qWt|dkr|dSt|SdS(s Some 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. iiiR~ig?tmitvtsitinvalidRNRiig@g@(RtmapR#RRntvalarrayRtbadvalueRXtanyRRRRSRRYR{R RR&R%terrstateR(RqR^RiRRR~RtoutputRKtgoodargsRVRZR[R\R`tout0tmu2ptmu3ptmu4pRaRs((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR=s#                        #*   c O`s|j||\}}}tt||f\}}ttt|}|j||dk@||k@}tt|d}t|d||jt |||}|d}|d}t|||j |t ||S(s Differential 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`: >>> drv = rv_discrete(values=((0, 1), (0.5, 0.5))) >>> np.allclose(drv.entropy(), np.log(2.0)) True iRi( RmRR#RRnRRR RRt vecentropyR( RqR^RiRRtcond0RRt goodscale((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR>?s#  #c O`s|j||\}}}|j|o3|dks:tSt||kr[tdn|dkrvtdnd\}}}} |dkr|dkr|jriidd6dd6d d 6d d 6|d 6} ni} |j|| \}}}} nt||||| |j |} |dkr9||| Sd} t |t |} xZt |D]L}t||||| |j |}| t ||dt | ||7} qbW| | || 7} | ||SdS(s n-th order non-central moment of distribution. Parameters ---------- n : int, n >= 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) isMoment must be an integer.sMoment must be positive.iRiRitvsitvkiR~texactN(NNNN(RmRnR$RRRSRRRbRtfloatRR tTrue(RqRUR^RiRRRVRZR[R\tmdictR_tresulttfacRtvalk((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR@cs.  0!!  !)cO`s|jd||S(sr Median 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 -------- stats.distributions.rv_discrete.ppf Inverse of the CDF g?(R;(RqR^Ri((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyRFscO`sFd|d<|j||}t|trB|jdkrB|dS|S(s Mean 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 RR~i((R=RRR(RqR^RiR((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyRCs  cO`sFd|d<|j||}t|trB|jdkrB|dS|S(s Variance 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 RR~i((R=RRR(RqR^RiR((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyREs  cO`s&d|dR@RFRCRERDRB(((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyRHsD     P "      J        > v $ .    c B`sdeZdZdd$d$dd$d$d$d$d$d$d ZdZdZdZdZdZ d Z d Z d Z d Z d ZdZdZdZdZdZdZdZdZdZdZdZdZdZdZd$dZdZdZdZ d Z!d!Z"d$d%d"dd$d$e#d#Z$RS(&sQ A 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. extradoc : str, optional, deprecated This string is used as the last part of the docstring returned when a subclass has no docstring of its own. Note: `extradoc` exists for backwards compatibility, do not use for new subclasses. seed : None or int or ``numpy.random.RandomState`` instance, optional This parameter defines the RandomState object to use for drawing random variates. If None (or np.random), the global np.random state is used. If integer, it is used to seed the local RandomState instance. Default is None. 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 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 a distribution, ``self.a <= x <= self.b``. 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. 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 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. 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``. ig+=c C`stt|j| td|d|d|d|d|d|d|d|d | d | |_|dkrst}n|dkrd }n||_||_||_ ||_ |dkrt |_ n|dkrt |_ n||_ ||_ ||_|jd |j|jgd dddt|jdd|_|jd|j_t|jdd|_t|jdd|_|jd|j_| |_|dkrt|jdd|_nt|jdd|_|jd|j_|dkr!|ddkrd} nd} | |}ntj j!dkr|j"dkrg|j#d|d | dt$ddqtt%} |j&t$| j'|jndS(NtmomtypeRoRptxtolRRRRrRRwt DistributionRRsloc=0, scale=1Rs loc, scaletotypesRiit aeiouAEIOUsAn sA iRRR(R6((RRPRtRt _ctor_paramRSR$RRRoRpR%R3t moment_typeRrRt_pdfR R"t _ppf_singleR Rtnint_entropyR$t _cdf_singlet_cdfvecRt_mom0_scRt_mom1_sctsystflagsRRRRRRR( RqR2RoRpR3RRRRrRRwthstrR((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyRts\                      cC`sn|jj}|j|d<|j|d<|j|d<|j|d<|j|d<|j|d<|j|d<|S(s Return the current version of _ctor_param, possibly updated by user. Used by freezing and pickling. Keep this in sync with the signature of __init__. RoRpR3RRRrR( R7R{RoRpR3RRRrR(RqR((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyRks       cG`s|j|f||S(N(R7(RqRxRyR^((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt _ppf_to_solve*scG`sd}}|jtj kr)|j}n|jtjkrG|j}nd}|sd|}x2|j|||dkr|}||9}q`Wn|s|}x2|j|||dkr|}||9}qWntj|j||d|f|d|jS(Ng$@ggR^R3( RSRoRXR%RpRDRtbrentqR3(RqRyR^tlefttrighttfactor((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR:-s$     cG`s|||j||S(N(R5(RqRxRR^((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt _mom_integ0FscG`s-tj|j|j|jd|f|dS(NR^i(RtquadRIRoRp(RqRR^((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR?IscG`s|j|||S(N(R;(RqRyRR^((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt _mom_integ1NscG`s'tj|jddd|f|dS(NiiR^(RRJRK(RqRR^((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR@Qsc G`s"t|j|ddd|ddS(Ntdxgh㈵>R^torderi(RR (RqRxR^((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR9TscG`st|j||S(N(RR9(RqRxR^((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt_logpdfXscG`s#tj|j|j|d|dS(NR^i(RRJR9Ro(RqRxR^((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR=[scG`s|j||S(N(R>(RqRxR^((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR ^sc O`s}|j||\}}}tt|||f\}}}ttt|}tj|jtjgg}tj|||d|}|j||dk@}|j ||dk@}||@} t t | |} t | d|tj ||jtj| rbt| |f||f} | d| d }} t| | |j| |n| jdkry| dS| S(sM Probability 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 tdtypeiii((RmRR#RRXtfind_common_typeROtfloat64RnRRRRtisnanRRRR R9R( RqRxR^RiRRtdtypR%tcond1RRR((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR5ds"! $ c O`s|j||\}}}tt|||f\}}}ttt|}tj|jtjgg}tj|||d|}|j||dk@}|j ||dk@}||@} t t | |} | j t t| d|tj||jtj| rut| |f||f} | d| d }} t| | |j| t|n| jdkr| dS| S(s Log 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 ROiii((RmRR#RRXRPRORQRnRR(RtfillR'RRRRRRR RNRR( RqRxR^RiRRRSR%RTRRR((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR6s$!  $&c O`s|j||\}}}tt|||f\}}}ttt|}tj|jtjgg}tj|||d|}|j||dk@}|j ||dk@}||j k|@} ||@} t t | |} t | d|tj||jt | | dtj| ret| |f|} t | | |j| n| jdkr|| dS| S(sR 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` ROiig?((RmRR#RRXRPRORQRnRRpRRR RRRRRR R( RqRxR^RiRRRSR%RTtcond2RRR((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR7s$! $c O`s|j||\}}}tt|||f\}}}ttt|}tj|jtjgg}tj|||d|}|j||dk@}|j ||dk@}||j k|@} ||@} t t | |} | j tt| d|||ktj||jt| | dtj| r|t| |f|} t| | |j| n| jdkr| dS| S(sq Log 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 ROiig((RmRR#RRXRPRORQRnRRpR(RRUR'R RRRRRR R( RqRxR^RiRRRSR%RTRVRRR((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR8s&!  .c O`s|j||\}}}tt|||f\}}}ttt|}tj|jtjgg}tj|||d|}|j||dk@}|j ||dk@}|||j k@} ||@} t t | |} t | d|tj||jt | | dtj| ret| |f|} t | | |j| n| jdkr|| dS| S(sE 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 ROiig?((RmRR#RRXRPRORQRnRRoRRR RRRRRR R( RqRxR^RiRRRSR%RTRVRRR((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR9 s$! $c O`s|j||\}}}tt|||f\}}}ttt|}tj|jtjgg}tj|||d|}|j||dk@}|j ||dk@}|||j k@} ||@} t t | |} | j tt| d|tj||jt| | dtj| rrt| |f|} t| | |j| n| jdkr| dS| S(s Log 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`. ROiig((RmRR#RRXRPRORQRnRRoR(RRUR'R RRRRRR R( RqRxR^RiRRRSR%RTRVRRR((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR:3s&!  $cO`s|j||\}}}tt|||f\}}}ttt|}|j||dk@||k@}d|k|dk@}||dk@}||dk@} ||@} tt| d|j} |j||} |j ||} t | |t || dt | | t | | dt j | rt | |f|||f}|d|d|d }}}t | | |j|||n| jdkr| dS| S(st 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) scale : array_like, optional scale parameter (default=1) Returns ------- x : array_like quantile corresponding to the lower tail probability q. iitvalueii((RmRR#RRnRRRRoRpR RRXRRR(RqRyR^RiRRR%RTRVtcond3RRt lower_boundt upper_boundR((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR;`s(!#   $cO`s|j||\}}}tt|||f\}}}ttt|}|j||dk@||k@}d|k|dk@}||dk@}||dk@} ||@} tt| d|j} |j||} |j ||} t | |t || dt | | t | | dt j | rt | |f|||f}|d|d|d }}}t | | |j|||n| jdkr| dS| S(s} 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) scale : array_like, optional scale parameter (default=1) Returns ------- x : ndarray or scalar Quantile corresponding to the upper tail probability q. iiRWii((RmRR#RRnRRRRoRpR RRXRRR(RqRyR^RiRRR%RTRVRXRRRYRZR((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR<s(!#   $cG`s tj|j||dd S(Ntaxisi(RXtsumRN(RqRxR^((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt_nnlfscC`sUy(|d}|d}t|d }Wntk rGtdnX|||fS(NiisNot enough input arguments.(Rt IndexErrorR(RqtthetaRRR^((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt_unpack_loc_scales   cC`s|j|\}}}|j| s4|dkr8tSt|||}t|t|}tj|j|rtS|j |||S(sReturn negative loglikelihood function. Notes ----- This is ``-sum(log pdf(x, theta), axis=0)`` where `theta` are the parameters (including loc and scale). i( R`RnR%R#RRRXRRR](RqR_RxRRR^t n_log_scale((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pytnnlfscC`s|j|}tj|dd}|dkrHt||d}n|j||}tj|}|tj|dd7}|dkr|ttd}tj||dd |Stj|dd S(NR[iid( RRXt count_nonzeroRRNtisfiniteR\RR)(RqRxR^R%tn_badR6t finite_logpdftpenalty((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt_nnlf_and_penaltys  cC`sv|j|\}}}|j| s4|dkr8tSt|||}t|t|}|j|||S(s Return penalized negative loglikelihood function, i.e., - sum (log pdf(x, theta), axis=0) + penalty where theta are the parameters (including loc and scale) i(R`RnR%R#RRRh(RqR_RxRRR^Ra((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt_penalized_nnlfs cC`sB|dkrd|j}n|j||\}}|||fS(Ng?(g?(RSRt_fit_loc_scale_support(RqRTR^RR((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt _fitstarts c `sjrjjddj}xt|D]z\}}|jd|dpf|jd|d}|dk r1d|}||krtd|q|||d } nyt t| } Wqxtk rttd | qxXn|rtd |n| | |d t|fd d} | dk r| || } nt| } | S(s Return MLEs for shape (if applicable), location, and scale parameters from data. MLE stands for Maximum Likelihood Estimate. 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 Data to use in calculating the MLEs. args : 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 Starting values for the location and scale parameters; no default. 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=0`` to suppress output as keyword arguments. Returns ------- mle_tuple : tuple of floats MLEs 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 ----- This fit is computed by maximizing a log-likelihood function, with penalty applied for samples outside of range of the distribution. The returned answer is not guaranteed to be the globally optimal MLE, it may only be locally optimal, or the optimization may fail altogether. Examples -------- Generate some data to fit: draw random variates from the `beta` distribution >>> from scipy.stats import beta >>> a, b = 1., 2. >>> x = beta.rvs(a, b, size=1000) Now we can fit all four parameters (``a``, ``b``, ``loc`` and ``scale``): >>> a1, b1, loc1, scale1 = beta.fit(x) 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) sToo many input arguments.iRRiit optimizertfmin_tfmins%s is not a valid optimizersUnknown arguments: %s.R^tdispiN(RRRRSRkRRyRR|tcallableRRRtgetattrtAttributeErrorRRR( RqRTR^RitNargtstartRRRxR,RrRzR((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR?-s:`       $  cG`sctj|}|j||\}}|j||j|j}}||}|dkrg||fS|||}|||} tj|} tj|} || kr| | kr||fS| | } d} | | }|tjkr| ||}| d||}||fS|tj kr8| ||dfS|tjkrY| ||dfSt dS(s Estimate 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. ig?iiN( RXR#t fit_loc_scaleRnRoRptmintmaxR%t RuntimeError(RqRTR^tloc_hatt scale_hatRoRpt support_widthta_hattb_hattdata_atdata_bt data_widtht rel_margintmargin((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyRjs2        c G`s|j|idd6\}}t|}|j}|j}t||}|||} tj| syd} ntj|od|ksd}n| |fS(s 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. R}R~ii(R=R#RCRERRXRd( RqRTR^RVRZttmptmuhattmu2hattShattLhat((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyRs     c `sfd}tjdd}tj|jjd}tj|tj|sc|Sjddg\}}tjjr|}n j}tjjr|}n j}tj|||dSdS(Nc`sj|}t|S(N(R9R(RxR_(R^Rq(s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pytinteg stoverRig|=g?gA?( RXRRRJRoRpRRR;R&( RqR^RRthtlowtupptuppertlower((R^Rqs@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR< s     ic  `si|d6|d6j|d krBfd} nfd} |d krw|j|}n|d kr|j|}n|rj||j||} nd} ||d>> 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. RRc`s|j||S(N(R5(RxR^(tlockwdsRq(s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pytfun{ sc`s|j||S(N(R5(RxR^(R,RRq(s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR~ sg?R^RRiN( RnRSRoRpR9RXRRRJ( RqR,R^RRRRRRiRtinvfacRR((R,RRqs@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyRA, s&K         N((%RRRRSRtRkRDR:RIR?RKR@R9RNR=R R5R6R7R8R9R:R;R<R]R`RbRhRiRkRyR?RjRR<RRA(((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyRP"sH  ?            ( + ) * ) - - -    4 A c`s@fd}t|jjjdjS(s,Non-central moment of discrete distribution.c`s tj|j|S(N(RXRYt_pmf(Rx(R^RURq(s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR sg?(t_expectRoRpR;tinc(RqRUR^R((R^RURqs@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt _drv2_moment sc G`s|j}|j}t|rttd|d}xR||jkrSd}Pn|j||}||kr~|d7}q:Pq:Wnd}t|rttd|d}x^||jkrd}Pn|j||}||kr|d8}qPqWn|j||}x||kr%|S||kr5|S||dkr\||krU|S|Snt||d}|j||}||kr||kr|}n td |}q||kr||kr|}n td |}q|SqWdS( Nidi g?iigig@supdating stopped, endless loop(RpRoR&RRR RR( RqRyR^RpRotqbtqatctqc((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt_drv2_ppfsingle s\                     cC`st|}d|tj|dd}|dkrDt|}n_t|}t|t|krwtdnd|tj|dd}t||}tj|dd}|dk r|t|}n|S(sYCalculate the entropy of a distribution for given probability values. If only probabilities `pk` are given, the entropy is calculated as ``S = -sum(pk * log(pk), axis=0)``. If `qk` is not None, then compute the Kullback-Leibler divergence ``S = sum(pk * log(pk / qk), axis=0)``. This routine will normalize `pk` and `qk` if they don't sum to 1. Parameters ---------- pk : sequence Defines the (discrete) distribution. ``pk[i]`` is the (possibly unnormalized) probability of event ``i``. qk : sequence, optional Sequence against which the relative entropy is computed. Should be in the same format as `pk`. base : float, optional The logarithmic base to use, defaults to ``e`` (natural logarithm). Returns ------- S : float The calculated entropy. g?R[is qk and pk must have same length.N( R#RXR\RSRRRRR(tpktqktbasetvectS((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR> s    c B`seZdZdedddddddddd Zdedddddddddd ZdZdZdZ d Z d Z d Z d Z d ZdZdZdZdZdZdZdZdZdZdddddedddd ZRS(s+ A 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 with non-zero probabilities ``pk`` with ``sum(pk) = 1``. 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. extradoc : str, optional This string is used as the last part of the docstring returned when a subclass has no docstring of its own. Note: `extradoc` exists for backwards compatibility, do not use for new subclasses. seed : None or int or ``numpy.random.RandomState`` instance, optional This parameter defines the RandomState object to use for drawing random variates. If None, the global np.random state is used. If integer, it is used to seed the local RandomState instance. Default is None. Methods ------- rvs pmf logpmf cdf logcdf sf logsf ppf isf moment stats entropy expect median mean std var interval __call__ 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: - 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``.) - scale parameter is not defined. 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. Examples -------- Custom made discrete distribution: >>> 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) ig:0yE>ic C`s<|dk r"tt|jtStt|j|SdS(N(RSRRQt__new__t rv_sample( R.RoRpRRt moment_toltvaluesRRRrRRw((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR s c C`stt|j| td|d|d|d|d|d|d|d|d | d | d | |_|dkryt}n||_||_||_ ||_ ||_ t |j d d |_t |j|_| |_|dk rtdn|jd|j|jgddddt td d } |jd| _t| |t|_t td d } |jd| _t| |t|_|jd|j_|j||| dS(NRoRpRRRRRRRrRRwR5Rs.rv_discrete.__init__(..., values != None, ...)RRsloc=0Rsloc, 1ii(RRQRtRR7RSR$RRoRpRRR"R=R>R<R$RrRRRR RRR;R/RRR t_construct_docstrings(RqRoRpRRRRRRRrRRwt_vec_generic_momentt_vppf((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyRt s<         c C`s|dkrd}n||_||_|dkr_|dd krLd}nd}||}ntjjdkr|jdkr|jd|d|d td d n(t t }|j t|j |j|jj d d |_ndS(NR4iR6sAn sA iRRRRsE scale : array_like, optional scale parameter (default=1)R3(R6(RSRRRARBRRRtdocdict_discreteRR RRR(RqRRRRCR((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR s(          cC`s{|jj}|j|d<|j|d<|j|d<|j|d<|j|d<|j|d<|j|d<|j |d<|S( s Return the current version of _ctor_param, possibly updated by user. Used by freezing and pickling. Keep this in sync with the signature of __init__. RoRpRRRRRrR( R7R{RoRpRRRRRrR(RqR((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyRk s        cG`st||kS(N(R(RqRR^((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt_nonzero scG`s$|j|||j|d|S(Ni(R (RqRR^((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR scG`st|j||S(N(RR(RqRR^((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyt_logpmf scG`s;tt|j|d}tj|j||ddS(NiR[i(RRRoRXR\R(RqRR^R((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR= scG`st|}|j||S(N(RR>(RqRxR^R((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR  s cO`s#t|d| dS| S(s Log 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. Rii((RmRR#RRnRoRpRR(RRUR'R RXRRRRRRR( RqRR^RiRRsR%RTRRR((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyROD s ,  $c O`s]|j||\}}}tt||f\}}ttt|}t||}|j|}||jk||jk@}||jk}||@} tt| d} t | d|t j ||j t | |||kdt j | rBt| |f|} t | | t j|j| ddn| jdkrY| dS| S(s Cumulative 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`. Rig?i((RmRR#RRnRoRpRRR RXRRRRRRR R( RqRR^RiRRsR%RTRVRRR((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR7i s" $+c O`s[|j||\}}}tt||f\}}ttt|}t||}|j|}||jk||jk@}||jk}||@} tt| d} | j t t | d|t j ||jt | |||kdt j| r@t| |f|} t | | |j| n| jdkrW| dS| S(s- 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. Rigi((RmRR#RRnRoRpR(RRUR'R RXRRRRRR R( RqRR^RiRRsR%RTRVRRR((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR8 s$  $c O`sW|j||\}}}tt||f\}}ttt|}t||}|j|}||jk||jk@}||jk|@}||@} tt| d} t | d|t j ||j t | |dt j | r<t| |f|} t | | t j|j| ddn| jdkrS| dS| S(s Survival 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. Rig?i((RmRR#RRnRoRpRRR RXRRRRRRR R( RqRR^RiRRsR%RTRVRRR((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR9 s" $+c O`sU|j||\}}}tt||f\}}ttt|}t||}|j|}||jk||jk@}||jk|@}||@} tt| d} | j t t | d|t j ||jt | |dt j| r:t| |f|} t | | |j| n| jdkrQ| dS| S(sh 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`. Rigi((RmRR#RRnRoRpR(RRUR'R RXRRRRRR R( RqRR^RiRRsR%RTRVRRR((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR: s$  $c O`sk|j||\}}}tt||f\}}ttt|}|j|||k@}|dk|dk@}|dk|@}||@} tt| d|jdd} t| |dk| | k|j dt| ||j t j | rPt | |f||f} | d| d }} t| | |j| |n| jdkrg| dS| S(s+ 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. iiRWttypecodeRi((RmRR#RRnRRRR RoRpRXRRRR( RqRyR^RiRRsR%RTRVRRR((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR; s" !' c O`sk|j||\}}}tt||f\}}ttt|}|j|||k@}|dk|dk@}|dk|@}||@} tt| d|jdd} t| |dk| | k|j t| ||j dt j | rPt | |f||f} | d| d }} t| | |j| |n| jdkrg| dS| S(s4 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. iiRWRRi((RmRR#RRnRRRR RpRoRXRRRR( RqRyR^RiRRsR%RTRVRRR((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR<0 s" !# c`sWtdrtjStfdjjjdjSdS(NRc`stj|S(N(RRN(Rx(R^Rq(s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyta sg?(RR>RRRoRpR;R(RqR^((R^Rqs@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR<] s ig|=i c  `sdkr$fd} nfd} j|dkraj}n |}|dkrj}n |}|rj|dj|} nd} jd} t| ||| j||| } | | S(s 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 (``ul <= 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 ``ul <= 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. c`s|j|S(N(R(Rx(R^RRq(s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR sc`s|j|S(N(R(Rx(R^R,RRq(s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR sig?g?N(RSRnRoRpR9R;RR(RqR,R^RRRRtmaxcountt tolerancet chunksizeRRRxR((R^R,RRqs@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyRAd s 4        )$N((RRRR%RSRRtRRkRRRR=R R4RNROR7R8R9R:R;R<R<RRA(((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyRQ s4    /         $ % ' ( & * ( - ig|=i cC`s|||krBtj||d|}||} tj| S||krW|}n||krl|}nd\} } xt||dd|d|D]o} | | j7} tj|| } | | 7} t| || jkrPn| |krtjdt| SqWxt|d|dd|d| D]o} | | j7} tj|| } | | 7} t| || jkrPn| |kr0tjdtPq0q0W| S(s4Helper for computing the expectation value of `fun`.iigRRsexpect(): sum did not converge(ig( RXRR\t _iter_chunkedRztabstwarningstwarntRuntimeWarning(RRRRxRRRRtsuppRtcountttotRxtdelta((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR s8       &   +   ic c`s|dkrtdn|dkr:td|n|dkrLdnd}t||}|}xc|||dkrt|t||}||}tj||||} ||7}| VqkWdS(sVIterate 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.) >>> [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])] isCannot increment by zero.s$Chunk size must be positive; got %s.iiN(RRRRXR( Rxtx1RRRtstepsizeRxRtstepR((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR s    Rc B`sneZdZded d dd dd d d d d ZdZdZdZdZ d Z d Z RS( sA 'sample' discrete distribution defined by the support and values. The ctor ignores most of the arguments, only needs the `values` argument. ig:0yE>ic C`stt|j| |dkr1tdntd|d|d|d|d|d|d|d |d | d | d | |_|dkrt}n||_||_ ||_ | |_ |j |_ |\} } t| t| krtd ntjtj| ds!tdntjtj| }tjtj| |d|_tjtj| |d|_|jd|_|jd|_tj|jdd|_d|_ |jd|jgdddd|j||| dS(Ns(rv_sample.__init__(..., values=None,...)RoRpRRRRRRRrRRws'xk and pk need to have the same length.is The sum of provided pk is not 1.iiR[RRRsloc=0Rsloc, 1(RRQRtRSRRR7R$RRRRrR<R$RRXtallcloseR\targsortRttaketxkRRoRptcumsumtqvalsRRR(RqRoRpRRRRRRRrRRwRRtindx((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyRt s<         !! cC`sUtjg|jD]}||k^qg|jD]}tj||d^q/dS(Ni(RXtselectRRR(RqRxRtp((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR7 s%cC`sUtj|dddf|j\}}tj||kddd}|j|S(NR[ii(RXRRSRR!R(RqRxtxxtxxkR((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR ; s+cC`sBtj|d|j\}}t||kdd}|j|S(N.R[i(.N(RXRRSRR!R(RqRytqqtsqqR((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR@ scC`sb|jj|j}|jdkrOtj|dd}|j|d}n|j|}|S(Ntndminii(RuRRRSRXtarrayR(RqRR((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyRE s cC`s t|jS(N(R>R(Rq((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR<P scC`s:t|}tj|j|tjdf|jddS(N.R[i(R#RXR\RtnewaxisR(RqRU((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyRS s N( RRRR%RSRtRR RRR<R(((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyR s  +    cC`sg}g}xv|D]n\}}|jdr4qn|jdrbt||rb|j|nt||r|j|qqW||fS(s| Collect 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. Rst_gen(Rtendswitht issubclassRR(tnamespace_pairst rv_base_classt distn_namestdistn_gen_namesRRW((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pytget_distribution_namesX s(t __future__RRRtscipy._lib.sixRRRtscipy._lib._utilRRRARRR*Rt scipy.miscRt _distr_paramsRR R R Rt scipy.specialR R RRRRtscipyRRRtnumpyRRRRRRRRRRRR R!R"R#R$R%R&R'R(RXt _constantsR)R/R+Rt_doc_rvst_doc_pdft _doc_logpdft_doc_pmft _doc_logpmft_doc_cdft _doc_logcdft_doc_sft _doc_logsft_doc_ppft_doc_isft _doc_momentt _doc_statst _doc_entropyt_doc_fitt _doc_expectt_doc_expect_discretet _doc_mediant _doc_meant_doc_vart_doc_stdt _doc_intervalRt_doc_allmethodst_doc_default_longsummaryt_doc_default_frozen_notet_doc_default_examplet_doc_default_locscalet _doc_defaultt_doc_default_before_notesRR{Rt_doc_disc_methodsR-Rt_doc_disc_methods_err_varnameRt_doc_default_discrete_examplet_doc_default_discrete_locscalet_doc_default_disctdirRRt NameErrorRSRWRbReRgtobjectRhRRRRRRRPRRR>RQRRRR(((s@lib/python2.7/site-packages/scipy/stats/_distn_infrastructure.pyts:     .         -             &  *      2   a %  t  :/ )#S