(ph$PSSKJr SSKrSSKrSSKrSSKrSSKrSSKJ r SSK J r SSK J r Jr SSKJrJr SSKJrJr SS KJr SS KJr SS KJr SS KJr SS KJrJrJrJrJrJ r J!r!J"r"J#r#J$r$J%r%J&r&J'r'J(r(J)r)J*r*J+r+J,r, SSKr-SSK.J/r/J0r0 SSK1J2r2 SSK3J4r4 SSSS.r5Sr6Sr7Sr8Sr9Sr:Sr;SrSr?Sr@S rAS!rBS"rCS#rDS$rES%rFS&rGS'rHS(rIS)rJS*rKS+R\5S,\6\7\8\;\<\=\>\?\@\A\B\C\D\E\G\H\I\J\K/5rMS-rNS.rOS/rPS0rQS+R\N\MS1\P/5rRS+R\N\M/5rS0S2\6_S3\7_S4\8_S5\;_S6\<_S7\=_S8\>_S9\?_S:\@_S;\B_S<\C_S=\D_S>\A_S?\E_S@\K_SA\H_SB\J_\I\G\M\N\O\P\R\S\QSC. ErT\TR5rV\9\VSD'\:\VSE'\F\VS?'/SFQrW\WHrX\V\XRSGS+5\V\X'M /SHQrZ\ZHrX\V\XRSISJ5\V\X'M \VRS35 \VRS45 S+R\WVs/sHn\VUPM sn5rM\5S,\M-\VSK'\NRSLSM5\VSN'SOrO\O\VSP'SQr\SRr]\\\VSS'\]\VST'S+R\VSN\VSK/5rS\S\VSU'S+R\VSN\VSK\VSP\VSS/5r^\^\VSV'\_"5Vs/sHoRSW5(dMUPM snHrX\a"SX\X-5 M CXSxSYjrbSZrcS[rdS\reS]rfS^rgS_rhS`ri"SaSb5rj"ScSd\j5rk"SeSf\j5rlSgrmShrn"SiSj5ro"SkSl5rpSmrq"SnSL\o5rrSorsSprt"SqSM\o5ruSySrjrvSzSsjrw"StSu\u5rxSvrySwrzgs snfs snf){)getfullargspec_no_selfN) zip_longest)doccer)distcont distdiscrete)check_random_state _lazywhere)combentr)optimize) integrate) _derivative)stats)arangeputmaskonesshapendarrayzerosfloor logical_andlogsqrtplaceargmax vectorizeasarraynaninfisinfempty)_XMAX_LOGXMAX) CensoredData)FitErrorz Methods ------- z Notes ----- z Examples -------- )methodsnotesexampleszPrvs(%(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.  rvspdflogpdfcdflogcdfsflogsfppfisfrentropyfitmomentexpectintervalmeanstd) varmedian allmethods longsummary frozennoteexampledefault before_notes after_notespmflogpmf)r,rErFr/r0r1r2r3r4rr5r8r=r:r<r;r9z , scale=1)r/r0r1r2z(x, z(k, r> 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)``. rArDrCrB_doc_zdel cRUcUR5nX- U-R5$N)r:)datanmus T/var/www/html/venv/lib/python3.13/site-packages/scipy/stats/_distn_infrastructure.py_momentrPks' z YY[ YN ""cUS:XagUS:XaUc U"S/UQ76nU$UnU$US:XaUbUc U"S/UQ76nU$X!U--nU$US:XaDUbUbUc U"S/UQ76nU$U[R"US5-nUSU-U--X-U--nU$US:XaaUb UbUbUc U"S/UQ76nU$US-US --n U[R"US5-nU SU-U--S U-U-U--X-U-U--nU$U"U/UQ76nU$) Nr?r?@@)nppower) rMrNmu2g1g2 moment_funcargsvalmu3mu4s rO_moment_from_statsreqs Q q& :a'$'C0 J-C, J+ q& ;"*a'$'C& J#2+C" J! q& : a'$'C JrxxS))Cad3h,ruRx'C J q& :s{bja'$'C J c6CH%CRXXc3''Cad3h,qtBws{*258B;6C J!#d# JrQc[R"U5nUR5nX- S-R5nX- S-R5nU[R"US5- $)z0 skew is third central moment / variance**(1.5) rTrUrV)r[ravelr:r\)rLrNm2m3s rO_skewrjsZ 88D>D B 9q.   B 9q.   B S! !!rQc[R"U5nUR5nX- S-R5nX- S-R5nX2S-- S- $)zDFisher's excess kurtosis is fourth central moment / variance**2 - 3.rTrWrU)r[rgr:)rLrNrhm4s rO _kurtosisrmsR 88D>D B 9q.   B 9q.   B A:>rQc^U4SjnU$)z?Decorator that vectorizes _rvs method to work on ndarray shapesc >[USRU5up4[R"U5n[R"U5n[R"U5n[R"U5(a T "/UQUPUP76$[R "U5n[R "UR5n[R"Xd)Xd45n[R"XWU5n[R"X)6H9nT "/UV s/sHn [R"U 5UPM sn QUPUP76XX'M; [R"XVU5$s sn fNr) _check_shaperr[arrayallr"rndimhstackmoveaxisndindexsqueeze) size random_statera _rvs1_size _rvs1_indicesoutj0j1iarg_rvs1s rO_rvs(_vectorize_rvs_over_shapes.._rvss($0a$E! xx~XXj) / 66- 3$33l3 3hhtn YYsxx  YY>*B,=> ?kk#2&T.12A54@4CRZZ_Q/4@5%5'35CF3 {{3B''As#E )rrs` rO_vectorize_rvs_over_shapesrs(4 KrQc[U5(dK[U[5(a6URS5(dSU-nUS:XaSn[ [ U5nU$U$![ an[US35UeSnAff=f)Nfmin_fminz is not a valid optimizer)callable isinstancestr startswithgetattrr AttributeError ValueError) optimizeres rO_fit_determine_optimizerrs I  :i#=#=##G,, )I  I M)4I 9 M {*CDE1 L Ms A A<(A77A<c4U[R"U5:H$rK)r[round)xs rO _isintegralrs  rQc[R"U5nUR[R"U5- n[R"X5U4$)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[isfinitery count_nonzerosum)rfinite_x bad_counts rO _sum_finiters@${{1~H  0 0 ::I 66!+  ))rQc\rSrSrSr\S5r\RS5rSrSr Sr Sr SS jr S r S rSS jrSrSrSrSrSSjrSrSSjrSSjrSrSrg ) rv_frozenicX lX0lUR"S0UR5D6UlURR "U0UD6un nURR "U6uUlUlg)Nr) rakwds __class___updated_ctor_paramdist _parse_args _get_supportab)selfrrarshapes_s rO__init__rv_frozen.__init__se  NN@T%=%=%?@ yy,,d;d; 1//8rQc.URR$rK)r _random_staters rOrzrv_frozen.random_statesyy&&&rQc8[U5URlgrK)r rrrseeds rOrzrs"4T": rQcjURR"U/URQ70URD6$rK)rr/rarrrs rOr/ rv_frozen.cdf'yy}}Q88dii88rQcjURR"U/URQ70URD6$rK)rr0rarrs rOr0rv_frozen.logcdf)yy;DII;;;rQcjURR"U/URQ70URD6$rK)rr3rarrqs rOr3 rv_frozen.ppf rrQcjURR"U/URQ70URD6$rK)rr4rarrs rOr4 rv_frozen.isfrrQNcURR5nURXS.5 URR"UR 0UD6$)Nryrz)rcopyupdaterr,ra)rryrzrs rOr, rv_frozen.rvss=yy~~ T@Ayy}}dii0400rQcjURR"U/URQ70URD6$rK)rr1rarrs rOr1 rv_frozen.sfs'yy||A7 7TYY77rQcjURR"U/URQ70URD6$rK)rr2rarrs rOr2rv_frozen.logsfs'yyq:499: ::rQcURR5nURSU05 URR"UR 0UD6$Nmoments)rrrrrra)rrrs rOrrv_frozen.statss?yy~~ Y()yy 2T22rQcbURR"UR0URD6$rK)rr=rarrs rOr=rv_frozen.median!s$yy8dii88rQcbURR"UR0URD6$rK)rr:rarrs rOr:rv_frozen.mean$s"yy~~tyy6DII66rQcbURR"UR0URD6$rK)rr<rarrs rOr< rv_frozen.var'"yy}}dii549955rQcbURR"UR0URD6$rK)rr;rarrs rOr; rv_frozen.std*rrQcjURR"U/URQ70URD6$rK)rr7rar)rorders rOr7rv_frozen.moment-s)yy? ?TYY??rQcbURR"UR0URD6$rK)rr5rarrs rOr5rv_frozen.entropy0$yy  $))9tyy99rQcjURR"U/URQ70URD6$rK)rr9rar)r confidences rOr9rv_frozen.interval3s)yy!!*FtyyFDIIFFrQc $URR"UR0URD6upgn[ UR[ 5(aURR "XXrX440UD6$URR "XXxX#U40UD6$rK)rrrarrrHr8) rfunclbub conditionalrrlocscales rOr8rv_frozen.expect6s  --tyyFDIIF  dii - -99##DSbNN N99##DS$/9379 9rQcbURR"UR0URD6$rK)rsupportrarrs rOrrv_frozen.supportBrrQ)rrarrrNN)mvrK)NNNF)__name__ __module__ __qualname____firstlineno__rpropertyrzsetterr/r0r3r4r,r1r2rr=r:r<r;r7r5r9r8r__static_attributes__rrQrOrrs9'';;9<991 8;3 9766@:G 9:rQrc \rSrSrSrSrSrg)rv_discrete_frozeniFcjURR"U/URQ70URD6$rK)rrErarrks rOrErv_discrete_frozen.pmfHrrQcjURR"U/URQ70URD6$rK)rrFrarrs rOrFrv_discrete_frozen.logpmfKrrQrN)rrrrrErFrrrQrOrrF 9 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,) r) r[ atleast_1drlisttuplersbroadcast_arraysrgrryextract broadcast_to)condranewargsrss rO argsreducerXsHmmT"G gu . .* vvd||,,[TU]5 [UR5nURSL=(d% SUR ;=(d SUR ;Ul[U5Ul gr) superr_getfullargspec_statsvarkwra kwonlyargs_stats_has_momentsr r)rrsigrs rOrrv_generic.__init__se dkk*$'IIT$9$A$-$9$A$-$? 05rQcUR$)abGet 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. )rrs rOrzrv_generic.random_states!!!rQc$[U5UlgrK)r rrs rOrzrs/5rQcURRU5 UR5 g![a' USUlUSUlUR 5 gf=fNrr)__dict__r_attach_methodsr _ctor_paramrr)rstates rO __setstate__rv_generic.__setstate__sY  MM  '  "  %QxD !&qD  MMO  s+..AAc[e)zAttaches 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__ )NotImplementedErrorrs rOr!rv_generic._attach_methodss "!rQc 0n[URU5 SH&n[X[R"XU55 M( g)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)rnsnames rO_attach_argparser_methods$rv_generic._attach_argparser_methodss= T % %r*KD D 0 04 @ ALrQcUR(a[UR[5(d [S5eURR SS5R 5nUHPn[ R"U5(a [S5e[R"SU5(aMG[S5e O/nUHn[U5nURSSn U (dM&URU 5 URb [S 5eURb [S 5eUR (a [S 5eUR"cM[S 5e U(aUS nUHn X:wdM [S5e O/nU(aSR%U5S-OSn ['U UUS9n [(U -UlU(aSR%U5OSUl[-US5(d[/U5Ulgg)a`Construct 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*) shape_arg_str locscale_in locscale_outnumargs)rrr TypeErrorreplacesplitkeyword iskeyword SyntaxErrorrematchrraappendvarargsrrdefaultsjoindictparse_arg_templater.hasattrlenr=) rmeths_to_inspectr;r<rfield shapes_listmeth shapes_argsraitem shapes_strdcts rO_construct_argparserrv_generic._construct_argparsers$ ;;dkk3// :;;[[((c288:F$$U++%&JKKxx :EBB%ACC  K(-d3 "''+4&&t,#**6'IKK"((4'JLL"--'OQQ"++7'(MNN%)($Q(D~'(KLL(28TYYv&-R * , $6#; +1dii't tY''v;DL(rQc UR5nUR=(d SUS'UR=(d SUS'UcSnSRSU55nXCS 'UR=(d SUS 'UR(aUR S :Xa US ==S - ss'UR(aSURSU3US'OSUS'URcSHnX5R SS5X5'M [S5HXnURc!URR SS5Ul[R"URU5UlMZ URR SS5R SS5Ulg![a SRS U55nGN`f=f![a*n[SURS[U535UeSnAff=f)z;Construct the instance docstring with string substitutions.distnamer3r*rNrr9c3(# UHoSv M g7f)z.3gNr.0rbs rO ,rv_generic._construct_doc..>sA[cCy\[sc3&# UHov M g7frKrr[s rOr]r^@s=#uXsvalsshapes_rr7z>>> z = set_vals_stmt)rBrCz- %(shapes)s : array_like shape parametersrTz %(shapes)s, z0Unable to construct docstring for distribution "z": z(, (z, ))) rr3rrIr>r=r?range__doc__r docformat Exceptionrepr)rdocdict shapes_valstempdictr`rSrrs rO_construct_docrv_generic._construct_doc5s<<>992 ![[.B  K >99A[AAD "kk/R ;;4<<1, Y 3 &  ;;*.t{{m3tf(EH_ %(*H_ % ;; 3!)!7!7Er"K4qA{{"#||33NBG  S%// hG ||++E37??sK ; >99===D >0 S!226))Da !KLQRS Ss*F>&G"G?G G7 %G22G7c~UcSnSRUSUS3S[SS/5UlURU5 g) z7Construct instance docstring from the default template.NAr*r8z random variable.z %(before_notes)s r(z %(example)s)rI docheadersrfrm)rlongnamerjdiscretes rO_construct_default_doc!rv_generic._construct_default_doc^sQ  Hww8*AhZ7H I 8*W:M / 12  G$rQch[U[5(a[U/UQ70UD6$[U/UQ70UD6$)a@Freeze 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. )rrGrrrrars rOfreezerv_generic.freezehs; dM * *'.squeeze_leftsD&&1*qaD&&1*qHrQr)rrz;size does not match the broadcast shape of the parameters. r9) getr[r rrtrrrMrszipr)rrakwargsry all_bcastrr bcast_shape bcast_ndimsize_ndiffbcdimszdimok param_bcast loc_bcast scale_bcasts rO _argcheck_rvsrv_generic._argcheck_rvss_zz&$'''.   /88i\!_i 8l(( q\&& <E"---.ESZ' 19-+5K QYJ&E (+K(?A(?nu1*..(?AB004vRwb OP P n bM m {E99O9:As DD cLSnUHn[U[U5S:5nM U$)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)rrar rs rO _argcheckrv_generic._argchecks-CtgclQ&68D rQc2URUR4$)auReturn 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. rr)rrars rOrrv_generic._get_supports(vvtvv~rQcUR"U6up4[R"SS9 X1:*X:*-sSSS5 $!,(df  g=fNrinvalidrr[rrrrarrs rO _support_maskrv_generic._support_masks8  $' [[ *Fqv&+ * * 9 AcUR"U6up4[R"SS9 X1:X:-sSSS5 $!,(df  g=frrrs rO_open_support_maskrv_generic._open_support_masks8  $' [[ *Eae$+ * *rrcJURUS9nUR"U/UQ76nU$)Nry)uniform_ppf)rryrzraUYs rOrrv_generic._rvss/  d + IIa $ rQc[R"SS9 [UR"U/UQ765sSSS5 $!,(df  g=fNrdivide)r[rr_cdfrrras rO_logcdfrv_generic._logcdf0 [[ )tyy*T*+* ) ) ; A c.SUR"U/UQ76- $NrSrrs rO_sfrv_generic._sfs499Q&&&&rQc[R"SS9 [UR"U/UQ765sSSS5 $!,(df  g=fr)r[rrrrs rO_logsfrv_generic._logsfs0 [[ )txx)D)** ) )rc(UR"U/UQ76$rK)_ppfvecrrras rOrrv_generic._ppf||A%%%rQc.UR"SU- /UQ76$r)rrs rO_isfrv_generic._isfsyyQ&&&rQcURSS5nURSS5nUR"U0UD6uppg[UR"U6US:5n[R "U5(dSUR S3n [U 5e[R "US:H5(aU[US5-$UbURn [U5n O URn UR"XU S.6n X-U-n UbW Ul U(aG[U[5(d2US :Xa [U 5n U $U R[R 5n U $) aRandom 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`. rsNrzrzDomain 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.drr)popr,rrr[rsr3rrrr rr rv_sampleintastypeint64) rrarrsrndmrrryr messagerandom_state_savedrzr`s rOr,rv_generic.rvs#sH<88J-xx-!%!5!5t!Dt!D54>>405A:?vvd||67;ii[A44G W% % 66%1*  tD#& &  !%!3!3 -d3L--Lyy$ E|c!  !3D  JtY77rz4y {{288, rQc UR"U0UD6uppE[[X445up4[[[U55nUR"U6US:-X3:H-n/n[ R "[U5URS9n[ R"U5(Ga[U/XU4-Q76n U SU SU SSpnUR(aUR"U 0SU0D6uppOUR"U 6uppSU;aHU cUR"S/U Q76n UR5n[XX-U-5 UR!U5 S U;aU cUR"S /U Q76nU cUR"S/U Q76n [ R""S S 9 [ R$"[ R&"U 5)XS -- [ R(5n SSS5 UR5n[XX-U-5 UR!U5 S U;aU cUR"S/U Q76nU cUR"S/U Q76n U c7UR"S /U Q76n[ R""S S 9 XU -- n SSS5 [ R""S S 9 U *U -SU -- U -U-nU[ R*"U S5- n SSS5 UR5n[XU 5 UR!U5 SU;Ga<U Gc UR"S/U Q76nU cUR"S/U Q76n U c7UR"S /U Q76n[ R""S S 9 XU -- n SSS5 U cSnOU [ R*"U S5-nUcBUR"S/U Q76n[ R""S S 9 U *U -SU -- U -U-nSSS5 [ R""S S 9 U S -*SU -- U -SU-- U -U-nUU S-- S- n SSS5 UR5n[XU 5 UR!U5 O UVs/sHnUR5PM nnUVs/sHnUSPM nn[-U5S:XaUS$[U5$!,(df  GN=f!,(df  GN/=f!,(df  GN=f!,(df  GNo=f!,(df  GN=f!,(df  N=fs snfs snf)ahSome 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_valuerrNrmrvrTrrrrUrVrrWrZrYrXr)r+maprrrr[fullrbadvalueanyrrrrrrrFrwherer!r r\rM)rrarrrrr outputrBgoodargsrNr]r^r_out0mu2pmu3prcmu4prdrr}s rOrrv_generic.statshsy4%)$:$:D$ID$I!53,/ S$'(~~t$ 2cjA''%+$--@ 66$<<!$=$s|*;=H#+B<"x}E&&"&++x#F1:G0D#FR#'++x"8g~:A11B||~d"*s"23 d#g~;::a3(3Dz!ZZ5H5X6 hh }dUlBFFK7||~d#+"56 d#g~:::a3(3Dz!ZZ5H5{#zz!7h7[[:"&b.C;X6 "s2v#~r1D8 288C#557||~d"% d#g~:::a3(3Dz!ZZ5H5{#zz!7h7[[:"&b.C;z"!288C#55{#zz!7h7[[:$&38a#g#5";d"BC;X6!#Q3"4qu>> 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 rrrNr) rrrrrrrrrr vecentropyr) rrarrrcond0rr goodscales rOr5rv_generic.entropys0 ++T:T:53,/ S$'(%3szBuU|S) fqw/e2T2QK AB< fT__h7#i.HIbzrQc UnUR"U0UD6upVn[R"/UQUPUP76nUGtpVn[R"UR"U6US:5n[R"XS:H5n [R"XS:g5n [ U/UQUPUP76nUGtpVn[ U5U:wa [S5eUS:a [S5eSuppUS:a;US:a5UR(a SSSS S S .U0nO0nUR"U0UD6upp[R"UR5n[XKXXRU5US '[UR5n[UU)UR 5 U R#5(a XvS:HU-UUS:H-n[UU U5 U R#5(GaXX/nUVs/sH nUcMUPM nn[%S 5Vs/sH nUUcM UPM nn[#U5(a'[ US:g/UQ76nSnUHnUUUU'US- nM Uupp[ US:g/UQUPUPUP76nUGtpVnn[URSS9nXv- n[%U5H3n[UXXURU5nU['UUSS9UU--U-- nM5 UUU-U-- nUXd--n[UU U5 US$s snfs snf)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.r~rrrvsmvsk)rrTrUrW.rWrrdtypeT)exactr)rr[r rrrrrrrr"rrerrrrrrer )rrrarrMrrri0i1i2rNr]r^r_mdictrbresultres1momrarrsidxjres2facrvalks rOr7rv_generic.moments  !--t[R"USS9upUR(aTR"U/UQ76O/nUR(a SUS- S::d5[R"S/US/45n[R"US/45nO[R"S/U45nU[R "[R "U5U- 5-$)NT) return_countsrrr)r[uniqueryr concatenaterdiff)rraljcdf_datar/rs rOlog_psf,rv_generic._penalized_nlpsf..log_psf7sIIat4EA./fftyy*T*"HFFq8B</14nnqc8aS%9:^^R!I.nnqc8_5rwws|b011 1rQ)rrr r[sortr2)rr"rrrrar?s` rO_penalized_nlpsfrv_generic._penalized_nlpsf,sb  11%8D~~t$ J WWQZ# u $ 2%%aw77rQ)rfr"r.rrr=rrK)NN continuous)/rrrrrfrrrzrr$r!r4rVrmrtrxr{rrrrrrrrrrrrrr,rr5r7r=r:r<r;r9rr$r r2r5rBr __classcell__rs@rOrrs  6 " "66 " BO'b'LR/36B%;(*~~H &  E:T ,' % $$ ,'+&' CJo!b#JKZ,422.,\!F2 7 & K88rQrcR\rSrSrS\R *\R 4S4SjrSrg) _ShapeInfoiFF)TTcXlX lX0lX@l[ U5n[ R "US5(a5US(d+[ R"US[ R5US'[ R "US5(a6US(d,[ R"US[ R*5US'X0l gr) r3 integrality endpoints inclusiverr[r nextafterr domain)rr3rJrNrLs rOr_ShapeInfo.__init__Gs &"f ;;vay ! !)A, VAY7F1I ;;vay ! !)A, VAY8F1I rQ)rNrKrLrJr3N)rrrrr[r rrrrQrOrHrHFs).7H' rQrHcUVs/sHo"U;dM X RU54PM nn[U5S:a3UVVs/sHup$UPM nnn[SSRU5-5eU(aUSS$S$s snfs snnf)a Given names such as ``['f0', 'fa', 'fix_a']``, check that there is at most one non-None value in `kwds` associated 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. rzOfit method got multiple keyword arguments to specify the same fixed parameter: r9rN)rrMrrI)rnamesr3r`rbrepeateds rO_get_fixed_fit_valuerSVs05 Eut "T88D> "uD E 4y1}*./$YTD$/>8,-. .471:'4' F/s A=A=Bc.^\rSrSrSrS-U4SjjrSrSrSrSr S r S r S r S r S rSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSr S.S jr!S.S!jr"S"r#S#r$S$r%S%r&S&r'S/S(jr(S)r)S'SS*.S+jr*S,r+U=r,$)0rGiparA 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``. rc >[T U]U 5 [XX4XVUXS9 UlUc[nUcSnXPlX`lX lX0lUc [*UlUc [UlX@l Xl Xl URURUR/SSS9 UR!5 UcUSS;aSn OS n X-n["R$R&S :abUR(cUR+U[,S S 9 g[[.5n UR1[,U R3UR 55 gg) N) momtyperrxtolrr3rrrr Distributionzloc=0, scale=1z loc, scalerNr;r<r aeiouAEIOUAn A rTrDrrrjrs)rrrJr"rrr3rrr rW moment_typerrV_pdfrr!sysflagsr rfrtrjrrmr) rrVrrrWrr3rrrrhstrrUrs rOrrv_continuous.__init__6sA  A8&  H <!D   9TDF 9DF "  !!DIItyy3I.>/; " =   Aw.({H 99   !||#++X4;5A,C8n##GSWWTYY-?@ "rQcURR5n/SQnUVs/sHo1RUS5PM nU$s snf)N)rr+r,_cdfvecrrrr rrrrUattrsattrs rO __getstate__rv_continuous.__getstate__hsAmm  "G)./t /  0AcUR5 [URSS9UlURS-URl[UR SS9Ul[URSS9Ul URS-URlURS:Xa[URSS9Ul O[URSS9Ul URS-URlg)zE Attaches dynamically created methods to the rv_continuous instance. rotypesrrN)r4r _ppf_singlerr=nin_entropyr _cdf_singlerfr__mom0_scr_mom1_scrs rOr!rv_continuous._attach_methodsrs &&(!!1!1#> < !1!1#> <>w&D$$T4t4r9"mTe$$T4t4r9 88E??%E$$U55:#V^e$$U55:t11#!dL LrQc2X-UR"U/UQ76-$rKr-)rrrras rO _mom_integ0rv_continuous._mom_integ0stdhhq(4(((rQcrUR"U6up4[R"URX4U4U-S9S$Nrar)rrquadr)rrrarrs rOrurv_continuous._mom0_scs@""D)~~d..$%49../1 1rQc.UR"U/UQ76U-$rKr)rrrras rO _mom_integ1rv_continuous._mom_integ1s"T"Q&&rQcR[R"URSSU4U-S9S$)Nrrr)rrr)rrras rOrvrv_continuous._mom1_scs(~~d..1A49EaHHrQc0[URUSUSS9$)Ngh㈵>r)dxrar)rrrs rOr`rv_continuous._pdfs499aDt1EErQcUR"U/UQ76n[R"SS9 [U5sSSS5 $!,(df  g=fr)r`r[rr)rrraps rO_logpdfrv_continuous._logpdfs4 IIa $  [[ )q6* ) )s = A c(UR"U/UQ76$rK)rrs rOr)rv_continuous._logpxf||A%%%rQcjUR"U6up4[R"URX1US9S$r)rrrr`)rrrarrs rOrtrv_continuous._cdf_singles0""D)~~diiT:1==rQc(UR"U/UQ76$rK)rfrs rOrrv_continuous._cdfrrQc^TR"S/UQ76n[R"SS9 [X:U4U-U4SjU4SjS9sSSS5 $!,(df  g=f)NrrrcR>[R"TR"U/UQ765$rK)r[rrrrars rO'rv_continuous._logcdf..s !8Kd8K1LrQcT>[R"TR"U/UQ76*5$rK)r[log1prrs rOrrs"((DHHQ[R"TR"U/UQ765$rK)r[rrrs rOr&rv_continuous._logsf..s8JT8J1KrQcT>[R"TR"U/UQ76*5$rK)r[rrrs rOrrs"((DIIa1$t)UH*<>H&rlHSbM8 & 8 4u < = ;;! ":  rQcUR"U0UD6up$n[[XU45upn[[[U55n[R "UR [R5n[R"X- U- US9nUR"U6US:-nUR"U/UQ76US:-nXx-n [[U 5U5n U R[*5 [U SU- [R"U5-UR 5 [R""U 5(aB[%U /U4U-U4-Q76n U SU SSp['XUR("U 6[+U5- 5 U R,S:XaU S$U $)a!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 rrrrNr)rrrrr[rrrrrr"rfillr rrrrrrrrrtrs rOr.rv_continuous.logpdf s_. ++T:T:5Gae_5 S$'(4 JJd 3%3""1,t, :}uT{D) SD5"((1+-t}}= 66$<<!$>1$t)UH*<>H&rlHSbM8 & h 7#e* D E ;;! ":  rQc2UR"U0UD6up$n[[XU45upn[[[U55nUR"U6upg[ R "UR[ R5n[ R"X- U- US9nUR"U6US:-n UR"U/UQ76US:-n U[ R"U5:U -n X-n [[U 5U5n [U SU - [ R"U5-UR5 [XS5 [ R "U 5(a)[#U /U4U-Q76n[XUR$"U65 U R&S:XaU S$U $)a 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` rrrrSr)rrrrrr[rrrrrrrrrrrrrrtrrrarrrrrrrrcond2r rrs rOr/rv_continuous.cdf6sc, ++T:T:5Gae_5 S$'(""D)4 JJd 3%3''1D1UQY?bjjn$-}uT{D) fqw +T]]; fS! 66$<<!$51$t)5H & 8 4 5 ;;! ":  rQc>UR"U0UD6up$n[[XU45upn[[[U55nUR"U6upg[ R "UR[ R5n[ R"X- U- US9nUR"U6US:-n UR"U/UQ76US:-n X:U -n X-n [[U 5U5n U R[*5 [U SU - X:H-[ R "U5-UR"5 [XS5 [ R$"U 5(a)['U /U4U-Q76n[XUR("U65 U R*S:XaU S$U $)aLog 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 rrrrr)rrrrrr[rrrrrr"rrr rrrrrrrtrs rOr0rv_continuous.logcdf`sm* ++T:T:5Gae_5 S$'(""D)4 JJd 3%3''1D1UQY?E!}uT{D) SD fqw0!? fZ;A>? 66$<<!$B1$t)UL*@BH#+B<"x}3 & 8 4u TRXT5$rK) _moment_error)r"r data_momentsrs rO objective-rv_continuous._reduce_func..objective s))%LAArQzMethod 'z ' not available; must be one of rz3All parameters fixed. There is nothing to optimize.cV>Sn[T5HnUT;dM XX'US- nM U$r)re)rar"rrMNargsfixedns rOrestore+rv_continuous._reduce_func..restore s8uA"'(Q& rQc,>T"TSSU5nT"X!5$rKr)r"rnewthetararrs rOr(rv_continuous._reduce_func..func s"47E2 --rQ)rr?r@ enumeraterrSrrMrerFrlowerr[rnewaxisrr5r)rrarrLrrrkeyrQrbrMx0r'rn_params exponentsrrrrrrs`` @@@@@rO _reduce_funcrv_continuous._reduce_func s! ;;[[((c288:F!&)CFlcAgvz2*47? #I *DzD $)%!)$45$4q$458JJ &FA{ a ((3-Q $q'" '$-(E*002 T>6{QV4H1hqj11bjj=AI66$tQw-":3t9"D1ML Bu_,,Ixx0//6i9: : v;! DG6{e# IKK  .4$&&a6s.H(c  URU5upEnUR"U6(aUS::a[$[R"[ [ U55Vs/sHnUR"US-/UQ7XES.6PM sn5n[R"[R"U55(a [S5eX8- [R"[R"U5S5- S-R5$s snf)NrrrrzqMethod of moments encountered a non-finite distribution moment and cannot continue. Consider trying method='MLE'.:0yE>rT)rrr r[rrrerMr7rrrmaximumabsr) rr"rrrrrar dist_momentss rOrrv_continuous._moment_error s11%8D~~t$ Jxx*/L0A*B!D*BQ"&QqS!N4!NS!N*B!DE 66"((<( ) )=> >-BFF<0$78:;<=@SU C!Ds#DcURSS5R5n[U[5nU(a3US:wa [ S5eUR 5S:XaUR nSn[U5nX`R:a [S5eU(dX[R"U5R5n[R"U5R5(d [ S5eS/S -nX`R:d S U;aS U;dURU5nX'US - nUR!S US 5nUR!S US 5n X(U 4- nUR#X#US9uppUR!S[$R&5n [)U 5n U(a[SUS35eU "XU4SS9nU "X5nU bU "X.5n[+U5nUR-U5upn[R"UR."U65(aU S:d [1S5eUS:Xa&[R"U5(d [1S5eU$)ad 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.NrTrrrr)rLrzUnknown arguments: .)radispz\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.)rrrr%rrrrMr=r>r[rrgrrsrrr r rrrrrr&)rrLrarrcensoredNargstartrrr rrrr`objrs rOr6rv_continuous.fit s8\(E*002dL1  ".//  "a''' 4y ,, 78 8 ::d#))+D;;t$((** !GHHq << $)0DNN4(E $rN "DhhueBi(%), e "&"3"3DT"3"J'HH[(--8 ,Y7 1$q9: : a84  4&DT{!33D9Ft~~v.//EAILM M T>;;s## -.. rQcx[U[5(aUR5nO[R"U5nUR "U/UQ76up4UR "U6 UR"U6upVXVpX- n U S::aX44$X7U--n X8U--n [R"U5n [R"U5n X:aX:aX44$X- nSnX-nU [R:aX- U- nUSU--U - nX44$U[R*:a X- U- S4$U[R:a X- U-S4$[e)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?rTr) rr% _uncensorr[r fit_loc_scalerrrrr RuntimeError)rrLraloc_hat scale_hatrrrr support_widtha_hatb_hatdata_adata_b data_width rel_marginmargins rOr$rv_continuous._fit_loc_scale_support s^& dL ) )>>#D::d#D"//fn% %_  ( 266 !zV+G#a&j0MAI% % w;J&(!+ + ZJ&(!+ + rQcUR"U0SS0D6up4[U5nUR5nUR5n[ Xt- 5n[ R "SS9 XhU-- n SSS5 [ R"W 5(dSn [ R"U5(aSU:dSnX4$!,(df  NQ=f)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)rrr:r<rr[rr) rrLrarNr]tmpmuhatmu2hatShatLhats rOr rv_continuous.fit_loc_scale s(**d8y$&78dm FL! [[ *7?D+{{4  D D!!q4xDz + *s #B66 Cc^^UU4SjnTR"T6up4[R"SS9 [R"X#U5SnSSS5 [R "W5(dU$TR "SS//TQ76upg[R"U5(aUnOUn[R"U5(aUn OUn [R"X)U5S$!,(df  N=f)Nc@>TR"U/TQ76n[U5$rK)r`r )rrbrars rOinteg%rv_continuous._entropy..integ1 s ))A%%C9 rQr)overr绽|=gA?)rr[rrrrr3r!) rrar6rrhlowuppupperrs `` rOrsrv_continuous._entropy0 s  ""D) [[h 'u"-a0A(xx{{Hxx 3;d;HCxx||xx||>>%6q9 9!( 's C  C.rc r^^^UUS.mTR"U6 TR"U6upTcUU4Sjn OUUU4Sjn UcX9U--nUcX:U--nTR"XV//UQ70TD6n U SU S- n X(S'Sn[R"USU- /5nU SX--nUTR "U/UQ76U--unn[ R"XU40UD6Sn[ R"U UU40UD6Sn[ R"U UU40UD6SnUU-U-nU(aUU -n[R"U5S$) aY Calculate 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 rc6>UTR"U/UQ70TD6-$rKr)rralockwdsrs rOfun!rv_continuous.expect..fun s!488A88888rQcB>T"U5TR"U/UQ70TD6-$rKr)rrarrArs rOrBrC s%Aw!!>d!>g!>>>rQrrrag?r)rrr/r[rrrrr)rrrarrrrrrrrrB cdf_boundsinvfacr inner_boundscdf_inner_boundscrlbccddubr`rAs`` @rOr8rv_continuous.expectI sgF!# ""D) < 9 ? :Ez!B :Ez!BXXrh999 AA.V xx% 01 %a=6+@@TYY/7$7%??1nnSa0403 ^^CA . .q 1nnS!R0403b3  FNDxx~b!!rQcUR5n[SS[R*[R4S5n[SSS[R4S5nXU/-nU$)NrFFFrr _shape_inforHr[r )r shape_infoloc_info scale_info param_infos rO _param_inforv_continuous._param_info sZ%%' eUbffWbff,=~NBFF ^L Z"88 rQrc UR"U/UQ7X4S.6n[R"US:UR"U/UQ7X4S.6UR"U/UQ7X4S.6- UR"U/UQ7X4S.6U- 5nURS:XaUSnU$)a 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, ...)`. rrrr)r/r[rr1rt)rx1x2rrracdf1rs rOrrv_continuous._delta_cdf sxx8T8s8 $*772CC#C!WWRE$ECEF((2CC#CdJL ;;! BZF rQ) rfr"rrrrrr_r3rrrW) rNNg+=NNNNNrK)NrrrNNF)-rrrrrfrrkr!rr}rqrrurrvr`rr)rtrrrr-r.r/r0r1r2r3r4rrr5rr rr6rr rsr8rVrrrErFs@rOrGrGpsCJ8=48#'0Ad3, 'L*)1 'IF & >&QR%N(T(T(T'R+Z+Z+Z "/H=$#F'P CobENB:2FJ E"N-.QrQc ^^^UUU4SjnTR"T6upE[X4UTR"S/TQ76TR5$)z,Non-central moment of discrete distribution.cZ>[R"UT5TR"U/TQ76-$rK)r[r\_pmf)rrarMrs rOrB_drv2_moment..fun s&xx1~ ! 3d 333rQr)r_expectrinc)rrMrarBrrs``` rO _drv2_momentrc s?4   %FB 3B # 5 5txx @@rQcpUR"U6up4UnUnSn[U5(aF[[SU-S55nXT:aSnO'UR"U/UQ76nX:a XW- nUS-nOOM-SnSn[U5(aF[[ SU-S55nXc::aSnO8UR"U/UQ76n X:a Xg-nUS-nOOM-UR"U/UQ76n [ R"U5(d[ R"U5(a S n [U 5eS n [U 5Hn W U:XaUs $X:XaUs $XVS-::a X:aUs $Us $[Xe-S - 5n UR"U /UQ76nX:aXm:waU nO [S 5eUn MjX:aX]:waU nO [S 5eUnMU s $ g) N r,rrSrTiirzAArguments that bracket the requested quantile could not be found.irYzupdating stopped, endless loop) rr!floatrrrr[r!rer)rrrarrrrstepqbqarmaxiterrrIqcs rO_drv2_ppfsinglerl s    %FB A A D Qxx #c!eR. !w1$t$B   D Qxx #d1fc" #w1$t$B  YYq 4  xx{{bhhqkkU7##G 7^ !GH GH !8v c N YYq 4  Fv"#CDDBfv"#CDDBH3rQc ^\rSrSrSrS\SSSSSSSS4 U4SjjrS\SSSSSSSS4 U4SjjrS rS r S r S r S r Sr SrSrSrSrSrU4SjrSrSrSrSrSrSrSrSrSrS!SjrSrS rU=r $)"rHiF aA 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 N>Ub[T U][5$[T U]U5$rK)r__new__r) clsrrr3r moment_tolvaluesrbrrrrrs rOrorv_discrete.__new__ s+  7?9- -7?3' 'rQc P>[T U]U 5 [XX4XVUXU S9 UlUc[nX@lXlX lXPlXpl Xl Ub [S5eURURUR/SSS9 UR5 UR!X85 g)N rrr3rrqrrrbrrrrz.rv_discrete.__init__(..., values != None, ...)loc=0loc, 1rY)rrrJr"rrrrrqrbrrrVr_rr!_construct_docstrings) rrrr3rrqrrrbrrrrrs rOrrv_discrete.__init__ s  4!c49  H $  MN N !!DIItyy3I.5/7 " 9  ""42rQcURR5n/SQnUVs/sHo1RUS5PM nU$s snf)N)rr+r,rfrrrgrhs rOrkrv_discrete.__getstate__ s@mm  "9)./t /  0rmc[URSS9Ul[UR5UlUR 5 [[ SS9nURS-Ul[R"X5Ul [[SS9nURS-Ul[R"X 5Ul URS-URlg)zAAttaches dynamically created methods to the rv_discrete instance.rrorTrN)rrtrfrsrr4rcr=rrr0r1rrlr)r_vec_generic_moment_vppfs rOr!rv_discrete._attach_methods s !1!1#> #DMM2 &&(( SA"&,,"2#../BI/#6LL1$ ''4  <[[5nUR[ URUR55 URRS S 5Ulgg) NrXrrZr\r]rTrsr^zE scale : array_like, optional scale parameter (default=1)r*) r3rarbr rfrtdocdict_discreterJrrmrr?)rr3rrrcrUs rOrx!rv_discrete._construct_docstrings s <!D   Aw.({H 99   !||#++X4D5?,A<(##$4cggdii6HI <<//@ACEDL "rQc URR5nURUS'URUS'URUS'UR US'UR US'URUS'URUS'U$)ryrrrrqrbr3r) r"rrrrrqrbr3rrzs rOrrv_discrete._updated_ctor_param5 sy ##%66C66C--J OOLXXE iiF  H  rQc[U5U:H$rK)rrrras rO_nonzerorv_discrete._nonzeroE sQx1}rQcVUR"U/UQ76UR"US- /UQ76- $)Nrrrs rOr_rv_discrete._pmfH s-yy"T"TYYqs%:T%:::rQc[R"SS9 [UR"U/UQ765sSSS5 $!,(df  g=fr)r[rrr_rs rO_logpmfrv_discrete._logpmfK rrc(UR"U/UQ76$rK)rrs rOr)rv_discrete._logpxfO rrQcrUSnSn[USS5nX#U4$![an[S5UeSnAff=f)Nrrrrrs rOrrv_discrete._unpack_loc_scaleU sU C)CEs$D4 C:; B Cs 6 16cUR"U6up4[[U5US-5n[R"UR "U/UQ76SS9$)Nrrr')rrrr[rr_)rrrarrrs rOrtrv_discrete._cdf_single^ sG""D) 3r7AaC vvdii)D)22rQcx[U5R[R5nUR"U/UQ76$rK)rrr[rrf)rrrars rOrrv_discrete._cdfc s, !HOOBJJ '||A%%%rQc.>SUS'[TU]"U0UD6$)aRandom 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`. Trs)rr,)rrarrs rOr,rv_discrete.rvsi s#:"zw{D+F++rQc UR"U0UD6up$n[[X45up[[[U55nUR"U6upg[X- 5nUR "U6nX:X:*-n [ U[5(dXR"U/UQ76-n X-n [[U 5S5n [U SU- [R"U5-UR5 [R"U 5(a?[!U /U4U-Q76n [X[R""UR$"U 6SS55 U R&S:XaU S$U $)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 rrrr)rrrrrrrrrrrrr[rrrrclipr_rt rrrarrrrrrrr rrs rOrErv_discrete.pmf s/&''66 1Wqh'S$'(""D) AEN%QW%$ **MM!3d33E}uT{C( fqw"((1+-t}}= 66$<<!$51$t)5H & 8([TR"U/TQ765$rK)r r_rs rOr&rv_discrete._entropy..sT$))A*=*=%>rQr)rLrr5rrrarrb)rrarrs`` rOrsrv_discrete._entropys` 4  ==) )&&-FB>499S#84#8$((D DrQc ^^^^TR"T6um n Tc UUU4Sjn O UUUU4Sjn TR"T6upUcU nOUT- nUcU nOUT- nU(a+TR"US- /TQ76TR"U/TQ76- nOSn[T[5(aTR XU5nX- $TR "S/TQ76n[ XUUTRXxU 5nX- $)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. c6>UT-TR"U/TQ76-$rKr_)rrarrs rOrBrv_discrete.expect..funs #tyy2T222rQcB>T"UT-5TR"U/TQ76-$rKr)rrarrrs rOrBrs$AcE{499Q#6#666rQrrSr)rrr1rrrarrb)rrrarrrrmaxcount tolerance chunksizerrBrrrFr r s```` rOr8rv_discrete.expectsp%%t, a < 3 3 7 7""D) :BcB :BcB WWRT)D)DGGB,>,>>FF dI & &,,s+C< YYs "T "cr2txxiP|rQcUR5n[SS[R*[R4S5nX/-nU$)NrTrOrP)rrRrSrUs rOrVrv_discrete._param_info5s?%%' eTRVVGRVV+,,E8 ;,&  3 & ,@$L%N(T&P$L(T&P.`D=ALN[zrQcX!- U::a8[R"XS-U5nU"U5n [R"U 5$X1:aUnX2:aUnSup[X2S-XtS9Hqn XR- n [R"U"U 55n X- n [ U 5XlR-:a O'X:dMU[ R"S[SS9 U s $ [US- US- Xt*S9Hqn XR- n [R"U"U 55n X- n [ U 5XlR-:a U $X:dMV[ R"S[SS9 U $ U $)z4Helper for computing the expectation value of `fun`.r)rr)rrbzexpect(): sum did not convergerU) stacklevel) r[rr _iter_chunkedryrwarningswarnRuntimeWarning)rBrrr rbrrrsuppr`counttotrdeltas rOrara<sO IyyT3'4yvvd| w  w JE 2!ty B s1v  u: FF* *    MM:(Q 8JC2a4A E s1v  u: FF* *  J   MM:(Q 8  JF JrQc#^# US:Xa [S5eUS::a[SUS35eUS:aSOSn[X#-5n[R"U5nXa- U-S:aK[ U[Xa- 55nXt-n[R "XfU-U5n Xh- nU v Xa- U-S:aMJgg7f)abIterate 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 rrrN)rrr[rrr) r rYrrbrstepsizerrrgrs rOrrgs& ax455A~[[U] U 5 Uc [S5e[ XX4XVUXU S9 UlUc[ nX@lXPlXpl Xl URUl Uup[R"U 5[R"U 5:wa [S5e[R"U S5R!5(a [S5e[R""[R$"U 5S5(d [S5e['[)[R*"U 555[R,"U 5:Xd [S5e[R."[R*"U 55n [R0"[R*"U 5U S 5Ul[R0"[R*"U 5U S 5UlUR2S UlUR2S Ul[R:"UR4S S 9UlS Ul UR?UR@/S SS9 URC5 UREX85 g)Nz(rv_sample.__init__(..., values=None,...)ruz#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'r8rvrwrY)#rrHrrrJr"rrrqrbrrsrr[rlessrallcloserrMsetrgryargsorttakexkrrrcumsumqvalsrVr_r!rx)rrrr3rrqrrrbrrrrrrindxrs rOrrv_sample.__init__s k4)$/ >GH H 4!c49  H $ -- 88B<288B< 'BC C 772s    ! !GH H{{266":q))?@ @3rxx|$%4CD Dzz"((2,'''"((2,a0''"((2,a0YYtwwQ/   !!DII;.5/7 " 9  ""42rQcURR5n/SQnUVs/sHo1RUS5PM nU$s snf)Nr*rgrhs rOrkrv_sample.__getstate__sAmm  "H)./t /  0rmc$UR5 g)z/Attaches dynamically created argparser methods.N)r4rs rOr!rv_sample._attach_methodss &&(rQc2URUR4$)aNReturn 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)rras rOrrv_sample._get_supportsvvtvv~rQc [R"URVs/sHo!U:HPM snURVs/sHn[R"X15SPM snS5$s snfs snfrp)r[selectrrr )rrrrs rOr_rv_sample._pmfsZyy$''2'Qq&'2@DH1"--a3A6H!M M2Hs A(#A- c[R"USS2S4UR5up#[R"X2:SS9S- nURU$)Nrr'r)r[r rrr)rrxxxxkrs rOrrv_sample._cdfsH%%a4j$'':yy+a/zz$rQc[R"USUR5up#[X2:SS9nURU$)N).Nrr')r[r rrr)rrqqsqqrs rOrrv_sample._ppfs:%%a lDJJ?cib)wwt}rQcURUS9nUc+[R"USS9nURU5SnU$URU5nU$)Nrr)ndminr)rr[rrr)rryrzrrs rOrrv_sample._rvssX  d + <!$A ! QA ! ArQcB[R"UR5$rK)rr5rrs rOrsrv_sample._entropys}}TWW%%rQc[U5n[R"URU[RS4-UR -SS9$)N.rr')rr[rrrr)rrMs rOrrv_sample.generic_moments; AJvvdggqS11DGG;!DDrQcURX R:*URU:*-nU"U5n[R"U5$rK)rr[r)rrBrrrarrr`s rOrarv_sample._expects:wwgg $''R-894yvvd|rQ) r"rrrrbrqrrrrrr)rrrrrfr rrkr!rr_rrrrsrrarrErFs@rOrrs` ct 1t433j) M  &ErQrc /n/n[USSS2USSS2SS9HNupEXT:dXEs=:XaS:Xa'O O$URU5 URS5 M=URS5 MP [USSS25[USSS254$)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)rrFr)argshapery scalar_shapebcargdimsizedims rOrqrq s4L B&x"~tDbDz124   6Q 6    ( IIdO IIe  4 dd# $eBttHo 55rQc /n/nUHwupEURS5(aMURS5(a![XQ5(aURU5 [ XQ5(dMfURU5 My X#4$)a;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. r_gen)rendswith issubclassrFr)namespace_pairs rv_base_class distn_namesdistn_gen_namesr3values rOget_distribution_namesr1sw(KO&  ??3    == Z%E%E  " "4 ( e + +   t $ '  ''rQrK)rr9r)rWr){scipy._lib._utilrrrarArDr0r itertoolsr scipy._libr _distr_paramsrrr r scipy.specialr r scipyr rscipy._lib._finite_differencesrrnumpyrrrrrrrrrrrrrrrr r!r"r[ _constantsr#r$_censored_datar%scipy.stats._warnings_errorsr&rq_doc_rvs_doc_pdf _doc_logpdf_doc_pmf _doc_logpmf_doc_cdf _doc_logcdf_doc_sf _doc_logsf_doc_ppf_doc_isf _doc_moment _doc_stats _doc_entropy_doc_fit _doc_expect_doc_expect_discrete _doc_median _doc_mean_doc_var_doc_std _doc_intervalrI_doc_allmethods_doc_default_longsummary_doc_default_frozen_note_doc_default_example_doc_default_locscale _doc_default_doc_default_before_notesrjrr_doc_disc_methodsrr?_doc_disc_methods_err_varnamer_doc_default_discrete_example_doc_default_discrete_locscale_doc_default_discdirrr-rPrerjrmrrrrrrrrrKrrHrSrGrcrlrHrarrrqr)rrs00rOr0ss G  !1;$ 7+++++'(1 4-68                        '':i0(H&+w%x;%|X& $h- IJ .`ww0',./ GG%=%4%67  8  8  k  8    k    '   Z  8  8  Z |  8  k  k     I! " 8# $ !+*#-(5 ><<>"(17 C,S199+rJS !A (C,S199&&IS )UX''