(phSSKrSSKrSSKrSSKrSSKJr SSKJ r J r J r J r J r JrJrJr SSKJr SSKJrJr SSKJrJr SSKJrJr SS KJr SS KJrJrJ r SS K!J"r" SS K#J$r$ SS K%J&r& /SQr'\RP"S\RR-5r*\RP"S5r+\RP"\RR5r,\RZ"5r.Sr/Sr0SSjr1SSjr2"SS5r3"SS5r4"SS5r5Sr6Sr7Sr8Sr9\6\7\/S.r:\8\9\/S.r;"SS \45r<\<"5r="S!S"\55r>S#Her?\R\?rB\R"\AR\;5\BlD\R"\AR\:5\AlDMg S$rES%rFSrGSrH\E\F\/S&.rI\G\H\/S&.rJ"S'S(\45rK\K"5rL"S)S*\55rMS+Her?\KR\?rA\MR\?rB\R"\AR\J5\BlD\R"\AR\I5\AlDMg S,rNSrOSrP\N\/S-.rQ\O\/S-.rRS.rSS/rTS0rU"S1S2\45rV\V"5rW"S3S4\55rXS5Her?\VR\?rA\XR\?rB\R"\AR\R5\BlD\R"\AR\Q5\AlDMg S6rYSrZSr[Sr\\Y\Z\/S7.r]\[\\\/S7.r^"S8S9\45r_\_"5r`"S:S;\55raS<Her?\_R\?rA\aR\?rB\R"\AR\^5\BlD\R"\AR\]5\AlDMg "S=S>\_5rb\b"5rc"S?S@\55rdSAHer?\bR\?rA\aR\?rB\R"\AR\^5\BlD\R"\AR\]5\AlDMg SBreSCrfSrgSrh\e\f\/S7.ri\g\h\/S7.rj"SDSE\45rk\k"5rl"SFSG\55rmSHHer?\kR\?rA\mR\?rB\R"\AR\j5\BlD\R"\AR\i5\AlDMg "SISJ\45rn\n"5ro"SKSL\55rp"SMSN\45rq\q"5rr"SOSP\55rs"SQSR\45rt\t"5ru"SSST\55rv"SUSV\45rw\w"5rx"SWSX\55rySYrzSZr{Sr|\z\{\/S[.r}S\|\/S[.r~"S\S]\45r"S^S_\55r\"5rS`Her?\R\?rA\R\?rB\R"\AR\~5\BlD\R"\AR\}5\AlDMg SarSbrSrSr\\\/S7.r\\\/S7.r"ScSd\45r\"5r"SeSf\55rSgHer?\R\?rA\R\?rB\R"\AR\5\BlD\R"\AR\5\AlDMg "ShSi\45r\"5r"SjSk\55rSlrSmrSnrSo\3rSr\/\\\\Sp.r\GR)5r\GR-SS\Sq.5 SSrjr\"\\5 SsH>r?\R\?rA\R\?rB\"\B\\AR5 \"\A\5 M@ "StSu\45r\"5r"SvSw\55rSxrSyrSrSr\\/Sz.r\\/Sz.rSS{jr"S|S}\45r\"5r"S~S\55rSHer?\R\?rA\R\?rB\R"\AR\5\BlD\R"\AR\5\AlDMg "SS\45r\"5r"SS\55r"SS\45r\"5r"SS\55rSHer?\R\?rA\R\?rB\R"\AR\;5\BlD\R"\AR\:5\AlDMg g)N)doccer)gammalnpsi multigammalnxlogyentrbetalniveloggamma)special)check_random_state _lazywhere)drotget_blas_funcs)norminvgamma)binom)_mvn _covariance_rcont_qmvt)directional_stats) root_scalar)multivariate_normal matrix_normal dirichletdirichlet_multinomialwishart invwishart multinomialspecial_ortho_group ortho_grouprandom_correlation unitary_groupmultivariate_tmultivariate_hypergeom random_tableuniform_directionvonmises_fishernormal_inverse_gammaaseed : {None, int, np.random.RandomState, np.random.Generator}, optional Used for drawing random variates. If `seed` is `None`, the `~np.random.RandomState` singleton is used. If `seed` is an int, a new ``RandomState`` instance is used, seeded with seed. If `seed` is already a ``RandomState`` or ``Generator`` instance, then that object is used. Default is `None`. cPUR5nURS:XaUSnU$)zS Remove single-dimensional entries from array and convert to scalar, if necessary. r)squeezendimouts L/var/www/html/venv/lib/python3.13/site-packages/scipy/stats/_multivariate.py_squeeze_outputr59s( ++-C xx1}"g JcUbUnUS;aNURRR5nSSS.nXC[R"U5R -nU[R "[U55-nU$)aDetermine which eigenvalues are "small" given the spectrum. This is for compatibility across various linear algebra functions that should agree about whether or not a Hermitian matrix is numerically singular and what is its numerical matrix rank. This is designed to be compatible with scipy.linalg.pinvh. Parameters ---------- spectrum : 1d ndarray Array of eigenvalues of a Hermitian matrix. cond, rcond : float, optional Cutoff for small eigenvalues. Singular values smaller than rcond * largest_eigenvalue are considered zero. If None or -1, suitable machine precision is used. Returns ------- eps : float Magnitude cutoff for numerical negligibility. )N@@g.A)fd)dtypecharlowernpfinfoepsmaxabs)spectrumcondrcondtfactorrAs r4_eigvalsh_to_epsrIDsm0  z NN   % % '%y288A;??* H & &C Jr6c[R"UVs/sHn[U5U::aSOSU- PM sn[S9$s snf)aVA helper function for computing the pseudoinverse. Parameters ---------- v : iterable of numbers This may be thought of as a vector of eigenvalues or singular values. eps : float Values with magnitude no greater than eps are considered negligible. Returns ------- v_pinv : 1d float ndarray A vector of pseudo-inverted numbers. rrr<)r?arrayrCfloat)vrAxs r4_pinv_1drPfs: 88! check_finitez9The input matrix must be symmetric positive semidefinite.zUWhen `allow_singular is False`, the input matrix must be symmetric positive definite.r9)r?asarray_MscipylinalgeighrImin ValueErrorlen LinAlgErrorrPmultiplysqrtrAVrankUsumloglog_pdet_pinv)selfMrErFr>rVallow_singularsurAmsgr;s_pinvrds r4__init__ _PSD.__init__s**Q- ||  l Kq. 66!9t MCS/ ! #gJ q6CF?>2C))'', ,!! KK2776? +s71ah;F rvvay)  r6cv[RRXR-SS9nX R:nU$)z: Check whether x lies in the support of the distribution. r8axis)r?rZrrbrA)rirOresidual in_supports r4 _support_mask_PSD._support_masks299>>!ff*2>6( r6cURc:[R"URURR5UlUR$N)rhr?dotrdTris r4pinv _PSD.pinvs4 :: 1DJzzr6)rdrbrXrhrArgrc)NNTTT) __name__ __module__ __qualname____firstlineno____doc__rprwpropertyr~__static_attributes__r/r6r4rRrRys/%N8<37Br6rRcj^\rSrSrSrSU4Sjjr\S5r\RS5rSr Sr U=r $) multi_rv_genericzW Class which encapsulates common functionality between all multivariate distributions. cB>[TU]5 [U5Ulgrz)superrpr _random_stateriseed __class__s r4rpmulti_rv_generic.__init__s /5r6cUR$)aFGet or set the Generator object for generating random variates. 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. rr}s r4 random_statemulti_rv_generic.random_states!!!r6c$[U5Ulgrzr rrirs r4rrs/5r6c6Ub [U5$UR$rzrrirs r4_get_random_state"multi_rv_generic._get_random_states  #%l3 3%% %r6rrz) rrrrrrprrsetterrr __classcell__rs@r4rrsE6 " "66&&r6rcL\rSrSrSr\S5r\RS5rSrg)multi_rv_frozenz^ Class which encapsulates common functionality between all frozen multivariate distributions. c.URR$rz)_distrr}s r4rmulti_rv_frozen.random_stateszz'''r6c8[U5URlgrz)r rrrs r4rrs#5d#;  r6r/N) rrrrrrrrrr/r6r4rrs5((<See class definition for a detailed description of parameters.)_mvn_doc_default_callparams_mvn_doc_callparams_note_doc_random_statec^\rSrSrSrSU4SjjrSSjrSSjrSrSr S r S r SS jr SS jr S rSSS.SjjrSSS.SjjrSSjrSSjrSSjrSrU=r$)multivariate_normal_geni%aG A multivariate normal random variable. The `mean` keyword specifies the mean. The `cov` keyword specifies the covariance matrix. Methods ------- pdf(x, mean=None, cov=1, allow_singular=False) Probability density function. logpdf(x, mean=None, cov=1, allow_singular=False) Log of the probability density function. cdf(x, mean=None, cov=1, allow_singular=False, maxpts=1000000*dim, abseps=1e-5, releps=1e-5, lower_limit=None) Cumulative distribution function. logcdf(x, mean=None, cov=1, allow_singular=False, maxpts=1000000*dim, abseps=1e-5, releps=1e-5) Log of the cumulative distribution function. rvs(mean=None, cov=1, size=1, random_state=None) Draw random samples from a multivariate normal distribution. entropy(mean=None, cov=1) Compute the differential entropy of the multivariate normal. fit(x, fix_mean=None, fix_cov=None) Fit a multivariate normal distribution to data. Parameters ---------- %(_mvn_doc_default_callparams)s %(_doc_random_state)s Notes ----- %(_mvn_doc_callparams_note)s The covariance matrix `cov` may be an instance of a subclass of `Covariance`, e.g. `scipy.stats.CovViaPrecision`. If so, `allow_singular` is ignored. Otherwise, `cov` must be a symmetric positive semidefinite matrix when `allow_singular` is True; it must be (strictly) positive definite when `allow_singular` is False. Symmetry is not checked; only the lower triangular portion is used. The determinant and inverse of `cov` are computed as the pseudo-determinant and pseudo-inverse, respectively, so that `cov` does not need to have full rank. The probability density function for `multivariate_normal` is .. math:: f(x) = \frac{1}{\sqrt{(2 \pi)^k \det \Sigma}} \exp\left( -\frac{1}{2} (x - \mu)^T \Sigma^{-1} (x - \mu) \right), where :math:`\mu` is the mean, :math:`\Sigma` the covariance matrix, :math:`k` the rank of :math:`\Sigma`. In case of singular :math:`\Sigma`, SciPy extends this definition according to [1]_. .. versionadded:: 0.14.0 References ---------- .. [1] Multivariate Normal Distribution - Degenerate Case, Wikipedia, https://en.wikipedia.org/wiki/Multivariate_normal_distribution#Degenerate_case Examples -------- >>> import numpy as np >>> import matplotlib.pyplot as plt >>> from scipy.stats import multivariate_normal >>> x = np.linspace(0, 5, 10, endpoint=False) >>> y = multivariate_normal.pdf(x, mean=2.5, cov=0.5); y array([ 0.00108914, 0.01033349, 0.05946514, 0.20755375, 0.43939129, 0.56418958, 0.43939129, 0.20755375, 0.05946514, 0.01033349]) >>> fig1 = plt.figure() >>> ax = fig1.add_subplot(111) >>> ax.plot(x, y) >>> plt.show() Alternatively, the object may be called (as a function) to fix the mean and covariance parameters, returning a "frozen" multivariate normal random variable: >>> rv = multivariate_normal(mean=None, cov=1, allow_singular=False) >>> # Frozen object with the same methods but holding the given >>> # mean and covariance fixed. The input quantiles can be any shape of array, as long as the last axis labels the components. This allows us for instance to display the frozen pdf for a non-isotropic random variable in 2D as follows: >>> x, y = np.mgrid[-1:1:.01, -1:1:.01] >>> pos = np.dstack((x, y)) >>> rv = multivariate_normal([0.5, -0.2], [[2.0, 0.3], [0.3, 0.5]]) >>> fig2 = plt.figure() >>> ax2 = fig2.add_subplot(111) >>> ax2.contourf(x, y, rv.pdf(pos)) Ncx>[TU]U5 [R"UR[ 5Ulgrz)rrpr docformatrmvn_docdict_paramsrs r4rp multivariate_normal_gen.__init__) '' 6HI r6c[XUUS9$)zjCreate a frozen multivariate normal distribution. See `multivariate_normal_frozen` for more information. )rkr)multivariate_normal_frozen)rimeancovrkrs r4__call__ multivariate_normal_gen.__call__s *$9G/35 5r6c[U[R5(aURX5$UR SX5upAn[ X#S9n[R "U5nXAU4$)zt Infer dimensionality from mean or covariance matrix, ensure that mean and covariance are full vector resp. matrix. Nrk) isinstancer Covariance_process_parameters_Covariance_process_parameters_psdrR CovViaPSD)rirrrkdimpsd cov_objects r4_process_parameters+multivariate_normal_gen._process_parameterssg c;11 2 266tA A"99$JNCss:C$..s3Jj( (r6cURSnUc[R"S/5OUnSUSU43n[R"X5nX1U4$![an[ U5UeSnAff=f)Nr8z(`cov` represents a covariance matrix in z9 dimensions,and so `mean` must be broadcastable to shape )shaper?rL broadcast_tor])rirrrmessagees r4r6multivariate_normal_gen._process_parameters_Covariancesiim!%rxx~4=cUCCDG6(L -??4-D#~ -W%1 , -sA A+ A&&A+ctUckUcBUcSnO[R"U[S9nURS:aSnO\URSnOL[R"U[S9nUR nO&[R "U5(d [S5eUc[R"U5n[R"U[S9nUcSn[R"U[S9nUS:Xa#URS5nURSS5nURS:wdURSU:wa[SU-5eURS:XaU[R"U5-nOURS:Xa[R"U5nOURS:XanURX4:wa]URupEXE:waS[UR5S 3nO%S nU[UR5[U54-n[U5eURS:a[S UR-5eXU4$) NrrKr-rz.Dimension of random variable must be a scalar.?z+Array 'mean' must be a vector of length %d.EArray 'cov' must be square if it is two dimensional, but cov.shape = .zTDimension mismatch: array 'cov' is of shape %s, but 'mean' is a vector of length %d.>Array 'cov' must be at most two-dimensional, but cov.ndim = %d)r?rWrMr1rsizeisscalarr]zerosreshapeeyediagstrr^)rirrrrowscolsrns r4r/multivariate_normal_gen._process_parameters_psds ;|;C**S6Cxx!|!iilzz$e4ii;;s## "-.. <88C=Dzz$e, ;CjjE* !8<<?D++a#C 99>TZZ]c1J !" " 88q=s #C XX]''#,C XX]syySJ6JD|++.syy>*:!=?S^SY77S/ ! XX\247HH=> >#~r6c[R"U[S9nURS:XaU[RnU$URS:Xa6US:XaUSS2[R4nU$U[RSS24nU$T Adjust quantiles array so that last axis labels the components of each data point. rKrrNr?rWrMr1newaxisrirOrs r4_process_quantiles*multivariate_normal_gen._process_quantilessy JJq & 66Q;"** A VVq[axam$bjj!m$r6c@URURpTX- nURS:a*US[R4nUS[R4n[R "[R "URU55SS9nSU[-U-U--$)aLog of the multivariate normal probability density function. Parameters ---------- x : ndarray Points at which to evaluate the log of the probability density function mean : ndarray Mean of the distribution cov_object : Covariance An object representing the Covariance matrix Notes ----- As this function does no argument checking, it should not be called directly; use 'logpdf' instead. r.r8rs) rgrcr1r?rresquarewhiten_LOG_2PI)rirOrr log_det_covrcdevmahas r4_logpdfmultivariate_normal_gen._logpdfs&'//Th 88a<%c2::o6KRZZ(Dvvbii 1 1# 67bAth4t;<[ [R"USTUTSTTTTT5SsSSS5 $!,(df  g=fNr)MVN_LOCKrmvnun)limitsabsepsrmaxptsrnrelepss r4func1d,multivariate_normal_gen._cdf..func1ds?zz&!*fQRj$ &889;s %7 A) r?fullrrbroadcast_arraysrecopy concatenateapply_along_axisr5)rirOrrrrr lower_limitr>bai_swapsignsrrr3rs ````` @r4_cdfmultivariate_normal_gen._cdfUs> 'bffW--8  ""1,vzzrz*+vvx1 y!) 19 GGBKR0 ; ; !!&"f5=s##r6rc $URX#U5n U upn U RnURX5nU(dSU -nURXX5XgU5n [R "U S:5(aU S-OU n [R "U 5n U $)aLog of the multivariate normal cumulative distribution function. Parameters ---------- x : array_like Quantiles, with the last axis of `x` denoting the components. %(_mvn_doc_default_callparams)s maxpts : integer, optional The maximum number of points to use for integration (default ``1000000*dim``) abseps : float, optional Absolute error tolerance (default 1e-5) releps : float, optional Relative error tolerance (default 1e-5) lower_limit : array_like, optional Lower limit of integration of the cumulative distribution function. Default is negative infinity. Must be broadcastable with `x`. Returns ------- cdf : ndarray or scalar Log of the cumulative distribution function evaluated at `x` Notes ----- %(_mvn_doc_callparams_note)s .. versionadded:: 1.0.0 @Br)r covariancerr r?rrf)rirOrrrkrrrrrrrcdfr3s r4logcdfmultivariate_normal_gen.logcdfs@))$^D &:##  # #A +s]FiifkJ&&q//cBhsffSk r6c URX#U5n U upn U RnURX5nU(dSU -nURXX5XgU5n U $)a Multivariate normal cumulative distribution function. Parameters ---------- x : array_like Quantiles, with the last axis of `x` denoting the components. %(_mvn_doc_default_callparams)s maxpts : integer, optional The maximum number of points to use for integration (default ``1000000*dim``) abseps : float, optional Absolute error tolerance (default 1e-5) releps : float, optional Relative error tolerance (default 1e-5) lower_limit : array_like, optional Lower limit of integration of the cumulative distribution function. Default is negative infinity. Must be broadcastable with `x`. Returns ------- cdf : ndarray or scalar Cumulative distribution function evaluated at `x` Notes ----- %(_mvn_doc_callparams_note)s .. versionadded:: 1.0.0 r)rrrr ) rirOrrrkrrrrrrrr3s r4rmultivariate_normal_gen.cdfsa@))$^D &:##  # #A +s]FiifkJ r6cURX5upQnURU5n[U[R5(a+UR nUR XU5n[U5nU$U=(d [5n[R"U5(dU4n[U5URS4-nURUS9n XRU 5-nU$)aDraw random samples from a multivariate normal distribution. Parameters ---------- %(_mvn_doc_default_callparams)s size : integer, optional Number of samples to draw (default 1). %(_doc_random_state)s Returns ------- rvs : ndarray or scalar Random variates of size (`size`, `N`), where `N` is the dimension of the random variable. Notes ----- %(_mvn_doc_callparams_note)s r8r)rrrrrrrr5tupler?iterablernormalcolorize) rirrrrrrr3rrOs r4rvsmultivariate_normal_gen.rvss*!% 8 8 C:--l; j+"7"7 8 8''C224dCC!#&C ?57D;;t$$w$K:#3#3B#7"99E###/A,,Q//C r6cvURX5up1nSUR[S--UR--$)zCompute the differential entropy of the multivariate normal. Parameters ---------- %(_mvn_doc_default_callparams)s Returns ------- h : scalar Entropy of the multivariate normal distribution Notes ----- %(_mvn_doc_callparams_note)s ?r)rrcrrg)rirrrrs r4entropymultivariate_normal_gen.entropys<"!% 8 8 C:jooA69L9LLMMr6cd[R"U5nURS:wa [S5eURupEUb7[R "U5nURU4:wa Sn[U5eUnOUR SS9nUb[R"U5nURXU4:wa Sn[U5e[RRUSSS9up[U5n [R"U5U *:a S n[U5eUn X{4$X- n U RU -U- n X{4$) aFit a multivariate normal distribution to data. Parameters ---------- x : ndarray (m, n) Data the distribution is fitted to. Must have two axes. The first axis of length `m` represents the number of vectors the distribution is fitted to. The second axis of length `n` determines the dimensionality of the fitted distribution. fix_mean : ndarray(n, ) Fixed mean vector. Must have length `n`. fix_cov: ndarray (n, n) Fixed covariance matrix. Must have shape ``(n, n)``. Returns ------- mean : ndarray (n, ) Maximum likelihood estimate of the mean vector cov : ndarray (n, n) Maximum likelihood estimate of the covariance matrix r-z`x` must be two-dimensional.zd`fix_mean` must be a one-dimensional array the same length as the dimensionality of the vectors `x`.rrszn`fix_cov` must be a two-dimensional square array of same side length as the dimensionality of the vectors `x`.TrUz2`fix_cov` must be symmetric positive semidefinite.)r?rWr1r]r atleast_1dr atleast_2drYrZr[rIr\r|) rirOfix_meanfix_cov n_vectorsrrnrrlrmrAr centered_datas r4fitmultivariate_normal_gen.fits/0 JJqM 66Q;;< <   }}X.H~~#(J o%D66q6>D  mmG,G}} *&!o%<<$$WDt$LDA"1%CvvayC4J o%CyHM//M1I=Cyr6rrz)NrFN)T)NrF)NrFNh㈵>r/NrrNNrNN)rrrrrrprrrrrrrrr rrrr#r,rrrs@r4rr%s`DJ5)0 7r"=6$8$83$jHL#'+8<+ZEI $'59'R#JN(??r6rcj\rSrSrS Sjr\S5rSrSrSS.Sjr SS.S jr SS jr S r S r g)ri^Nc[U5UlURRXU5uUlUlUlU=(d UR R UlU(dSUR-nXPlX`l Xpl g)aHCreate a frozen multivariate normal distribution. Parameters ---------- mean : array_like, default: ``[0]`` Mean of the distribution. cov : array_like, default: ``[1]`` Symmetric positive (semi)definite covariance matrix of the distribution. allow_singular : bool, default: ``False`` Whether to allow a singular covariance matrix. 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. maxpts : integer, optional The maximum number of points to use for integration of the cumulative distribution function (default ``1000000*dim``) abseps : float, optional Absolute error tolerance for the cumulative distribution function (default 1e-5) releps : float, optional Relative error tolerance for the cumulative distribution function (default 1e-5) Examples -------- When called with the default parameters, this will create a 1D random variable with mean 0 and covariance 1: >>> from scipy.stats import multivariate_normal >>> r = multivariate_normal() >>> r.mean array([ 0.]) >>> r.cov array([[1.]]) rN) rrrrrr_allow_singularrkrrr)rirrrkrrrrs r4rp#multivariate_normal_frozen.__init___smV-T2 JJ * *4n E -$)T_,O0O0Otxx'F   r6c.URR$rz)rrr}s r4rmultivariate_normal_frozen.covs)))r6cURRXR5nURRXRUR 5n[ R"UR RUR:5(a;UR RXR- 5)n[ R*X#'[U5$rz) rrrrrrr?rrcrwrr5)rirOr3rs r4r!multivariate_normal_frozen.logpdfs JJ ) )!XX 6jj  IIt? 66$//&&1 2 2!__::1YY;GGM"$&&C s##r6cL[R"URU55$rzr?rrrirOs r4rmultivariate_normal_frozen.pdfvvdkk!n%%r6rcURXS9n[R"US:5(aUS-OUn[R"U5nU$)Nrrr)rr?rrf)rirOrrr3s r4r!multivariate_normal_frozen.logcdfsAhhqh2&&q//cBhsffSk r6c URRXR5nURRXRUR R URURURU5n[U5$rz) rrrr rrrrrrr5)rirOrr3s r4rmultivariate_normal_frozen.cdfsa JJ ) )!XX 6jjooaDOO,F,F"kk4;; )+s##r6cdURRURURX5$rz)rrrrrirrs r4rmultivariate_normal_frozen.rvss!zz~~dii$MMr6c~URRnURRnSU[S--U--$)zComputes the differential entropy of the multivariate normal. Returns ------- h : scalar Entropy of the multivariate normal distribution r"r)rrgrcr)rirgrcs r4r#"multivariate_normal_frozen.entropys;??++##dhl+h677r6)rrrkrrrrr)NrFNNr/r/rN)rrrrrprrrrrrrr#rr/r6r4rr^sKDH263j**$&(,%)$N 8r6r)rrrrramean : array_like, optional Mean of the distribution (default: `None`) rowcov : array_like, optional Among-row covariance matrix of the distribution (default: ``1``) colcov : array_like, optional Among-column covariance matrix of the distribution (default: ``1``) aIf `mean` is set to `None` then a matrix of zeros is used for the mean. The dimensions of this matrix are inferred from the shape of `rowcov` and `colcov`, if these are provided, or set to ``1`` if ambiguous. `rowcov` and `colcov` can be two-dimensional array_likes specifying the covariance matrices directly. Alternatively, a one-dimensional array will be be interpreted as the entries of a diagonal matrix, and a scalar or zero-dimensional array will be interpreted as this value times the identity matrix. )_matnorm_doc_default_callparams_matnorm_doc_callparams_notercz^\rSrSrSrSU4SjjrSSjrSrSrSr SSjr SS jr SS jr SS jr S rS rU=r$)matrix_normal_genia A matrix normal random variable. The `mean` keyword specifies the mean. The `rowcov` keyword specifies the among-row covariance matrix. The 'colcov' keyword specifies the among-column covariance matrix. Methods ------- pdf(X, mean=None, rowcov=1, colcov=1) Probability density function. logpdf(X, mean=None, rowcov=1, colcov=1) Log of the probability density function. rvs(mean=None, rowcov=1, colcov=1, size=1, random_state=None) Draw random samples. entropy(rowcol=1, colcov=1) Differential entropy. Parameters ---------- %(_matnorm_doc_default_callparams)s %(_doc_random_state)s Notes ----- %(_matnorm_doc_callparams_note)s The covariance matrices specified by `rowcov` and `colcov` must be (symmetric) positive definite. If the samples in `X` are :math:`m \times n`, then `rowcov` must be :math:`m \times m` and `colcov` must be :math:`n \times n`. `mean` must be the same shape as `X`. The probability density function for `matrix_normal` is .. math:: f(X) = (2 \pi)^{-\frac{mn}{2}}|U|^{-\frac{n}{2}} |V|^{-\frac{m}{2}} \exp\left( -\frac{1}{2} \mathrm{Tr}\left[ U^{-1} (X-M) V^{-1} (X-M)^T \right] \right), where :math:`M` is the mean, :math:`U` the among-row covariance matrix, :math:`V` the among-column covariance matrix. The `allow_singular` behaviour of the `multivariate_normal` distribution is not currently supported. Covariance matrices must be full rank. The `matrix_normal` distribution is closely related to the `multivariate_normal` distribution. Specifically, :math:`\mathrm{Vec}(X)` (the vector formed by concatenating the columns of :math:`X`) has a multivariate normal distribution with mean :math:`\mathrm{Vec}(M)` and covariance :math:`V \otimes U` (where :math:`\otimes` is the Kronecker product). Sampling and pdf evaluation are :math:`\mathcal{O}(m^3 + n^3 + m^2 n + m n^2)` for the matrix normal, but :math:`\mathcal{O}(m^3 n^3)` for the equivalent multivariate normal, making this equivalent form algorithmically inefficient. .. versionadded:: 0.17.0 Examples -------- >>> import numpy as np >>> from scipy.stats import matrix_normal >>> M = np.arange(6).reshape(3,2); M array([[0, 1], [2, 3], [4, 5]]) >>> U = np.diag([1,2,3]); U array([[1, 0, 0], [0, 2, 0], [0, 0, 3]]) >>> V = 0.3*np.identity(2); V array([[ 0.3, 0. ], [ 0. , 0.3]]) >>> X = M + 0.1; X array([[ 0.1, 1.1], [ 2.1, 3.1], [ 4.1, 5.1]]) >>> matrix_normal.pdf(X, mean=M, rowcov=U, colcov=V) 0.023410202050005054 >>> # Equivalent multivariate normal >>> from scipy.stats import multivariate_normal >>> vectorised_X = X.T.flatten() >>> equiv_mean = M.T.flatten() >>> equiv_cov = np.kron(V,U) >>> multivariate_normal.pdf(vectorised_X, mean=equiv_mean, cov=equiv_cov) 0.023410202050005054 Alternatively, the object may be called (as a function) to fix the mean and covariance parameters, returning a "frozen" matrix normal random variable: >>> rv = matrix_normal(mean=None, rowcov=1, colcov=1) >>> # Frozen object with the same methods but holding the given >>> # mean and covariance fixed. cx>[TU]U5 [R"UR[ 5Ulgrz)rrprrrmatnorm_docdict_paramsrs r4rpmatrix_normal_gen.__init__X) '' 6LM r6c[XX4S9$)z_Create a frozen matrix normal distribution. See `matrix_normal_frozen` for more information. r)matrix_normal_frozenrirrowcovcolcovrs r4rmatrix_normal_gen.__call__\s $D&DDr6cUbh[R"U[S9nURn[ U5S:wa [ S5e[R "US:H5(a [ S5e[R"U[S9nURS:Xa:UbU[R"WS5-nO@U[R"S5-nO&URS:Xa[R"U5nURn[ U5S:wa [ S5eUSUS:wa [ S5eUSS:Xa [ S 5eUSn[R"U[S9nURS:Xa:UbU[R"WS5-nO@U[R"S5-nO&URS:Xa[R"U5nURn[ U5S:wa [ S 5eUSUS:wa [ S 5eUSS:Xa [ S 5eUSnUb)WSU:wa [ S 5eUSU:wa [ S5eO[R"Xh45nXh4n XX#4$)zg Infer dimensionality from mean or covariance matrices. Handle defaults. Ensure compatible dimensions. rKr-z%Array `mean` must be two dimensional.rzArray `mean` has invalid shape.rz(`rowcov` must be a scalar or a 2D array.zArray `rowcov` must be square.z!Array `rowcov` has invalid shape.z(`colcov` must be a scalar or a 2D array.zArray `colcov` must be square.z!Array `colcov` has invalid shape.z=Arrays `mean` and `rowcov` must have the same number of rows.z@Arrays `mean` and `colcov` must have the same number of columns.) r?rWrMrr^r]rr1identityrr) rirrVrW meanshaperowshapenumrowscolshapenumcolsdimss r4r%matrix_normal_gen._process_parametersdsQ  ::d%0D I9~" !HIIvvi1n%% !BCCF%0 ;;! "++il";;"++a.0 [[A WWV_F<< x=A GH H A;(1+ %=> > A;! @A A1+F%0 ;;! "++il";;"++a.0 [[A WWV_F<< x=A GH H A;(1+ %=> > A;! @A A1+  |w& "899|w& ";<<'88W./D!6))r6c[R"U[S9nURS:XaU[RSS24nUR SSU:wa [ S5eU$)zX Adjust quantiles array so that last two axes labels the components of each data point. rKr-NzJThe shape of array `X` is not compatible with the distribution parameters.)r?rWrMr1rrr])riXr`s r4r$matrix_normal_gen._process_quantiless] JJq & 66Q;"**a- A 7723<4 AB Br6cXUup[R"X#- SS5n [R"UR[R"X5S5n [R "[R "[R "U 5SS9SS9n SX-[-X--X--U --$)aQLog of the matrix normal probability density function. Parameters ---------- dims : tuple Dimensions of the matrix variates X : ndarray Points at which to evaluate the log of the probability density function mean : ndarray Mean of the distribution row_prec_rt : ndarray A decomposition such that np.dot(row_prec_rt, row_prec_rt.T) is the inverse of the among-row covariance matrix log_det_rowcov : float Logarithm of the determinant of the among-row covariance matrix col_prec_rt : ndarray A decomposition such that np.dot(col_prec_rt, col_prec_rt.T) is the inverse of the among-column covariance matrix log_det_colcov : float Logarithm of the determinant of the among-column covariance matrix Notes ----- As this function does no argument checking, it should not be called directly; use 'logpdf' instead. r8rrrsr)r?moveaxis tensordotr|r{rerr) rir`rdr row_prec_rtlog_det_rowcov col_prec_rtlog_det_colcovr]r_roll_dev scale_devrs r4rmatrix_normal_gen._logpdfs< ;;qvr1-LL!#!>C vvbffRYYy1;!Dwx/'2HH /02678 8r6c URX#U5upRp4URX5n[USS9n[USS9nURXQX&RUR URUR 5n[ U5$)aULog of the matrix normal probability density function. Parameters ---------- X : array_like Quantiles, with the last two axes of `X` denoting the components. %(_matnorm_doc_default_callparams)s Returns ------- logpdf : ndarray Log of the probability density function evaluated at `X` Notes ----- %(_matnorm_doc_callparams_note)s Fr)rrrRrrdrgr5) rirdrrVrWr`rowpsdcolpsdr3s r4rmatrix_normal_gen.logpdfs{&&*%=%=d>D&F"F  # #A ,fU3fU3ll4D((FOOVXX!??,s##r6cN[R"URXX455$)a<Matrix normal probability density function. Parameters ---------- X : array_like Quantiles, with the last two axes of `X` denoting the components. %(_matnorm_doc_default_callparams)s Returns ------- pdf : ndarray Probability density function evaluated at `X` Notes ----- %(_matnorm_doc_callparams_note)s r<)rirdrrVrWs r4rmatrix_normal_gen.pdfs&vvdkk!6:;;r6c [U5nURXU5upap#[RR USS9n[RR USS9nUR U5nUR USXFS4S9RSSS5n U[R"SXyUSS9-n US:XaU RUR5n U $) aDraw random samples from a matrix normal distribution. Parameters ---------- %(_matnorm_doc_default_callparams)s size : integer, optional Number of samples to draw (default 1). %(_doc_random_state)s Returns ------- rvs : ndarray or scalar Random variates of size (`size`, `dims`), where `dims` is the dimension of the random matrices. Notes ----- %(_matnorm_doc_callparams_note)s Tr>rrrr-zjp,ipq,kq->ijk)optimize) intrrYrZcholeskyrstandard_normal transposer?einsumrr) rirrVrWrrr`rowcholcolcholstd_normr3s r4rmatrix_normal_gen.rvs s*4y%)%=%=d>D&F"F,,''d';,,''d';--l;  //q'4a)0 )Aq!  RYY/&'(,.. 19++djj)C r6c[R"URSURS45nURUUU5upEp[ USS9n[ USS9nUR XFR UR 5$)aLog of the matrix normal probability density function. Parameters ---------- rowcov : array_like, optional Among-row covariance matrix of the distribution (default: ``1``) colcov : array_like, optional Among-column covariance matrix of the distribution (default: ``1``) Returns ------- entropy : float Entropy of the distribution Notes ----- %(_matnorm_doc_callparams_note)s rFr)r?rrrrR_entropyrg)rirVrW dummy_meanr`_rqrrs r4r#matrix_normal_gen.entropy3sx(XXv||A Q@A "&":"::;A;A#CfU3fU3}}T??FOODDr6cRUupESU-U-S[--SU-U--SU-U--$Nr"r)r)rir`row_cov_logdetcol_cov_logdetrps r4rmatrix_normal_gen._entropyPsAa! q8|,sQw/GGa.() *r6r.rzr0NrrNrrrNrr)rrrrrrprrrrrrrr#rrrrs@r4rMrMsHbHNE@*D $8L$8<*'RE:**r6rMc>\rSrSrSrS SjrSrSrS SjrSr S r g) rTiYaR Create a frozen matrix normal distribution. Parameters ---------- %(_matnorm_doc_default_callparams)s seed : {None, int, `numpy.random.Generator`, `numpy.random.RandomState`}, optional If `seed` is `None` the `~np.random.RandomState` singleton is used. If `seed` is an int, a new ``RandomState`` instance is used, seeded with seed. If `seed` is already a ``RandomState`` or ``Generator`` instance, then that object is used. Default is `None`. Examples -------- >>> import numpy as np >>> from scipy.stats import matrix_normal >>> distn = matrix_normal(mean=np.zeros((3,3))) >>> X = distn.rvs(); X array([[-0.02976962, 0.93339138, -0.09663178], [ 0.67405524, 0.28250467, -0.93308929], [-0.31144782, 0.74535536, 1.30412916]]) >>> distn.pdf(X) 2.5160642368346784e-05 >>> distn.logpdf(X) -10.590229595124615 Nc[U5UlURRXU5uUlUlUlUl[UR SS9Ul[UR SS9Ul g)NFr) rMrrr`rrVrWrRrqrrrUs r4rpmatrix_normal_frozen.__init__xs[&t, JJ * *4 @ 7 49dk4;4;;u= 4;;u= r6c jURRXR5nURRURXRUR R UR RURR URR5n[U5$rz) rrr`rrrqrdrgrrr5)rirdr3s r4rmatrix_normal_frozen.logpdfsu JJ ) )!YY 7jj  Ayy$++--!%!5!5t{{}}!%!5!57s##r6cL[R"URU55$rzr<)rirds r4rmatrix_normal_frozen.pdfr?r6c|URRURURURUU5$rz)rrrrVrWrEs r4rmatrix_normal_frozen.rvss.zz~~diidkk4*, ,r6cURRURURRUR R5$rz)rrr`rqrgrrr}s r4r#matrix_normal_frozen.entropys8zz""499dkk.B.B#';;#7#79 9r6)rrWrrr`rrVrqr0rI) rrrrrrprrrr#rr/r6r4rTrTYs <>$&,9r6rT)rrrr#zalpha : array_like The concentration parameters. The number of entries determines the dimensionality of the distribution. )!_dirichlet_doc_default_callparamsrc[R"U5n[R"U5S::a [S5eURS:wa[SUR S35eU$)Nrz%All parameters must be greater than 0rzzLThe input vector 'x' must lie within the normal simplex. but np.sum(x, 0) = )r?rWrr]rLrer1appendvstackr\rBrepeatr logical_andrCr)rrOxkxeq0alphalt1chks r4_dirichlet_check_inputrs 1 AwwqzA~Q'AGGAJ%++a.,HDDIKK=Q**+''!56 6  wwqzU[[^# XXq266!Q<'( ) 77a< ! A WW\ 1'"AJK K vvay1}$% % vvay1}JKK FD Hww%++99Xwwr{<DDQWWM .. (C vvc{{34 4 rvva|c!"V+002288:q! ~QHI I Hr6c[R"[U55[[R"U55- $)aJInternal helper function to compute the log of the useful quotient. .. math:: B(\alpha) = \frac{\prod_{i=1}{K}\Gamma(\alpha_i)} {\Gamma\left(\sum_{i=1}^{K} \alpha_i \right)} Parameters ---------- %(_dirichlet_doc_default_callparams)s Returns ------- B : scalar Helper quotient, internal use only )r?rerrs r4_lnBrs)$ 66'%. !GBFF5M$: ::r6cn^\rSrSrSrSU4SjjrSSjrSrSrSr Sr S r S r S r SS jrS rU=r$) dirichlet_genia~ A Dirichlet random variable. The ``alpha`` keyword specifies the concentration parameters of the distribution. .. versionadded:: 0.15.0 Methods ------- pdf(x, alpha) Probability density function. logpdf(x, alpha) Log of the probability density function. rvs(alpha, size=1, random_state=None) Draw random samples from a Dirichlet distribution. mean(alpha) The mean of the Dirichlet distribution var(alpha) The variance of the Dirichlet distribution cov(alpha) The covariance of the Dirichlet distribution entropy(alpha) Compute the differential entropy of the Dirichlet distribution. Parameters ---------- %(_dirichlet_doc_default_callparams)s %(_doc_random_state)s Notes ----- Each :math:`\alpha` entry must be positive. The distribution has only support on the simplex defined by .. math:: \sum_{i=1}^{K} x_i = 1 where :math:`0 < x_i < 1`. If the quantiles don't lie within the simplex, a ValueError is raised. The probability density function for `dirichlet` is .. math:: f(x) = \frac{1}{\mathrm{B}(\boldsymbol\alpha)} \prod_{i=1}^K x_i^{\alpha_i - 1} where .. math:: \mathrm{B}(\boldsymbol\alpha) = \frac{\prod_{i=1}^K \Gamma(\alpha_i)} {\Gamma\bigl(\sum_{i=1}^K \alpha_i\bigr)} and :math:`\boldsymbol\alpha=(\alpha_1,\ldots,\alpha_K)`, the concentration parameters and :math:`K` is the dimension of the space where :math:`x` takes values. Note that the `dirichlet` interface is somewhat inconsistent. The array returned by the rvs function is transposed with respect to the format expected by the pdf and logpdf. Examples -------- >>> import numpy as np >>> from scipy.stats import dirichlet Generate a dirichlet random variable >>> quantiles = np.array([0.2, 0.2, 0.6]) # specify quantiles >>> alpha = np.array([0.4, 5, 15]) # specify concentration parameters >>> dirichlet.pdf(quantiles, alpha) 0.2843831684937255 The same PDF but following a log scale >>> dirichlet.logpdf(quantiles, alpha) -1.2574327653159187 Once we specify the dirichlet distribution we can then calculate quantities of interest >>> dirichlet.mean(alpha) # get the mean of the distribution array([0.01960784, 0.24509804, 0.73529412]) >>> dirichlet.var(alpha) # get variance array([0.00089829, 0.00864603, 0.00909517]) >>> dirichlet.entropy(alpha) # calculate the differential entropy -4.3280162474082715 We can also return random samples from the distribution >>> dirichlet.rvs(alpha, size=1, random_state=1) array([[0.00766178, 0.24670518, 0.74563305]]) >>> dirichlet.rvs(alpha, size=2, random_state=2) array([[0.01639427, 0.1292273 , 0.85437844], [0.00156917, 0.19033695, 0.80809388]]) Alternatively, the object may be called (as a function) to fix concentration parameters, returning a "frozen" Dirichlet random variable: >>> rv = dirichlet(alpha) >>> # Frozen object with the same methods but holding the given >>> # concentration parameters fixed. cx>[TU]U5 [R"UR[ 5Ulgrz)rrprrrdirichlet_docdict_paramsrs r4rpdirichlet_gen.__init__gs) '' 6NO r6c[XS9$NrS)dirichlet_frozenrirrs r4rdirichlet_gen.__call__ks 11r6c[U5nU*[R"[US- UR5RS5-$)a>Log of the Dirichlet probability density function. Parameters ---------- x : ndarray Points at which to evaluate the log of the probability density function %(_dirichlet_doc_default_callparams)s Notes ----- As this function does no argument checking, it should not be called directly; use 'logpdf' instead. rr)rr?rerr|)rirOrlnBs r4rdirichlet_gen._logpdfns: 5kurvvuUQY477;;;r6cf[U5n[X!5nURX5n[U5$)a)Log of the Dirichlet probability density function. Parameters ---------- x : array_like Quantiles, with the last axis of `x` denoting the components. %(_dirichlet_doc_default_callparams)s Returns ------- pdf : ndarray or scalar Log of the probability density function evaluated at `x`. )rrrr5rirOrr3s r4rdirichlet_gen.logpdfs1,E2 "5 ,ll1$s##r6c[U5n[X!5n[R"UR X55n[ U5$)aThe Dirichlet probability density function. Parameters ---------- x : array_like Quantiles, with the last axis of `x` denoting the components. %(_dirichlet_doc_default_callparams)s Returns ------- pdf : ndarray or scalar The probability density function evaluated at `x`. )rrr?rrr5rs r4rdirichlet_gen.pdfs:,E2 "5 ,ffT\\!+,s##r6c`[U5nU[R"U5- n[U5$)zMean of the Dirichlet distribution. Parameters ---------- %(_dirichlet_doc_default_callparams)s Returns ------- mu : ndarray or scalar Mean of the Dirichlet distribution. rr?rer5)rirr3s r4rdirichlet_gen.means+,E2rvve}%s##r6c~[U5n[R"U5nXU- -X"-US--- n[U5$)zVariance of the Dirichlet distribution. Parameters ---------- %(_dirichlet_doc_default_callparams)s Returns ------- v : ndarray or scalar Variance of the Dirichlet distribution. rr)riralpha0r3s r4vardirichlet_gen.varsB,E2'V_!,LMs##r6c[U5n[R"U5nX- n[R"U5[R"X35- US-- n[ U5$)zCovariance matrix of the Dirichlet distribution. Parameters ---------- %(_dirichlet_doc_default_callparams)s Returns ------- cov : ndarray The covariance matrix of the distribution. r)rr?rerouterr5)rirrr rs r4rdirichlet_gen.covsP,E2 NwwqzBHHQN*vz:s##r6cP[U5n[R"U5n[U5nURSnX2U- [ R RU5--[R"US- [ R RU5-5- n[U5$)z Differential entropy of the Dirichlet distribution. Parameters ---------- %(_dirichlet_doc_default_callparams)s Returns ------- h : scalar Entropy of the Dirichlet distribution rr) rr?rerrrYr rr5)rirrrKr3s r4r#dirichlet_gen.entropys,E25k KKNaZ5==#4#4V#<<r6r)rrrrrrr#zdf : int Degrees of freedom, must be greater than or equal to dimension of the scale matrix scale : array_like Symmetric positive definite scale matrix of the distribution )_doc_default_callparams_doc_callparams_noterc^\rSrSrSrSU4SjjrSSjrSrSrSr Sr S r S r S r S rS rSrSrSrSrSrSSjrSrSrSrSrU=r$) wishart_geniYa! A Wishart random variable. The `df` keyword specifies the degrees of freedom. The `scale` keyword specifies the scale matrix, which must be symmetric and positive definite. In this context, the scale matrix is often interpreted in terms of a multivariate normal precision matrix (the inverse of the covariance matrix). These arguments must satisfy the relationship ``df > scale.ndim - 1``, but see notes on using the `rvs` method with ``df < scale.ndim``. Methods ------- pdf(x, df, scale) Probability density function. logpdf(x, df, scale) Log of the probability density function. rvs(df, scale, size=1, random_state=None) Draw random samples from a Wishart distribution. entropy() Compute the differential entropy of the Wishart distribution. Parameters ---------- %(_doc_default_callparams)s %(_doc_random_state)s Raises ------ scipy.linalg.LinAlgError If the scale matrix `scale` is not positive definite. See Also -------- invwishart, chi2 Notes ----- %(_doc_callparams_note)s The scale matrix `scale` must be a symmetric positive definite matrix. Singular matrices, including the symmetric positive semi-definite case, are not supported. Symmetry is not checked; only the lower triangular portion is used. The Wishart distribution is often denoted .. math:: W_p(\nu, \Sigma) where :math:`\nu` is the degrees of freedom and :math:`\Sigma` is the :math:`p \times p` scale matrix. The probability density function for `wishart` has support over positive definite matrices :math:`S`; if :math:`S \sim W_p(\nu, \Sigma)`, then its PDF is given by: .. math:: f(S) = \frac{|S|^{\frac{\nu - p - 1}{2}}}{2^{ \frac{\nu p}{2} } |\Sigma|^\frac{\nu}{2} \Gamma_p \left ( \frac{\nu}{2} \right )} \exp\left( -tr(\Sigma^{-1} S) / 2 \right) If :math:`S \sim W_p(\nu, \Sigma)` (Wishart) then :math:`S^{-1} \sim W_p^{-1}(\nu, \Sigma^{-1})` (inverse Wishart). If the scale matrix is 1-dimensional and equal to one, then the Wishart distribution :math:`W_1(\nu, 1)` collapses to the :math:`\chi^2(\nu)` distribution. The algorithm [2]_ implemented by the `rvs` method may produce numerically singular matrices with :math:`p - 1 < \nu < p`; the user may wish to check for this condition and generate replacement samples as necessary. .. versionadded:: 0.16.0 References ---------- .. [1] M.L. Eaton, "Multivariate Statistics: A Vector Space Approach", Wiley, 1983. .. [2] W.B. Smith and R.R. Hocking, "Algorithm AS 53: Wishart Variate Generator", Applied Statistics, vol. 21, pp. 341-345, 1972. Examples -------- >>> import numpy as np >>> import matplotlib.pyplot as plt >>> from scipy.stats import wishart, chi2 >>> x = np.linspace(1e-5, 8, 100) >>> w = wishart.pdf(x, df=3, scale=1); w[:5] array([ 0.00126156, 0.10892176, 0.14793434, 0.17400548, 0.1929669 ]) >>> c = chi2.pdf(x, 3); c[:5] array([ 0.00126156, 0.10892176, 0.14793434, 0.17400548, 0.1929669 ]) >>> plt.plot(x, w) >>> plt.show() The input quantiles can be any shape of array, as long as the last axis labels the components. Alternatively, the object may be called (as a function) to fix the degrees of freedom and scale parameters, returning a "frozen" Wishart random variable: >>> rv = wishart(df=1, scale=1) >>> # Frozen object with the same methods but holding the given >>> # degrees of freedom and scale fixed. cx>[TU]U5 [R"UR[ 5Ulgrzrrprrrwishart_docdict_paramsrs r4rpwishart_gen.__init__rQr6c[XU5$)zRCreate a frozen Wishart distribution. See `wishart_frozen` for more information. )wishart_frozenridfscalers r4rwishart_gen.__call__s b..r6cUcSn[R"U[S9nURS:Xa$U[R[R4nOURS:Xa[R "U5nOzURS:XaBUR SUR S:Xd"[S[UR 5S35eURS:a[SUR-5eUR SnUcUnO9[R"U5(d [S 5eXS- ::a [S 5eX1U4$) NrrKrrr-zIArray 'scale' must be square if it is two dimensional, but scale.scale = rzBArray 'scale' must be at most two-dimensional, but scale.ndim = %dz$Degrees of freedom must be a scalar.zNDegrees of freedom must be greater than the dimension of scale matrix minus 1.) r?rWrMr1rrrr]rr)rirrrs r4rwishart_gen._process_parameterss+ =E 5. ::?"**bjj01E ZZ1_GGENE ZZ1_U[[^u{{1~%E336u{{3C2DAGH H ZZ!^46;jjAB Bkk!n :BRCD D 7]BC C~r6c[R"U[S9nURS:Xa1U[R"U5SS2SS2[R 4-nURS:Xa]US:Xa(U[R [R SS24nGO[R "U5SS2SS2[R 4nOURS:Xa]URSURS:Xd"[S[UR5S35eUSS2SS2[R 4nO{URS:XaCURSURS:Xd"[S [UR5S35eO(URS:a[S UR-5eURSSX"4:Xd [S X"4S URSSS35eU$) rrKrNrr-zDQuantiles must be square if they are two dimensional, but x.shape = rzbQuantiles must be square in the first two dimensions if they are three dimensional, but x.shape = znQuantiles must be at most two-dimensional with an additional dimension for multiplecomponents, but x.ndim = %dz2Quantiles have incompatible dimensions: should be z, got ) r?rWrMr1rrrrr]rrs r4rwishart_gen._process_quantiless JJq & 66Q;BFF3K1bjj 011A 66Q;axbjj"**a/0GGAJq!RZZ/0 VVq[771:+ &&)!''l^1677!Q "#A VVq[771:+ DDGL>QRTUU,VVaZ;=>VVDE E wwq|z)$%(J #D YY]%%(t%5$689 9 IIKd xr6cl[R"URS5n[R"UR5n[R"URS5n [URS5Hun UR USS2SS2U 45uoU '[ R RUS4USS2SS2U 45USS2SS2U 4'USS2SS2U 4R5X'Mw SX2- S- -U-SU -- SU-U-[-SU-U--[SU-U5-- n U $)aLog of the Wishart probability density function. Parameters ---------- x : ndarray Points at which to evaluate the log of the probability density function dim : int Dimension of the scale matrix df : int Degrees of freedom scale : ndarray Scale matrix log_det_scale : float Logarithm of the determinant of the scale matrix C : ndarray Cholesky factorization of the scale matrix, lower triangular. Notes ----- As this function does no argument checking, it should not be called directly; use 'logpdf' instead. r8NTr"r) r?emptyrrange_cholesky_logdetrYrZ cho_solvetrace_LOG_2r) rirOrrr log_det_scaleC log_det_x scale_inv_xtr_scale_inv_xirr3s r4rwishart_gen._logpdf#s">HHQWWR[) hhqww' !''"+.qwwr{#A"33AaAgJ?OA|#(<<#9#91d)Qq!QwZ#PK1a +Aq!G 4 : : ??3"-!,( ??3'!*( !1s %D cURU5nURXX4U5n[R"U5H>n[R"XWU5n [R"XR 5Xx'M@ U$)aDraw random samples from a Wishart distribution. Parameters ---------- n : integer Number of variates to generate shape : iterable Shape of the variates to generate dim : int Dimension of the scale matrix df : int Degrees of freedom C : ndarray Cholesky factorization of the scale matrix, lower triangular. %(_doc_random_state)s Notes ----- As this function does no argument checking, it should not be called directly; use 'rvs' instead. )rr4r?ndindexr{r|) rirrrrrrr0indexCAs r4_rvswishart_gen._rvs& sl.--l;    q, ?ZZ&EU8$Bvvb$$'AH'r6cURU5upVURX5upqn[RR USS9nUR XVXqX5n [ U 5$)aDraw random samples from a Wishart distribution. Parameters ---------- %(_doc_default_callparams)s size : integer or iterable of integers, optional Number of samples to draw (default 1). %(_doc_random_state)s Returns ------- rvs : ndarray Random variates of shape (`size`) + (``dim``, ``dim``), where ``dim`` is the dimension of the scale matrix. Notes ----- %(_doc_callparams_note)s TrwrrrYrZrzr:r5 rirrrrrrrrr3s r4rwishart_gen.rvsS b*%%d+11"< LL ! !%t ! 4ii#1;s##r6c SUS--U-SU-US--[--[SU-U5-SX!- S- -[R"[ U5Vs/sHn[ SUS-US-- -5PM sn5-- SU-U--$s snf)aRCompute the differential entropy of the Wishart. Parameters ---------- dim : int Dimension of the scale matrix df : int Degrees of freedom log_det_scale : float Logarithm of the determinant of the scale matrix Notes ----- As this function does no argument checking, it should not be called directly; use 'entropy' instead. r"r)rrr?rerr)rirrrrs r4rwishart_gen._entropyr s& 3q5MM ) #IQ & ( ) R % & 28a< 26649#J?JqS"q&AaC.)*J?$   "HsN   @s!B ctURX5up1nURU5upEURX1U5$)zCompute the differential entropy of the Wishart. Parameters ---------- %(_doc_default_callparams)s Returns ------- h : scalar Entropy of the Wishart distribution Notes ----- %(_doc_callparams_note)s rrrrirrrrrs r4r#wishart_gen.entropy s<"11"<007}}Sm44r6c[RRUSS9nS[R"[R "UR 555-nX#4$)axCompute Cholesky decomposition and determine (log(det(scale)). Parameters ---------- scale : ndarray Scale matrix. Returns ------- c_decomp : ndarray The Cholesky decomposition of `scale`. logdet : scalar The log of the determinant of `scale`. Notes ----- This computation of ``logdet`` is equivalent to ``np.linalg.slogdet(scale)``. It is ~2x faster though. Trwr-)rYrZrzr?rerfr)rirc_decomplogdets r4rwishart_gen._cholesky_logdet sK*<<((d(;RVVBFF8#4#4#6788r6r.rzNNNrI)rrrrrrprrrrrrrrrrrr rr4r:rrr#rrrrs@r4rrYsym^N/8#J ,\$:1,"$ *@&*$ 2h+Z$> 85*  r6rcP\rSrSrSrS SjrSrSrSrSr S r SS jr S r S r g)ri a Create a frozen Wishart distribution. Parameters ---------- df : array_like Degrees of freedom of the distribution scale : array_like Scale matrix of the distribution 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. Nc[U5UlURRX5uUlUlUlURR UR 5uUlUlgrz) rrrrrrrrrrs r4rpwishart_frozen.__init__ sT & (, (F(F )%$'4:%)ZZ%@%@%L""r6cURRXR5nURRXRURUR UR UR5n[U5$rz) rrrrrrrrr5rirOr3s r4rwishart_frozen.logpdf sZ JJ ) )!XX 6jj  HHdggtzz!%!3!3TVV=s##r6cL[R"URU55$rzr<r=s r4rwishart_frozen.pdf r?r6cURRURURUR5n[ U5$rzrrrrrr5rir3s r4rwishart_frozen.mean 1jjtxx$**=s##r6cURRURURUR5nUb [ U5$U$rzrrrrrr5rVs r4rwishart_frozen.mode :jjtxx$**='*s#?C?r6cURRURURUR5n[ U5$rzrr rrrr5rVs r4rwishart_frozen.var s/jjoodhh<s##r6cURRU5up4URRX4URURUR U5n[ U5$rzrrr:rrrr5rirrrrr3s r4rwishart_frozen.rvs sL::++D1jjooa$''"ffl4s##r6cxURRURURUR5$rzrrrrrr}s r4r#wishart_frozen.entropy )zz""488TWWd6H6HIIr6rrrrrrrzrI)rrrrrrprrrrrrr#rr/r6r4rr s2"M $&$@$$ Jr6r)rrrrrrr#c^\rSrSrSrSU4SjjrSSjrSrSrSr Sr S r S r S r S rS rSrSrSSjrSrSrSrU=r$)invwishart_geni a An inverse Wishart random variable. The `df` keyword specifies the degrees of freedom. The `scale` keyword specifies the scale matrix, which must be symmetric and positive definite. In this context, the scale matrix is often interpreted in terms of a multivariate normal covariance matrix. Methods ------- pdf(x, df, scale) Probability density function. logpdf(x, df, scale) Log of the probability density function. rvs(df, scale, size=1, random_state=None) Draw random samples from an inverse Wishart distribution. entropy(df, scale) Differential entropy of the distribution. Parameters ---------- %(_doc_default_callparams)s %(_doc_random_state)s Raises ------ scipy.linalg.LinAlgError If the scale matrix `scale` is not positive definite. See Also -------- wishart Notes ----- %(_doc_callparams_note)s The scale matrix `scale` must be a symmetric positive definite matrix. Singular matrices, including the symmetric positive semi-definite case, are not supported. Symmetry is not checked; only the lower triangular portion is used. The inverse Wishart distribution is often denoted .. math:: W_p^{-1}(\nu, \Psi) where :math:`\nu` is the degrees of freedom and :math:`\Psi` is the :math:`p \times p` scale matrix. The probability density function for `invwishart` has support over positive definite matrices :math:`S`; if :math:`S \sim W^{-1}_p(\nu, \Sigma)`, then its PDF is given by: .. math:: f(S) = \frac{|\Sigma|^\frac{\nu}{2}}{2^{ \frac{\nu p}{2} } |S|^{\frac{\nu + p + 1}{2}} \Gamma_p \left(\frac{\nu}{2} \right)} \exp\left( -tr(\Sigma S^{-1}) / 2 \right) If :math:`S \sim W_p^{-1}(\nu, \Psi)` (inverse Wishart) then :math:`S^{-1} \sim W_p(\nu, \Psi^{-1})` (Wishart). If the scale matrix is 1-dimensional and equal to one, then the inverse Wishart distribution :math:`W_1(\nu, 1)` collapses to the inverse Gamma distribution with parameters shape = :math:`\frac{\nu}{2}` and scale = :math:`\frac{1}{2}`. Instead of inverting a randomly generated Wishart matrix as described in [2], here the algorithm in [4] is used to directly generate a random inverse-Wishart matrix without inversion. .. versionadded:: 0.16.0 References ---------- .. [1] M.L. Eaton, "Multivariate Statistics: A Vector Space Approach", Wiley, 1983. .. [2] M.C. Jones, "Generating Inverse Wishart Matrices", Communications in Statistics - Simulation and Computation, vol. 14.2, pp.511-514, 1985. .. [3] Gupta, M. and Srivastava, S. "Parametric Bayesian Estimation of Differential Entropy and Relative Entropy". Entropy 12, 818 - 843. 2010. .. [4] S.D. Axen, "Efficiently generating inverse-Wishart matrices and their Cholesky factors", :arXiv:`2310.15884v1`. 2023. Examples -------- >>> import numpy as np >>> import matplotlib.pyplot as plt >>> from scipy.stats import invwishart, invgamma >>> x = np.linspace(0.01, 1, 100) >>> iw = invwishart.pdf(x, df=6, scale=1) >>> iw[:3] array([ 1.20546865e-15, 5.42497807e-06, 4.45813929e-03]) >>> ig = invgamma.pdf(x, 6/2., scale=1./2) >>> ig[:3] array([ 1.20546865e-15, 5.42497807e-06, 4.45813929e-03]) >>> plt.plot(x, iw) >>> plt.show() The input quantiles can be any shape of array, as long as the last axis labels the components. Alternatively, the object may be called (as a function) to fix the degrees of freedom and scale parameters, returning a "frozen" inverse Wishart random variable: >>> rv = invwishart(df=1, scale=1) >>> # Frozen object with the same methods but holding the given >>> # degrees of freedom and scale fixed. cx>[TU]U5 [R"UR[ 5Ulgrzrrs r4rpinvwishart_gen.__init__v rQr6c[XU5$)z^Create a frozen inverse Wishart distribution. See `invwishart_frozen` for more information. )invwishart_frozenrs r4rinvwishart_gen.__call__z s !D11r6c d[R"URS5n[R"URS5n[SU45nUS:am[ URS5HPn UR USS2SS2U 45uoU 'U"SXSSS9n [R RU 5S -Xy'MR O-[R"US 5USS&US S -US - USS&S U-U-S U-- S U-U-[-S X2-S--U--- [S U-U5- n U $) aLog of the inverse Wishart probability density function. Parameters ---------- x : ndarray Points at which to evaluate the log of the probability density function. dim : int Dimension of the scale matrix df : int Degrees of freedom log_det_scale : float Logarithm of the determinant of the scale matrix C : ndarray Cholesky factorization of the scale matrix, lower triangular. Notes ----- As this function does no argument checking, it should not be called directly; use 'logpdf' instead. r8trsmrNrrTsider>r-rrr") r?rrrrrrZrrfrr) rirOrrrrrtr_scale_x_invrqrCxr0r3s r4rinvwishart_gen._logpdf s80HHQWWR[) !''"+.v- 71772;'#'#8#81a7#D aLR$7$&IINN1$5q$8!( 66!D'?IaL !$ QtW 4N1 b=(3+??b3'#A*>*JJLCFC() r6cURX#5upBnURX5nURU5upVURXX&U5n[ U5$)aLog of the inverse Wishart probability density function. Parameters ---------- x : array_like Quantiles, with the last axis of `x` denoting the components. Each quantile must be a symmetric positive definite matrix. %(_doc_default_callparams)s Returns ------- pdf : ndarray Log of the probability density function evaluated at `x` Notes ----- %(_doc_callparams_note)s rrs r4rinvwishart_gen.logpdf sX(11"<  # #A +007ll12a8s##r6cN[R"URXU55$)ajInverse Wishart probability density function. Parameters ---------- x : array_like Quantiles, with the last axis of `x` denoting the components. Each quantile must be a symmetric positive definite matrix. %(_doc_default_callparams)s Returns ------- pdf : ndarray Probability density function evaluated at `x` Notes ----- %(_doc_callparams_note)s r<r s r4rinvwishart_gen.pdf r r6c2X!S-:a X2U- S- - nU$SnU$)zMean of the inverse Wishart distribution. Parameters ---------- dim : int Dimension of the scale matrix %(_doc_default_callparams)s Notes ----- As this function does no argument checking, it should not be called directly; use 'mean' instead. rNr/rs r4rinvwishart_gen._mean s0 a<8a<(C C r6cnURX5up1nURX1U5nUb [U5$U$)aMean of the inverse Wishart distribution. Only valid if the degrees of freedom are greater than the dimension of the scale matrix plus one. Parameters ---------- %(_doc_default_callparams)s Returns ------- mean : float or None The mean of the distribution rrs r4rinvwishart_gen.mean s< 11"<jj%('*s#?C?r6cX2U-S-- $)zMode of the inverse Wishart distribution. Parameters ---------- dim : int Dimension of the scale matrix %(_doc_default_callparams)s Notes ----- As this function does no argument checking, it should not be called directly; use 'mode' instead. rr/r s r4rinvwishart_gen._mode sS1 %%r6cdURX5up1nURX1U5n[U5$)zMode of the inverse Wishart distribution. Parameters ---------- %(_doc_default_callparams)s Returns ------- mode : float The Mode of the distribution rrs r4rinvwishart_gen.mode s311"<jj%(s##r6cX!S-:aZX!- S-US--nUR5nXBU- S- [R"XU5-- nXBU- X!- S- S--X!- S- --nU$SnU$)zVariance of the inverse Wishart distribution. Parameters ---------- dim : int Dimension of the scale matrix %(_doc_default_callparams)s Notes ----- As this function does no argument checking, it should not be called directly; use 'var' instead. rrr-Nrrs r4r invwishart_gen._var( s a<8a<5!8+C>>#D HqLBHHT$88 8C HA 11RX\B BC C r6cnURX5up1nURX1U5nUb [U5$U$)aVariance of the inverse Wishart distribution. Only valid if the degrees of freedom are greater than the dimension of the scale matrix plus three. Parameters ---------- %(_doc_default_callparams)s Returns ------- var : float The variance of the distribution r#rs r4rinvwishart_gen.var@ s<11"<ii''*s#?C?r6c([R"X#U4-5n[R"USS9upxX3S- -S-n UR/UQU P7S9USXx4'[R"U5n XC- S-U -n UR U /UQUP7S9S-USX4'U$) a Parameters ---------- n : integer Number of variates to generate shape : iterable Shape of the variates to generate dim : int Dimension of the scale matrix df : int Degrees of freedom random_state : {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. Returns ------- A : ndarray Random variates of shape (`shape`) + (``dim``, ``dim``). Each slice `A[..., :, :]` is lower-triangular, and its inverse is the lower Cholesky factor of a draw from `invwishart(df, np.eye(dim))`. Notes ----- As this function does no argument checking, it should not be called directly; use 'rvs' instead. r8r&rr-r.)rrr")r?rr+raranger)) rirrrrrr0tri_rowstri_colsr-rchi_dfss r4_inv_standard_rvs invwishart_gen._inv_standard_rvsS sH HHU3Z' ( __SB7A!#%1%8%8!5!&!&9& #x !" yy~8a<4')33]u]c]4 #t/r6c @URU5nURXX4U5n[SU45n[SU45n [R"UR SS5H8n US:aU"SXzUSSS9n U "SXSSSS 9Xz'M#US XzS - S -XzS 'M: U$) aDraw random samples from an inverse Wishart distribution. Parameters ---------- n : integer Number of variates to generate shape : iterable Shape of the variates to generate dim : int Dimension of the scale matrix df : int Degrees of freedom C : ndarray Cholesky factorization of the scale matrix, lower triangular. %(_doc_random_state)s Notes ----- As this function does no argument checking, it should not be called directly; use 'rvs' instead. rqtrmmNrcrrTrr)rsr>trans_artr-)rrrr?r7r) rirrrrrrr0rqrr8r9s r4r:invwishart_gen._rvs s.--l;  " "1Sl Cv-v-ZZ -EQw"ah>B$M"#D'AHTN":Q!>.r6cURU5upVURX5upqn[RR USS9nUR XVXqX5n [ U 5$)aDraw random samples from an inverse Wishart distribution. Parameters ---------- %(_doc_default_callparams)s size : integer or iterable of integers, optional Number of samples to draw (default 1). %(_doc_random_state)s Returns ------- rvs : ndarray Random variates of shape (`size`) + (``dim``, ``dim``), where ``dim`` is the dimension of the scale matrix. Notes ----- %(_doc_callparams_note)s Trwr=r>s r4rinvwishart_gen.rvs r@r6c"[SUS-5Vs/sH nSX!- U--PM nn[R"U5n[SU-U5SU-U--SUS--U[- --SX!-S--[ XUS9R 5-- $s snf)Nrr"r2)rr?rWrrrre)rirrrrpsi_eval_pointss r4rinvwishart_gen._entropy s9>q#'9JK9JA3"(Q,/9JK**_5C"Hc*S3Y^; 37O}v5 67 28a<  5 9 9 ; << <LsB ctURX5up1nURU5upEURX1U5$rzrDrEs r4r#invwishart_gen.entropy s:11"<007}}Sm44r6r.rzrKrI)rrrrrrprrrrrrrrr rrr:rrr#rrrs@r4rjrj seqfN2)V$41,*@(&"$"0@&4l)V$><55r6rjcL\rSrSrS SjrSrSrSrSrSr S S jr S r S r g)rni Ncn[U5UlURRX5uUlUlUl[ RRUR SS9Ul S[R"[R"URR555-Ulg)aCreate a frozen inverse Wishart distribution. Parameters ---------- df : array_like Degrees of freedom of the distribution scale : array_like Scale matrix of the distribution seed : {None, int, `numpy.random.Generator`}, optional If `seed` is None the `numpy.random.Generator` singleton is used. If `seed` is an int, a new ``Generator`` instance is used, seeded with `seed`. If `seed` is already a ``Generator`` instance then that instance is used. Trwr-N)rjrrrrrrYrZrzrr?rerfrrrs r4rpinvwishart_frozen.__init__ s"$D) (, (F(F ) %$'4: &&tzz&>tvv/@(A!BBr6cURRXR5nURRXRURUR UR 5n[U5$rz)rrrrrrrr5rPs r4rinvwishart_frozen.logpdf sT JJ ) )!XX 6jj  HHdgg!%!3!3TVV=s##r6cL[R"URU55$rzr<r=s r4rinvwishart_frozen.pdf r?r6cURRURURUR5nUb [ U5$U$rzrUrVs r4rinvwishart_frozen.mean r\r6cURRURURUR5n[ U5$rzrZrVs r4rinvwishart_frozen.mode rXr6cURRURURUR5nUb [ U5$U$rzr^rVs r4rinvwishart_frozen.var s8jjoodhh<'*s#?C?r6cURRU5up4URRX4URURUR U5n[ U5$rzrarbs r4rinvwishart_frozen.rvs sN::++D1jjooa$''"ffl4s##r6cxURRURURUR5$rzrer}s r4r#invwishart_frozen.entropy rgr6rhrzrI) rrrrrprrrrrrr#rr/r6r4rnrn s.C4$ &@$@$Jr6rn)rrrrrrzsn : int Number of trials p : array_like Probability of a trial falling into each category; should sum to 1 a`n` should be a nonnegative integer. Each element of `p` should be in the interval :math:`[0,1]` and the elements should sum to 1. If they do not sum to 1, the last element of the `p` array is not used and is replaced with the remaining probability left over from the earlier elements. c~^\rSrSrSrSU4SjjrSSjrSSjrSrSr Sr S r S r S r S rS rSSjrSrU=r$)multinomial_geniJ a A multinomial random variable. Methods ------- pmf(x, n, p) Probability mass function. logpmf(x, n, p) Log of the probability mass function. rvs(n, p, size=1, random_state=None) Draw random samples from a multinomial distribution. entropy(n, p) Compute the entropy of the multinomial distribution. cov(n, p) Compute the covariance matrix of the multinomial distribution. Parameters ---------- %(_doc_default_callparams)s %(_doc_random_state)s Notes ----- %(_doc_callparams_note)s The probability mass function for `multinomial` is .. math:: f(x) = \frac{n!}{x_1! \cdots x_k!} p_1^{x_1} \cdots p_k^{x_k}, supported on :math:`x=(x_1, \ldots, x_k)` where each :math:`x_i` is a nonnegative integer and their sum is :math:`n`. .. versionadded:: 0.19.0 Examples -------- >>> from scipy.stats import multinomial >>> rv = multinomial(8, [0.3, 0.2, 0.5]) >>> rv.pmf([1, 3, 4]) 0.042000000000000072 The multinomial distribution for :math:`k=2` is identical to the corresponding binomial distribution (tiny numerical differences notwithstanding): >>> from scipy.stats import binom >>> multinomial.pmf([3, 4], n=7, p=[0.4, 0.6]) 0.29030399999999973 >>> binom.pmf(3, 7, 0.4) 0.29030400000000012 The functions ``pmf``, ``logpmf``, ``entropy``, and ``cov`` support broadcasting, under the convention that the vector parameters (``x`` and ``p``) are interpreted as if each row along the last axis is a single object. For instance: >>> multinomial.pmf([[3, 4], [3, 5]], n=[7, 8], p=[.3, .7]) array([0.2268945, 0.25412184]) Here, ``x.shape == (2, 2)``, ``n.shape == (2,)``, and ``p.shape == (2,)``, but following the rules mentioned above they behave as if the rows ``[3, 4]`` and ``[3, 5]`` in ``x`` and ``[.3, .7]`` in ``p`` were a single object, and as if we had ``x.shape = (2,)``, ``n.shape = (2,)``, and ``p.shape = ()``. To obtain the individual elements without broadcasting, we would do this: >>> multinomial.pmf([3, 4], n=7, p=[.3, .7]) 0.2268945 >>> multinomial.pmf([3, 5], 8, p=[.3, .7]) 0.25412184 This broadcasting also works for ``cov``, where the output objects are square matrices of size ``p.shape[-1]``. For example: >>> multinomial.cov([4, 5], [[.3, .7], [.4, .6]]) array([[[ 0.84, -0.84], [-0.84, 0.84]], [[ 1.2 , -1.2 ], [-1.2 , 1.2 ]]]) In this example, ``n.shape == (2,)`` and ``p.shape == (2, 2)``, and following the rules above, these broadcast as if ``p.shape == (2,)``. Thus the result should also be of shape ``(2,)``, but since each output is a :math:`2 \times 2` matrix, the result in fact has shape ``(2, 2, 2)``, where ``result[0]`` is equal to ``multinomial.cov(n=4, p=[.3, .7])`` and ``result[1]`` is equal to ``multinomial.cov(n=5, p=[.4, .6])``. Alternatively, the object may be called (as a function) to fix the `n` and `p` parameters, returning a "frozen" multinomial random variable: >>> rv = multinomial(n=7, p=[.3, .7]) >>> # Frozen object with the same methods but holding the given >>> # degrees of freedom and scale fixed. See also -------- scipy.stats.binom : The binomial distribution. numpy.random.Generator.multinomial : Sampling from the multinomial distribution. scipy.stats.multivariate_hypergeom : The multivariate hypergeometric distribution. cx>[TU]U5 [R"UR[ 5Ulgrz)rrprrrmultinomial_docdict_paramsrs r4rpmultinomial_gen.__init__ s,    T\\+E F r6c[XU5$)zZCreate a frozen multinomial distribution. See `multinomial_frozen` for more information. )multinomial_frozen)rirrrs r4rmultinomial_gen.__call__ s "!--r6cn[R"U[RSS9nSUSSS24RSS9- n[R"U5U:nXEX%S4'[R "US:SS9nU[R "US :SS9-n[R"U[ SS9nUS:nXXv-4$) zReturns: n_, p_, npcond. n_ and p_ are arrays of the correct shape; npcond is a boolean array flagging values out of the domain. Tr<rr.Nr8rsrr)r?rLfloat64rerCrry)rirrrA p_adjusted i_adjustedpcondnconds r4r#multinomial_gen._process_parameters s HHQbjjt 4!C"H+//r/22 VVJ'#- &2b.q1u2& AB'' HHQc -AU]""r6c[R"U[S9nURS:Xa [ S5eUR S:waJUR SUR S:Xd*[ SUR SUR S4-5e[R"XA:gSS9nU[R"US:SS9-nU[R"USS9U:g-nXE4$)zeReturns: x_, xcond. x_ is an int array; xcond is a boolean array flagging values out of the domain. rKrzx must be an array.r8zHSize of each quantile should be size of p: received %d, but expected %d.rs) r?rWryr1r]rrrre)rirOrrxxrEs r4r"multinomial_gen._process_quantiles s ZZ % 77a<23 3 77a<  ;= hhrlAGGBK89: : vvbgB' rAvB''rvvbr*a/0xr6c[R"U5nURS:waX1U'U$U(aURS:XaU$X1S'U$)Nr.r?rWr1riresultrE bad_values r4 _checkresultmultinomial_gen._checkresult sLF# 99>$4L  {{a  #3K r6cz[US-5[R"[X5[US-5- SS9-$)Nrr8rs)rr?rerrirOrrs r4_logpmfmultinomial_gen._logpmf s1qs|bffU1[71Q3<%?bIIIr6cURX#5up#nURXU5upURXU5nU[R"UR [R S9-nURXg[R*5nU[R"UR [R S9-nURXh[R5$)aBLog of the Multinomial probability mass function. Parameters ---------- x : array_like Quantiles, with the last axis of `x` denoting the components. %(_doc_default_callparams)s Returns ------- logpmf : ndarray or scalar Log of the probability mass function evaluated at `x` Notes ----- %(_doc_callparams_note)s rK) rrrr?rrbool_rrnan) rirOrrnpcondxcondrxcond_npcond_s r4logpmfmultinomial_gen.logpmf s$//5 f**13aA&&,,bhh??""6BFF7;288EKKrxx@@  "&&99r6cN[R"URXU55$)a,Multinomial probability mass function. Parameters ---------- x : array_like Quantiles, with the last axis of `x` denoting the components. %(_doc_default_callparams)s Returns ------- pmf : ndarray or scalar Probability density function evaluated at `x` Notes ----- %(_doc_callparams_note)s r?rrrs r4pmfmultinomial_gen.pmf s$vvdkk!*++r6cURX5upnUS[R4U-nURXC[R5$)zMean of the Multinomial distribution. Parameters ---------- %(_doc_default_callparams)s Returns ------- mean : float The mean of the distribution .)rr?rrr)rirrrrs r4rmultinomial_gen.mean. sF//5 f3 ?#A%  88r6cTURX5upnUS[R[R4nU[R"SU*U5-n[ UR S5HnUSXf4==XSU4-- ss'M UR XS[R5$)zCovariance matrix of the multinomial distribution. Parameters ---------- %(_doc_default_callparams)s Returns ------- cov : ndarray The covariance matrix of the distribution .z...j,...k->...jkr8)rr?rr}rrrr)rirrrnnrrs r4rmultinomial_gen.cov> s//5 f sBJJ * +bii 2QB::qwwr{#A 39 S!V9 , $  88r6c^URX5upn[RS[R"U5S-nU[R"[ U5SS9-nU[ US-5-nUS[R4n[URUR5UR- S-nU=RSU-- sl [R"[R"XAU5[ US-5-SSU- 4S9nURXW-U[R5$)aCompute the entropy of the multinomial distribution. The entropy is computed using this expression: .. math:: f(x) = - \log n! - n\sum_{i=1}^k p_i \log p_i + \sum_{i=1}^k \sum_{x=0}^n \binom n x p_i^x(1-p_i)^{n-x} \log x! Parameters ---------- %(_doc_default_callparams)s Returns ------- h : scalar Entropy of the Multinomial distribution Notes ----- %(_doc_callparams_note)s rr8rs.)r)rr?r(rBrerrrr1rrrrr)rirrrrOterm1new_axes_neededterm2s r4r#multinomial_gen.entropyU s.//5 f EE!BFF1IaK "&&ar** 1 c2::o affaff-6: 4''uyyq)'!A#,6O!346  ??r6cpURX5upnURU5nURXU5$)aYDraw random samples from a Multinomial distribution. Parameters ---------- %(_doc_default_callparams)s size : integer or iterable of integers, optional Number of samples to draw (default 1). %(_doc_random_state)s Returns ------- rvs : ndarray or scalar Random variates of shape (`size`, `len(p)`) Notes ----- %(_doc_callparams_note)s )rrr")rirrrrrs r4rmultinomial_gen.rvs| s;&//5 f--l; ''d33r6r.rz)gV瞯TRTRTR4$rz)rrr)rrris r4r8multinomial_frozen.__init__.._process_parameters s664664;;. .r6)rrrrrr)rirrrrs` r4rpmultinomial_frozen.__init__ sC$T* &*jj&D&DQ&J#  /*= &r6cbURRXRUR5$rz)rrrrr=s r4rmultinomial_frozen.logpmf !zz  FFDFF33r6cbURRXRUR5$rz)rrrrr=s r4rmultinomial_frozen.pmf zz~~a00r6cbURRURUR5$rz)rrrrr}s r4rmultinomial_frozen.mean zztvvtvv..r6cbURRURUR5$rz)rrrrr}s r4rmultinomial_frozen.cov zz~~dffdff--r6cbURRURUR5$rz)rr#rrr}s r4r#multinomial_frozen.entropy s!zz!!$&&$&&11r6cdURRURURX5$rz)rrrrrEs r4rmultinomial_frozen.rvs s!zz~~dffdffdAAr6)rrrrrzrI) rrrrrrprrrrr#rrr/r6r4rr s+ =41/.2Br6r)rrrrrcJ^\rSrSrSrSU4SjjrS SjrSrS SjrSr U=r $) special_ortho_group_geni aA Special Orthogonal matrix (SO(N)) random variable. Return a random rotation matrix, drawn from the Haar distribution (the only uniform distribution on SO(N)) with a determinant of +1. The `dim` keyword specifies the dimension N. Methods ------- rvs(dim=None, size=1, random_state=None) Draw random samples from SO(N). Parameters ---------- dim : scalar Dimension of matrices seed : {None, int, np.random.RandomState, np.random.Generator}, optional Used for drawing random variates. If `seed` is `None`, the `~np.random.RandomState` singleton is used. If `seed` is an int, a new ``RandomState`` instance is used, seeded with seed. If `seed` is already a ``RandomState`` or ``Generator`` instance, then that object is used. Default is `None`. Notes ----- This class is wrapping the random_rot code from the MDP Toolkit, https://github.com/mdp-toolkit/mdp-toolkit Return a random rotation matrix, drawn from the Haar distribution (the only uniform distribution on SO(N)). The algorithm is described in the paper Stewart, G.W., "The efficient generation of random orthogonal matrices with an application to condition estimators", SIAM Journal on Numerical Analysis, 17(3), pp. 403-409, 1980. For more information see https://en.wikipedia.org/wiki/Orthogonal_matrix#Randomization See also the similar `ortho_group`. For a random rotation in three dimensions, see `scipy.spatial.transform.Rotation.random`. Examples -------- >>> import numpy as np >>> from scipy.stats import special_ortho_group >>> x = special_ortho_group.rvs(3) >>> np.dot(x, x.T) array([[ 1.00000000e+00, 1.13231364e-17, -2.86852790e-16], [ 1.13231364e-17, 1.00000000e+00, -1.46845020e-16], [ -2.86852790e-16, -1.46845020e-16, 1.00000000e+00]]) >>> import scipy.linalg >>> scipy.linalg.det(x) 1.0 This generates one random matrix from SO(3). It is orthogonal and has a determinant of 1. Alternatively, the object may be called (as a function) to fix the `dim` parameter, returning a "frozen" special_ortho_group random variable: >>> rv = special_ortho_group(5) >>> # Frozen object with the same methods but holding the >>> # dimension parameter fixed. See Also -------- ortho_group, scipy.spatial.transform.Rotation.random cn>[TU]U5 [R"UR5Ulgrzrrprrrrs r4rp special_ortho_group_gen.__init__& '' 5 r6c[XS9$)z\Create a frozen SO(N) distribution. See `special_ortho_group_frozen` for more information. rS)special_ortho_group_frozenrirrs r4r special_ortho_group_gen.__call__s *#99r6cUb0[R"U5(aUS::dU[U5:wa [S5eU$)5Dimension N must be specified; it cannot be inferred.rzmDimension of rotation must be specified, and must be a scalar greater than 1.r?rryr]rirs r4r+special_ortho_group_gen._process_parameters%sA ;bkk#..#(cSXoHI I r6c URU5n[U5nUS:aU4OSnURU5n[R"X!U4-5n[R "U5USSS2SS24'[R"X!4-5n[ US- 5GH%nURX!U- 4-S9nUSSSS24nUSSS2S4n [R"X5RS5n USR5n [R"U S:g[R"U 5S5USU4'US==USU4[R"U 5-- ss'U[R"XS -- USS --S - 5S -nUSSS2US24==[R"USSS2US24U 5U--ss'GM( S US- -USSS 24RS S 9-US'XESSS2S4-nU$)aDraw random samples from SO(N). Parameters ---------- dim : integer Dimension of rotation space (N). size : integer, optional Number of samples to draw (default 1). Returns ------- rvs : ndarray or scalar Random size N-dimensional matrices, dimension (size, dim, dim) rr/.Nr)rcr8.rrr-@.Nr8rs).r8)rryrr?rrrrmatmulr0rwheresignrar) rirrrHDrrOxrowxcolnorm2x0s r4rspecial_ortho_group_gen.rvs-s --l; 4y(w&&s+ HHT#J& 'vvc{#q!) HHTF] #s1uA ##Q#9AS$\?DS!T\?D IId)11(;E6!Bq"''"+q9Ac1fI fI362775>1 1I %a%-!F)Q,6"<=iH HA c1abjMRYYqa}d;dB BM36CE]1S#2#X;#3#3#3#<<' sAt|_r6r.rzr2rI rrrrrrprrrrrrs@r4rr s%GR6:AAr6rc(\rSrSrSSjrSSjrSrg)ritNcd[U5UlURRU5Ulg)aDCreate a frozen SO(N) distribution. Parameters ---------- dim : scalar Dimension of matrices 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. Examples -------- >>> from scipy.stats import special_ortho_group >>> g = special_ortho_group(5) >>> x = g.rvs() N)rrrrrs r4rp#special_ortho_group_frozen.__init__us&,-T2 ::11#6r6cNURRURX5$rzrrrrEs r4rspecial_ortho_group_frozen.rvszz~~dhh;;r6rrr2rIrrrrrprrr/r6r4rrt 72>> import numpy as np >>> from scipy.stats import ortho_group >>> x = ortho_group.rvs(3) >>> np.dot(x, x.T) array([[ 1.00000000e+00, 1.13231364e-17, -2.86852790e-16], [ 1.13231364e-17, 1.00000000e+00, -1.46845020e-16], [ -2.86852790e-16, -1.46845020e-16, 1.00000000e+00]]) >>> import scipy.linalg >>> np.fabs(scipy.linalg.det(x)) 1.0 This generates one random matrix from O(3). It is orthogonal and has a determinant of +1 or -1. Alternatively, the object may be called (as a function) to fix the `dim` parameter, returning a "frozen" ortho_group random variable: >>> rv = ortho_group(5) >>> # Frozen object with the same methods but holding the >>> # dimension parameter fixed. See Also -------- special_ortho_group cn>[TU]U5 [R"UR5Ulgrzrrs r4rportho_group_gen.__init__rr6c[XS9$)zSCreate a frozen O(N) distribution. See `ortho_group_frozen` for more information. rS)ortho_group_frozenrs r4rortho_group_gen.__call__s "#11r6cUb0[R"U5(aUS::dU[U5:wa [S5eU$rrzLDimension of rotation must be specified,and must be a scalar greater than 1.rrs r4r#ortho_group_gen._process_parametersA ;bkk#..#(cSXoDE E r6cLURU5n[U5nURU5nUS:aU4OSnURX!U4-S9n[R R U5upVURSSSS9nXW[U5- S[RS S 24-nU$) aDraw random samples from O(N). Parameters ---------- dim : integer Dimension of rotation space (N). size : integer, optional Number of samples to draw (default 1). Returns ------- rvs : ndarray or scalar Random size N-dimensional matrices, dimension (size, dim, dim) rr/rrrcr8offsetaxis1axis2.N) rryrrr?rZqrrrCrrirrrzqrr;s r4rortho_group_gen.rvss --l; 4y&&s+(w   T#J%6  7yy||A JJarJ 4 AhRZZ* ++r6r.rzr2rIrrs@r4r r s#@D62r6r c(\rSrSrSSjrSSjrSrg)r$i Ncd[U5UlURRU5Ulg)a3Create a frozen O(N) distribution. Parameters ---------- dim : scalar Dimension of matrices 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. Examples -------- >>> from scipy.stats import ortho_group >>> g = ortho_group(5) >>> x = g.rvs() N)r rrrrs r4rportho_group_frozen.__init__s&,%T* ::11#6r6cNURRURX5$rzrrEs r4rortho_group_frozen.rvs'rr6rr2rIrr/r6r4r$r$ rr6r$cV^\rSrSrSrS U4SjjrS SjrSrSrSr S Sjr S r U=r $) random_correlation_geni+aA random correlation matrix. Return a random correlation matrix, given a vector of eigenvalues. The `eigs` keyword specifies the eigenvalues of the correlation matrix, and implies the dimension. Methods ------- rvs(eigs=None, random_state=None) Draw random correlation matrices, all with eigenvalues eigs. Parameters ---------- eigs : 1d ndarray Eigenvalues of correlation matrix 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. tol : float, optional Tolerance for input parameter checks diag_tol : float, optional Tolerance for deviation of the diagonal of the resulting matrix. Default: 1e-7 Raises ------ RuntimeError Floating point error prevented generating a valid correlation matrix. Returns ------- rvs : ndarray or scalar Random size N-dimensional matrices, dimension (size, dim, dim), each having eigenvalues eigs. Notes ----- Generates a random correlation matrix following a numerically stable algorithm spelled out by Davies & Higham. This algorithm uses a single O(N) similarity transformation to construct a symmetric positive semi-definite matrix, and applies a series of Givens rotations to scale it to have ones on the diagonal. References ---------- .. [1] Davies, Philip I; Higham, Nicholas J; "Numerically stable generation of correlation matrices and their factors", BIT 2000, Vol. 40, No. 4, pp. 640 651 Examples -------- >>> import numpy as np >>> from scipy.stats import random_correlation >>> rng = np.random.default_rng() >>> x = random_correlation.rvs((.5, .8, 1.2, 1.5), random_state=rng) >>> x array([[ 1. , -0.02423399, 0.03130519, 0.4946965 ], [-0.02423399, 1. , 0.20334736, 0.04039817], [ 0.03130519, 0.20334736, 1. , 0.02694275], [ 0.4946965 , 0.04039817, 0.02694275, 1. ]]) >>> import scipy.linalg >>> e, v = scipy.linalg.eigh(x) >>> e array([ 0.5, 0.8, 1.2, 1.5]) cn>[TU]U5 [R"UR5Ulgrzrrs r4rprandom_correlation_gen.__init__wrr6c[XUUS9$)zbCreate a frozen random correlation matrix. See `random_correlation_frozen` for more information. )rtoldiag_tol)random_correlation_frozen)rieigsrr?r@s r4rrandom_correlation_gen.__call__{s )c2:< TZZ]c1SAX/0 0 77266$<#% & ,LM MA4x !HIIyr6c US- nUS- nUS:Xag[R"[US-XE-- S55nU[R"Xc5-U- nS[R"SXw--5- nUS:XaSn X4$X-n X4$)aComputes a 2x2 Givens matrix to put 1's on the diagonal. The input matrix is a 2x2 symmetric matrix M = [ aii aij ; aij ajj ]. The output matrix g is a 2x2 anti-symmetric matrix of the form [ c s ; -s c ]; the elements c and s are returned. Applying the output matrix to the input matrix (as b=g.T M g) results in a matrix with bii=1, provided tr(M) - det(M) >= 1 and floating point issues do not occur. Otherwise, some other valid rotation is returned. When tr(M)==2, also bjj=1. rr)rrr-)mathrarBcopysign) riaiiajjaijaiidajjdddrGcrls r4 _givens_to_1#random_correlation_gen._givens_to_1sRxRx 19 YYs36DI-q1 24==) )T 1 28$ $ 6At At r6czURR(a>UR[R:Xa UR SUR S:Xd [ 5eUR Sn[US- 5HnXU4S:XaMXU4S:a#[US-U5HnXU4S:dM O% O"[US-U5HnXU4S:dM O URXU4UWU4XU45upVUR5n[XwXV*UX2-SXB-SSSS9 [XwXV*UX2XBSSS9 M U$)z Given a psd matrix m, rotate to put one's on the diagonal, turning it into a correlation matrix. This also requires the trace equal the dimensionality. Note: modifies input matrix rrT)roffxincxoffyincy overwrite_x overwrite_y) flags c_contiguousr<r?rrr]rrQravelr)rimr;rjrPrlmvs r4_to_corrrandom_correlation_gen._to_corrsD$$BJJ)> aggaj(,  GGAJqsAAw!|a41qsAAAw{'qsAAAw{'$$Q!tWa1gqAw?DAB B!c!!t 5 B!a!t 5/6r6cURXS9upQURU5n[RXRS9n[R "[R "U[R "U55UR5nURU5n[UR5S- 5R5U:a [S5eU$)aDraw random correlation matrices. Parameters ---------- eigs : 1d ndarray Eigenvalues of correlation matrix tol : float, optional Tolerance for input parameter checks diag_tol : float, optional Tolerance for deviation of the diagonal of the resulting matrix. Default: 1e-7 Raises ------ RuntimeError Floating point error prevented generating a valid correlation matrix. Returns ------- rvs : ndarray or scalar Random size N-dimensional matrices, dimension (size, dim, dim), each having eigenvalues eigs. r?)rrz-Failed to generate a valid correlation matrix) rrr$rr?r{rr|r`rCrrB RuntimeError)rirBrr?r@rr]s r4rrandom_correlation_gen.rvss4,,T,; --l; OOCO ; FF266!RWWT]+QSS 1 MM!  qzz|a $ $ & 1NO Or6r.rzNgvIh%<=gHz>) rrrrrrprrrQr`rrrrs@r4r;r;+s/IV6<"B'R&&r6r;c(\rSrSrSSjrSSjrSrg)rAi Nc[U5UlX0lX@lURR XRS9uoPlg)aCreate a frozen random correlation matrix distribution. Parameters ---------- eigs : 1d ndarray Eigenvalues of correlation matrix 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. tol : float, optional Tolerance for input parameter checks diag_tol : float, optional Tolerance for deviation of the diagonal of the resulting matrix. Default: 1e-7 Raises ------ RuntimeError Floating point error prevented generating a valid correlation matrix. Returns ------- rvs : ndarray or scalar Random size N-dimensional matrices, dimension (size, dim, dim), each having eigenvalues eigs. rcN)r;rr?r@rrB)rirBrr?r@rs r4rp"random_correlation_frozen.__init__ s:B,D1  zz55d5I 9r6cvURRURUURURS9$)N)rr?r@)rrrBr?r@rs r4rrandom_correlation_frozen.rvs1s3zz~~diil"&((T]]D Dr6)rr@rBr?rfrzrr/r6r4rArA s$JLDr6rAcJ^\rSrSrSrSU4SjjrS SjrSrS SjrSr U=r $) unitary_group_geni6aA matrix-valued U(N) random variable. Return a random unitary matrix. The `dim` keyword specifies the dimension N. Methods ------- rvs(dim=None, size=1, random_state=None) Draw random samples from U(N). Parameters ---------- dim : scalar Dimension of matrices, must be greater than 1. seed : {None, int, np.random.RandomState, np.random.Generator}, optional Used for drawing random variates. If `seed` is `None`, the `~np.random.RandomState` singleton is used. If `seed` is an int, a new ``RandomState`` instance is used, seeded with seed. If `seed` is already a ``RandomState`` or ``Generator`` instance, then that object is used. Default is `None`. Notes ----- This class is similar to `ortho_group`. References ---------- .. [1] F. Mezzadri, "How to generate random matrices from the classical compact groups", :arXiv:`math-ph/0609050v2`. Examples -------- >>> import numpy as np >>> from scipy.stats import unitary_group >>> x = unitary_group.rvs(3) >>> np.dot(x, x.conj().T) array([[ 1.00000000e+00, 1.13231364e-17, -2.86852790e-16], [ 1.13231364e-17, 1.00000000e+00, -1.46845020e-16], [ -2.86852790e-16, -1.46845020e-16, 1.00000000e+00]]) # may vary This generates one random matrix from U(3). The dot product confirms that it is unitary up to machine precision. Alternatively, the object may be called (as a function) to fix the `dim` parameter, return a "frozen" unitary_group random variable: >>> rv = unitary_group(5) See Also -------- ortho_group cn>[TU]U5 [R"UR5Ulgrzrrs r4rpunitary_group_gen.__init__qrr6c[XS9$)ztCreate a frozen (U(N)) n-dimensional unitary matrix distribution. See `unitary_group_frozen` for more information. rS)unitary_group_frozenrs r4runitary_group_gen.__call__us $C33r6cUb0[R"U5(aUS::dU[U5:wa [S5eU$r'rrs r4r%unitary_group_gen._process_parameters|r)r6cURU5n[U5nURU5nUS:aU4OSnS[R"S5- UR X!U4-S9SUR X!U4-S9---n[ RRU5upVURSSSS 9nXW[U5- S [ RS S 24-nU$) aDraw random samples from U(N). Parameters ---------- dim : integer Dimension of space (N). size : integer, optional Number of samples to draw (default 1). Returns ------- rvs : ndarray or scalar Random size N-dimensional matrices, dimension (size, dim, dim) rr/r-ry?rrcr8r+.N) rryrrHrarr?rZr/rrCrr0s r4runitary_group_gen.rvss --l; 4y&&s+(w diilNL//T#J5F/G|22Sz8I2JJK Lyy||A JJarJ 4 AhRZZ* ++r6r.rzr2rIrrs@r4rmrm6s"8t64  r6rmc(\rSrSrSSjrSSjrSrg)rqiNcd[U5UlURRU5Ulg)aRCreate a frozen (U(N)) n-dimensional unitary matrix distribution. Parameters ---------- dim : scalar Dimension of matrices 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. Examples -------- >>> from scipy.stats import unitary_group >>> x = unitary_group(3) >>> x.rvs() N)rmrrrrs r4rpunitary_group_frozen.__init__s&,'t, ::11#6r6cNURRURX5$rzrrEs r4runitary_group_frozen.rvsrr6rr2rIrr/r6r4rqrqrr6rqaloc : array_like, optional Location of the distribution. (default ``0``) shape : array_like, optional Positive semidefinite matrix of the distribution. (default ``1``) df : float, optional Degrees of freedom of the distribution; must be greater than zero. If ``np.inf`` then results are multivariate normal. The default is ``1``. allow_singular : bool, optional Whether to allow a singular matrix. (default ``False``) aSetting the parameter `loc` to ``None`` is equivalent to having `loc` be the zero-vector. The parameter `shape` can be a scalar, in which case the shape matrix is the identity times that value, a vector of diagonal entries for the shape matrix, or a two-dimensional array_like. )_mvt_doc_default_callparams_mvt_doc_callparams_noterc^\rSrSrSrSU4SjjrSSjrSSjrSSjrSr SS jr SSSSS .S jjr SS jr SS jr SSjrSrSrSrU=r$)multivariate_t_genia A multivariate t-distributed random variable. The `loc` parameter specifies the location. The `shape` parameter specifies the positive semidefinite shape matrix. The `df` parameter specifies the degrees of freedom. In addition to calling the methods below, the object itself may be called as a function to fix the location, shape matrix, and degrees of freedom parameters, returning a "frozen" multivariate t-distribution random. Methods ------- pdf(x, loc=None, shape=1, df=1, allow_singular=False) Probability density function. logpdf(x, loc=None, shape=1, df=1, allow_singular=False) Log of the probability density function. cdf(x, loc=None, shape=1, df=1, allow_singular=False, *, maxpts=None, lower_limit=None, random_state=None) Cumulative distribution function. rvs(loc=None, shape=1, df=1, size=1, random_state=None) Draw random samples from a multivariate t-distribution. entropy(loc=None, shape=1, df=1) Differential entropy of a multivariate t-distribution. Parameters ---------- %(_mvt_doc_default_callparams)s %(_doc_random_state)s Notes ----- %(_mvt_doc_callparams_note)s The matrix `shape` must be a (symmetric) positive semidefinite matrix. The determinant and inverse of `shape` are computed as the pseudo-determinant and pseudo-inverse, respectively, so that `shape` does not need to have full rank. The probability density function for `multivariate_t` is .. math:: f(x) = \frac{\Gamma((\nu + p)/2)}{\Gamma(\nu/2)\nu^{p/2}\pi^{p/2}|\Sigma|^{1/2}} \left[1 + \frac{1}{\nu} (\mathbf{x} - \boldsymbol{\mu})^{\top} \boldsymbol{\Sigma}^{-1} (\mathbf{x} - \boldsymbol{\mu}) \right]^{-(\nu + p)/2}, where :math:`p` is the dimension of :math:`\mathbf{x}`, :math:`\boldsymbol{\mu}` is the :math:`p`-dimensional location, :math:`\boldsymbol{\Sigma}` the :math:`p \times p`-dimensional shape matrix, and :math:`\nu` is the degrees of freedom. .. versionadded:: 1.6.0 References ---------- .. [1] Arellano-Valle et al. "Shannon Entropy and Mutual Information for Multivariate Skew-Elliptical Distributions". Scandinavian Journal of Statistics. Vol. 40, issue 1. Examples -------- The object may be called (as a function) to fix the `loc`, `shape`, `df`, and `allow_singular` parameters, returning a "frozen" multivariate_t random variable: >>> import numpy as np >>> from scipy.stats import multivariate_t >>> rv = multivariate_t([1.0, -0.5], [[2.1, 0.3], [0.3, 1.5]], df=2) >>> # Frozen object with the same methods but holding the given location, >>> # scale, and degrees of freedom fixed. Create a contour plot of the PDF. >>> import matplotlib.pyplot as plt >>> x, y = np.mgrid[-1:3:.01, -2:1.5:.01] >>> pos = np.dstack((x, y)) >>> fig, ax = plt.subplots(1, 1) >>> ax.set_aspect('equal') >>> plt.contourf(x, y, rv.pdf(pos)) Nc>[TU]U5 [R"UR[ 5Ul[ U5Ulg)zfInitialize a multivariate t-distributed random variable. Parameters ---------- seed : Random state. N)rrprrrmvt_docdict_paramsr rrs r4rpmultivariate_t_gen.__init__>s8 '' 6HI /5r6cVU[R:Xa [XUUS9$[XUXES9$)zZCreate a frozen multivariate t-distribution. See `multivariate_t_frozen` for parameters. )rrrkr)locrrrkr)r?rrmultivariate_t_frozen)rirrrrkrs r4rmultivariate_t_gen.__call__Js< <-3=K379 9%b4BO Or6c URX#U5upbp4URX5n[X5S9nURXURUR UXgR 5n[R"U5$)aMultivariate t-distribution probability density function. Parameters ---------- x : array_like Points at which to evaluate the probability density function. %(_mvt_doc_default_callparams)s Returns ------- pdf : Probability density function evaluated at `x`. Examples -------- >>> from scipy.stats import multivariate_t >>> x = [0.4, 5] >>> loc = [0, 1] >>> shape = [[1, 0.1], [0.1, 1]] >>> df = 7 >>> multivariate_t.pdf(x, loc, shape, df) 0.00075713 r) rrrRrrdrgrcr?r) rirOrrrrkr shape_infors r4rmultivariate_t_gen.pdfWsj0#66s2F%  # #A +%? ajllJ4G4G!??4vvf~r6c URX#U5upRp4URX5n[U5nURXURUR XEUR 5$)a,Log of the multivariate t-distribution probability density function. Parameters ---------- x : array_like Points at which to evaluate the log of the probability density function. %(_mvt_doc_default_callparams)s Returns ------- logpdf : Log of the probability density function evaluated at `x`. Examples -------- >>> from scipy.stats import multivariate_t >>> x = [0.4, 5] >>> loc = [0, 1] >>> shape = [[1, 0.1], [0.1, 1]] >>> df = 7 >>> multivariate_t.logpdf(x, loc, shape, df) -7.1859802 See Also -------- pdf : Probability density function. )rrrRrrdrgrc)rirOrrrrrs r4rmultivariate_t_gen.logpdfvs^:#66s2F%  # #A +%[ ||AJLL*2E2Er&OO- -r6cU[R:Xa[RXX4U5$X- n[R"[R "X55R SS9n SXV--n [U 5n [SU-5n US- [R"U[R-5-n SU-nU *[R"SSU- U --5-n[X- U - U- U-5$)aUtility method `pdf`, `logpdf` for parameters. Parameters ---------- x : ndarray Points at which to evaluate the log of the probability density function. loc : ndarray Location of the distribution. prec_U : ndarray A decomposition such that `np.dot(prec_U, prec_U.T)` is the inverse of the shape matrix. log_pdet : float Logarithm of the determinant of the shape matrix. df : float Degrees of freedom of the distribution. dim : int Dimension of the quantiles x. rank : int Rank of the shape matrix. Notes ----- As this function does no argument checking, it should not be called directly; use 'logpdf' instead. r8rsr"rrr) r?rrrrr{rerrfpir5)rirOrprec_UrgrrrcrrrGr0BrrEs r4rmultivariate_t_gen._logpdfs8 <&..qvN Ngyy,-11r1: 28  AJ C"H  FRVVBJ' ' (N BRUdN*+ +quqy1}q011r6c R^^^^^Ub [U5mO URmT(dSU-mURX5nUc0[R"UR [R *5OUnX- Xr- pq[R"X5upX:n SU RSS9-n U R5U R5pXXsX'X'UR Sm[R"X4SS9n UUUUU4Sjn[R"USU 5U -n[U5$)Nir8rsc:>USTUTSp![TTTXT5S$rr)rr r rrrrngrs r4r'multivariate_t_gen._cdf..func1ds."1:vabzqUA#6q9 9r6) r rrr?rrrrrerrrr5)rirOrrrrrrrr r r r rrresrrs `` ` @@r4r multivariate_t_gen._cdfs  #$\2C$$CCZF  # #A +%-wwsyy266'23> +"3;""12vzzrz*+vvx1 y!) 19 GGBKR0 : :!!&"f5=s##r6rrrc zURX#U5upp4[X5S9RnURXX4XXx5$)a3Multivariate t-distribution cumulative distribution function. Parameters ---------- x : array_like Points at which to evaluate the cumulative distribution function. %(_mvt_doc_default_callparams)s maxpts : int, optional Maximum number of points to use for integration. The default is 1000 times the number of dimensions. lower_limit : array_like, optional Lower limit of integration of the cumulative distribution function. Default is negative infinity. Must be broadcastable with `x`. %(_doc_random_state)s Returns ------- cdf : ndarray or scalar Cumulative distribution function evaluated at `x`. Examples -------- >>> from scipy.stats import multivariate_t >>> x = [0.4, 5] >>> loc = [0, 1] >>> shape = [[1, 0.1], [0.1, 1]] >>> df = 7 >>> multivariate_t.cdf(x, loc, shape, df) 0.64798491 r)rrRrXr ) rirOrrrrkrrrrs r4rmultivariate_t_gen.cdfsFB#66s2F%U:==yyC$4 4r6c^U[R:Xa[SUS9R5$[ U5nSUR -mU4SjnU4SjnUS-S-[R "U5S-- n[X':X4XeS9$) N)rr"c>SX--nSU-n[U5*[U5-SU-[R"U[R-5--U[ U5[ U5- --T-$)Nr")rr?rfrr)rrhalfsumhalf_df shape_terms r4regular,multivariate_t_gen._entropy..regulars{SX&GBhG!!GG$44)bffR"%%Z0013:w<#g,.400 r6c >U[R"5-X- -XS- -US--S- - US-US- -US--S- -USUS--SUS---S- -US --S - -US-SUS--S US--- S --US --S- -T-S$)Nr-grg gr/)rr)rrrs r4 asymptotic/multivariate_t_gen._entropy..asymptotic#s dmmo%0q/BH,q01q&C!G$r4x/!34c1fq36z1A56TABFGq&AQJc1f4r9:RXEJ K    r6drr)r:f2)r?rrr#rRrgrfr) rirrrrrr thresholdrs @r4rmultivariate_t_gen._entropysz <&t7??A A%[ :...   #IMRVVC[1_5 "/C9 OOr6cPURSX#5upAp#URXCU5$)zCalculate the differential entropy of a multivariate t-distribution. Parameters ---------- %(_mvt_doc_default_callparams)s Returns ------- h : float Differential entropy Nrr)rirrrrs r4r#multivariate_t_gen.entropy4s,#66tUG%}}Se,,r6cURXU5upap#Ub [U5nO URn[R"U5(a[R "U5nOUR X4S9U- nUR[R"U5X$S9n X[R"U5S- -n [U 5$)a*Draw random samples from a multivariate t-distribution. Parameters ---------- %(_mvt_doc_default_callparams)s size : integer, optional Number of samples to draw (default 1). %(_doc_random_state)s Returns ------- rvs : ndarray or scalar Random variates of size (`size`, `P`), where `P` is the dimension of the random variable. Examples -------- >>> from scipy.stats import multivariate_t >>> x = [0.4, 5] >>> loc = [0, 1] >>> shape = [[1, 0.1], [0.1, 1]] >>> df = 7 >>> multivariate_t.rvs(loc, shape, df) array([[0.93477495, 3.00408716]]) rr ) rr rr?isinfonesr)rrrar5) rirrrrrrrrOr1sampless r4rmultivariate_t_gen.rvsEs@#66s2F%  #$\2C$$C 88B<< A b ,r1A  # #BHHSM5 # DBGGAJy111w''r6c[R"U[S9nURS:XaU[RnU$URS:Xa6US:XaUSS2[R4nU$U[RSS24nU$rrrs r4r%multivariate_t_gen._process_quantilestsy JJq & 66Q;"** A  VVq[axam$bjj!m$r6c@Uc8Uc5[R"S[S9n[R"S[S9nSnOUcR[R"U[S9nURS:aSnOURSn[R "U5nO}Uc<[R"U[S9nUR n[R"U5nO>[R"U[S9n[R"U[S9nUR nUS:Xa#URS5nURSS5nURS:wdURSU:wa[SU-5eURS:XaU[R"U5-nOURS:Xa[R"U5nOURS:XanURXD4:wa]URupVXV:waS[UR5S3nO%SnU[UR5[U54-n[U5eURS:a[S UR-5eUcSnO7US::a [S 5e[R"U5(a [S 5eXAX#4$) zo Infer dimensionality from location array and shape matrix, handle defaults, and ensure compatible dimensions. rrKrr-z*Array 'loc' must be a vector of length %d.rrzSDimension mismatch: array 'cov' is of shape %s, but 'loc' is a vector of length %d.rz'df' must be greater than zero.z8'df' is 'nan' but must be greater than zero or 'np.inf'.)r?rWrMr1rrrrrr]rrr^isnan)rirrrrrrrns r4r&multivariate_t_gen._process_parameterss0 ;5=**Qe,CJJq.EC [JJuE2EzzA~kk!n((3-C ]**S.C((CFF3KEJJuE2E**S.C((C !8++a.CMM!Q'E 88q=CIIaLC/I !" " ::?BFF3K'E ZZ1_GGENE ZZ1_ !:JD|++.u{{+;*S-s3x88S/ ! ZZ!^249JJ?@ @ :B 1W>? ? XXb\\WX X""r6)rrrzNrrFN)NrrFrrKrr)rrrrrrprrrrr rrr#rrrrrrs@r4rrssPd 6@E O>!-F)2VEI%$N%4T%4N PD-"-(^ :#:#r6rcP\rSrSrS SjrSrSSSS.SjrSrS SjrS r S r g) riNc[U5UlURRXU5upap#XaX#4uUlUlUlUl[X$S9Ulg)aCreate a frozen multivariate t distribution. Parameters ---------- %(_mvt_doc_default_callparams)s Examples -------- >>> import numpy as np >>> from scipy.stats import multivariate_t >>> loc = np.zeros(3) >>> shape = np.eye(3) >>> df = 10 >>> dist = multivariate_t(loc, shape, df) >>> dist.rvs() array([[ 0.81412036, -1.53612361, 0.42199647]]) >>> dist.pdf([1, 1, 1]) array([0.01237803]) rN) rrrrrrrrRr)rirrrrkrrs r4rpmultivariate_t_frozen.__init__sR,(- "jj<>> from scipy.stats import multivariate_hypergeom >>> multivariate_hypergeom.pmf(x=[8, 4], m=[10, 20], n=12) 0.0025207176631464523 The `multivariate_hypergeom` distribution is identical to the corresponding `hypergeom` distribution (tiny numerical differences notwithstanding) when only two types (good and bad) of objects are present in the population as in the example above. Consider another example for a comparison with the hypergeometric distribution: >>> from scipy.stats import hypergeom >>> multivariate_hypergeom.pmf(x=[3, 1], m=[10, 5], n=4) 0.4395604395604395 >>> hypergeom.pmf(k=3, M=15, n=4, N=10) 0.43956043956044005 The functions ``pmf``, ``logpmf``, ``mean``, ``var``, ``cov``, and ``rvs`` support broadcasting, under the convention that the vector parameters (``x``, ``m``, and ``n``) are interpreted as if each row along the last axis is a single object. For instance, we can combine the previous two calls to `multivariate_hypergeom` as >>> multivariate_hypergeom.pmf(x=[[8, 4], [3, 1]], m=[[10, 20], [10, 5]], ... n=[12, 4]) array([0.00252072, 0.43956044]) This broadcasting also works for ``cov``, where the output objects are square matrices of size ``m.shape[-1]``. For example: >>> multivariate_hypergeom.cov(m=[[7, 9], [10, 15]], n=[8, 12]) array([[[ 1.05, -1.05], [-1.05, 1.05]], [[ 1.56, -1.56], [-1.56, 1.56]]]) That is, ``result[0]`` is equal to ``multivariate_hypergeom.cov(m=[7, 9], n=8)`` and ``result[1]`` is equal to ``multivariate_hypergeom.cov(m=[10, 15], n=12)``. Alternatively, the object may be called (as a function) to fix the `m` and `n` parameters, returning a "frozen" multivariate hypergeometric random variable. >>> rv = multivariate_hypergeom(m=[10, 20], n=12) >>> rv.pmf(x=[8, 4]) 0.0025207176631464523 See Also -------- scipy.stats.hypergeom : The hypergeometric distribution. scipy.stats.multinomial : The multinomial distribution. References ---------- .. [1] The Multivariate Hypergeometric Distribution, http://www.randomservices.org/random/urn/MultiHypergeometric.html .. [2] Thomas J. Sargent and John Stachurski, 2020, Multivariate Hypergeometric Distribution https://python.quantecon.org/multi_hyper.html cx>[TU]U5 [R"UR[ 5Ulgrz)rrprrrmhg_docdict_paramsrs r4rp#multivariate_hypergeom_gen.__init__rr6c[XUS9$)zpCreate a frozen multivariate_hypergeom distribution. See `multivariate_hypergeom_frozen` for more information. rS)multivariate_hypergeom_frozen)rir]rrs r4r#multivariate_hypergeom_gen.__call__s -Q==r6c 8[R"U5n[R"U5nURS:XaUR[5nURS:XaUR[5n[R "UR [R5(d [S5e[R "UR [R5(d [S5eURS:Xa [S5eURS:waUS[R4n[R"X5upURS:waUSnUS:nURSS9nUS:X$:-nXAX#U[R"USS9U-4$) Nrz'm' must an array of integers.z'n' must an array of integers.z1'm' must be an array with at least one dimension..rr8rs)r?rWrastypery issubdtyper<integer TypeErrorr1r]rrrer)rir]rmcondrjrs r4r.multivariate_hypergeom_gen._process_parameterssA JJqM JJqM 66Q; A 66Q; A}}QWWbjj11<= =}}QWWbjj11<= = 66Q;89 9 66Q;#rzz/"A""1( 66Q;& AA EErENQ15!QubffU&@ @r6c[R"U5nURS:waX1U'O U(aU$URS:XaUS$U$)Nrr/rrs r4r'multivariate_hypergeom_gen._checkresultsFF# 99>$4L   ;;! ":  r6c[R"U[RS9n[R"U[RS9nX5)X)pX&)XF)pB[US-S5[US-X1- S-5- Xu)'[US-S5[US-X$- S-5- X)'[RXu'[RX'UR SS9nXx- $)NrKrr8rs)r? zeros_likerr rre) rirOrjr]rmxcondrnumdens r4r"multivariate_hypergeom_gen._logpmfsmmARZZ0mmARZZ0z1W:1y!F)1qsA!QSU);;G ac1~qsACE(::F ff VV gg2gyr6c*URX#5upBp5pgURXX#5upp#nn XX-n U[R"UR[R S9-nUR XX#X5n U [R"UR[R S9-n URX[R*5n U[R"U R[R S9-n URX[R5$)aRLog of the multivariate hypergeometric probability mass function. Parameters ---------- x : array_like Quantiles, with the last axis of `x` denoting the components. %(_doc_default_callparams)s Returns ------- logpmf : ndarray or scalar Log of the probability mass function evaluated at `x` Notes ----- %(_doc_callparams_note)s rK) rrr?rrrrrrr)rirOr]rrjrrmncondr xcond_reducedrrrmncond_s r4r!multivariate_hypergeom_gen.logpmfs$)-(@(@(F%a11!= qU 99aA&8&,,bhh!GG""6BFF7;288M$7$7rxxHH  "&&99r6cR[R"URXU55nU$)a<Multivariate hypergeometric probability mass function. Parameters ---------- x : array_like Quantiles, with the last axis of `x` denoting the components. %(_doc_default_callparams)s Returns ------- pmf : ndarray or scalar Probability density function evaluated at `x` Notes ----- %(_doc_callparams_note)s r)rirOr]rr3s r4rmultivariate_hypergeom_gen.pmfs"$ffT[[q)* r6cURX5up1n pEURS:wa)US[R4US[R4p#US:Hn[RR X6S9nX!U- -nURS:waCUS[R4[R "UR[RS9-nURXu[R5$)zMean of the multivariate hypergeometric distribution. Parameters ---------- %(_doc_default_callparams)s Returns ------- mean : array_like or scalar The mean of the distribution r.maskrK rrr?rma masked_arrayrrrrr)rir]rrjrrrEmus r4rmultivariate_hypergeom_gen.mean1s!% 8 8 >aA 66Q;S"**_%qbjj'9qQ EE  q  , !W 66Q;S"**_-hhrxxrxx89F  RVV44r6cURX5up1n pEURS:wa)US[R4US[R4p#US:HUS- S:H-n[RR X6S9nX!-U- X1- -U- X2- -US- - nURS:waCUS[R4[R "UR[RS9-nURXu[R5$)a Variance of the multivariate hypergeometric distribution. Parameters ---------- %(_doc_default_callparams)s Returns ------- array_like The variances of the components of the distribution. This is the diagonal of the covariance matrix of the distribution r.rrrKr)rir]rrjrrrEoutputs r4rmultivariate_hypergeom_gen.varIs!% 8 8 >aA 66Q;S"**_%qbjj'9qQ1Q3!8$ EE  q  ,qAC"ac*AaC0 66Q;S"**_-hhv||288<=F  88r6cURX5up1n pEURS:waHUS[R[R4nUS[R[R4nUS:HUS- S:H-n[RR X6S9nU*X2- -US- - [R "SX5-US-- nURS:waUSUSp#USnURSn[U5HEn X#U- -USU 4-X1SU 4- -USX4'USX4US- - USX4'USX4US-- USX4'MG URS:waRUS[R[R4[R"UR[RS 9-nURXu[R5$) zCovariance matrix of the multivariate hypergeometric distribution. Parameters ---------- %(_doc_default_callparams)s Returns ------- cov : array_like The covariance matrix of the distribution r.rrz...i,...j->...ijr-).rrr8rK) rrr?rrrr}rrrrrr) rir]rrjrrrErrrs r4rmultivariate_hypergeom_gen.covbs!% 8 8 >aA 66Q;#rzz2::-.A#rzz2::-.AQ1Q3!8$ EE  q  ,"*ac")).569:A? 66Q;Y<9q ?DggbksA!"cQsAvY!6CF) !DF39  &sAy 1QqS 9F39  &sAy 1QT :F39  66Q;S"**bjj89hhv||288<=F  88r6c .URX5upQn nURU5nUb[U[5(aU4nUc*[R "UR URS9nO/[R "X1R S4-URS9nUn[UR SS- 5H>n XSU 4- nUS:Hn U )URUSU 4X-X*-US9-USU 4'X'SU 4- nM@ X'SUR SS- 4'U$)aIDraw random samples from a multivariate hypergeometric distribution. Parameters ---------- %(_doc_default_callparams)s size : integer or iterable of integers, optional Number of samples to draw. Default is ``None``, in which case a single variate is returned as an array with shape ``m.shape``. %(_doc_random_state)s Returns ------- rvs : array_like Random variates of shape ``size`` or ``m.shape`` (if ``size=None``). Notes ----- %(_doc_callparams_note)s Also note that NumPy's `multivariate_hypergeometric` sampler is not used as it doesn't support broadcasting. rKr8r.rr) rrrryr?rrr<rhypergeometric) rir]rrrrjrrremrPn0masks r4rmultivariate_hypergeom_gen.rvss10 33A9aAq--l;   4 5 58D <((177!''2C((4772;/1ACqwwr{Q'A#q& /C!VF"7'66qay7:|78z<@7BBCQK QKA(%&Cq ! r6r.rzr2)rrrrrrprrrrrrrrrrrrrrs@r4rr)sQo`J>E@@6 ":H*5092$9L22r6rcF\rSrSrS SjrSrSrSrSrSr S S jr S r g) riNc^[U5TlTRRX5uTlTlTlTlTlTlU4SjnUTRlg)Nc>TRTRTRTRTRTR 4$rz)rjr]rrrr)r]rris r4rCmultivariate_hypergeom_frozen.__init__.._process_parameterss4FFDFFDFFJJ KK! !r6) rrrrjr]rrrr)rir]rrrs` r4rp&multivariate_hypergeom_frozen.__init__sU/5  66q<  TZ  !*= &r6cbURRXRUR5$rz)rrr]rr=s r4r$multivariate_hypergeom_frozen.logpmfrr6cbURRXRUR5$rz)rrr]rr=s r4r!multivariate_hypergeom_frozen.pmfrr6cbURRURUR5$rz)rrr]rr}s r4r"multivariate_hypergeom_frozen.meanrr6cbURRURUR5$rz)rrr]rr}s r4r!multivariate_hypergeom_frozen.varrr6cbURRURUR5$rz)rrr]rr}s r4r!multivariate_hypergeom_frozen.covrr6cbURRURURUUS9$Nrr)rrr]rrEs r4r!multivariate_hypergeom_frozen.rvss.zz~~dffdff#'+79 9r6)rjrr]rrrrrzrI) rrrrrprrrrrrrr/r6r4rrs% =41/..9r6r)rrrrrrc^\rSrSrSrSU4SjjrSS.SjrSrSrS r SSSS .S jr \ S 5r \ S 5r \S5r\S5r\ S5r\ S5rSrU=r$)random_table_genia*Contingency tables from independent samples with fixed marginal sums. This is the distribution of random tables with given row and column vector sums. This distribution represents the set of random tables under the null hypothesis that rows and columns are independent. It is used in hypothesis tests of independence. Because of assumed independence, the expected frequency of each table element can be computed from the row and column sums, so that the distribution is completely determined by these two vectors. Methods ------- logpmf(x) Log-probability of table `x` to occur in the distribution. pmf(x) Probability of table `x` to occur in the distribution. mean(row, col) Mean table. rvs(row, col, size=None, method=None, random_state=None) Draw random tables with given row and column vector sums. Parameters ---------- %(_doc_row_col)s %(_doc_random_state)s Notes ----- %(_doc_row_col_note)s Random elements from the distribution are generated either with Boyett's [1]_ or Patefield's algorithm [2]_. Boyett's algorithm has O(N) time and space complexity, where N is the total sum of entries in the table. Patefield's algorithm has O(K x log(N)) time complexity, where K is the number of cells in the table and requires only a small constant work space. By default, the `rvs` method selects the fastest algorithm based on the input, but you can specify the algorithm with the keyword `method`. Allowed values are "boyett" and "patefield". .. versionadded:: 1.10.0 Examples -------- >>> from scipy.stats import random_table >>> row = [1, 5] >>> col = [2, 3, 1] >>> random_table.mean(row, col) array([[0.33333333, 0.5 , 0.16666667], [1.66666667, 2.5 , 0.83333333]]) Alternatively, the object may be called (as a function) to fix the row and column vector sums, returning a "frozen" distribution. >>> dist = random_table(row, col) >>> dist.rvs(random_state=123) array([[1, 0, 0], [1, 3, 1]]) References ---------- .. [1] J. Boyett, AS 144 Appl. Statist. 28 (1979) 329-332 .. [2] W.M. Patefield, AS 159 Appl. Statist. 30 (1981) 91-97 Nc$>[TU]U5 grzrrprs r4rprandom_table_gen.__init__1 r6rSc[XUS9$)znCreate a frozen distribution of tables with given marginals. See `random_table_frozen` for more information. rS)random_table_frozen)rirowcolrs r4rrandom_table_gen.__call__4s #3$77r6cURX#5upEn[R"U5nURS:a [ S5e[R "UR [R5n[R"SS9 U(d<[R"UR[5U:H5(d [ S5eSSS5 [R"US:5(a [ S5e[R"US S 9n[R"US S 9n URS [U5:wa [ S 5eU RS [U5:wa [ S 5e[R "URSS 5n [R"X:HS S 9[R"X:HS S 9-n Sn [R"U "U5S S 9[R"U "U5S S 9-U "U5- [R"U "X5SS 9- X'[R"*X)'U S$!,(df  GN~=f)aLog-probability of table to occur in the distribution. Parameters ---------- %(_doc_x)s %(_doc_row_col)s Returns ------- logpmf : ndarray or scalar Log of the probability mass function evaluated at `x`. Notes ----- %(_doc_row_col_note)s If row and column marginals of `x` do not match `row` and `col`, negative infinity is returned. Examples -------- >>> from scipy.stats import random_table >>> import numpy as np >>> x = [[1, 5, 1], [2, 3, 1]] >>> row = np.sum(x, axis=1) >>> col = np.sum(x, axis=0) >>> random_table.logpmf(x, row, col) -1.6306401200847027 Alternatively, the object may be called (as a function) to fix the row and column vector sums, returning a "frozen" distribution. >>> d = random_table(row, col) >>> d.logpmf(x) -1.6306401200847027 r-z$`x` must be at least two-dimensionalignore)invalidz%`x` must contain only integral valuesNrz)`x` must contain only non-negative valuesr8rsrcz"shape of `x` must agree with `row`z"shape of `x` must agree with `col`c[US-5$r1)r)rOs r4lnfac&random_table_gen.logpmf..lnfac}s1q5> !r6)r8rcr/)rr?rWr1r]rr<rerrstateallrryrrerr^rr) rirOrrr3rPr dtype_is_intr2c2rrr!s r4rrandom_table_gen.logpmf;sL**34a JJqM 66A:CD D}}QWWbjj9 [[ *qxx}/A(B(B !HII+ 66!a%==HI I VVAB  VVAB  88B<3q6 !AB B 88B<3q6 !AB Bhhqwws|$vvbgB'"&&r*BB "VVE!H2.ar1JJQx "$&&qwh"GH ffWE 2w9+ *s AI IcN[R"URXU55$)aProbability of table to occur in the distribution. Parameters ---------- %(_doc_x)s %(_doc_row_col)s Returns ------- pmf : ndarray or scalar Probability mass function evaluated at `x`. Notes ----- %(_doc_row_col_note)s If row and column marginals of `x` do not match `row` and `col`, zero is returned. Examples -------- >>> from scipy.stats import random_table >>> import numpy as np >>> x = [[1, 5, 1], [2, 3, 1]] >>> row = np.sum(x, axis=1) >>> col = np.sum(x, axis=0) >>> random_table.pmf(x, row, col) 0.19580419580419592 Alternatively, the object may be called (as a function) to fix the row and column vector sums, returning a "frozen" distribution. >>> d = random_table(row, col) >>> d.pmf(x) 0.19580419580419592 r)rirOrrs r4rrandom_table_gen.pmfsLvvdkk!#.//r6c\URX5up4n[R"X45U- $)aMean of distribution of conditional tables. %(_doc_mean_params)s Returns ------- mean: ndarray Mean of the distribution. Notes ----- %(_doc_row_col_note)s Examples -------- >>> from scipy.stats import random_table >>> row = [1, 5] >>> col = [2, 3, 1] >>> random_table.mean(row, col) array([[0.33333333, 0.5 , 0.16666667], [1.66666667, 2.5 , 0.83333333]]) Alternatively, the object may be called (as a function) to fix the row and column vector sums, returning a "frozen" distribution. >>> d = random_table(row, col) >>> d.mean() array([[0.33333333, 0.5 , 0.16666667], [1.66666667, 2.5 , 0.83333333]]) )rr?r)rirrr3rPrs r4rrandom_table_gen.means+>**34axx~!!r6rmethodrcURX5upgnURX6U5up9URU5nURXFXx5n U "XgXU5R U 5$)aoDraw random tables with fixed column and row marginals. Parameters ---------- %(_doc_row_col)s size : integer, optional Number of samples to draw (default 1). method : str, optional Which method to use, "boyett" or "patefield". If None (default), selects the fastest method for this input. %(_doc_random_state)s Returns ------- rvs : ndarray Random 2D tables of shape (`size`, `len(row)`, `len(col)`). Notes ----- %(_doc_row_col_note)s Examples -------- >>> from scipy.stats import random_table >>> row = [1, 5] >>> col = [2, 3, 1] >>> random_table.rvs(row, col, random_state=123) array([[1., 0., 0.], [1., 3., 1.]]) Alternatively, the object may be called (as a function) to fix the row and column vector sums, returning a "frozen" distribution. >>> d = random_table(row, col) >>> d.rvs(random_state=123) array([[1., 0., 0.], [1., 3., 1.]]) )r_process_size_shaper_process_rvs_methodr) rirrrr.rr3rPrrmeths r4rrandom_table_gen.rvssiP**34a..t: --l; ''18A!<088??r6c<[R"U[RSS9n[R"U[RSS9n[R"U5S:wa [ S5e[R"U5S:wa [ S5e[R "US:5(a [ S5e[R "US:5(a [ S5e[R "U5nU[R "U5:wa [ S 5e[R"U[R"U5:H5(d [ S 5e[R"U[R"U5:H5(d [ S 5eX#U4$) z Check that row and column vectors are one-dimensional, that they do not contain negative or non-integer entries, and that the sums over both vectors are equal. Trrz`row` must be one-dimensionalz`col` must be one-dimensionalrz*each element of `row` must be non-negativez*each element of `col` must be non-negativez'sums over `row` and `col` must be equalz(each element of `row` must be an integerz(each element of `col` must be an integer) r?rLint64r1r]rrer$rW)rrr3rPrs r4r$random_table_gen._process_parameterss! HHSt 4 HHSt 4 771:?<= = 771:?<= = 66!a%==IJ J 66!a%==IJ J FF1I q >FG Gvva2::c?*++GH Hvva2::c?*++GH HQwr6cj[U5[U54nUcSU4$[R"U5n[R"UR[R 5(a[R "US:5(a [S5e[R"U5[U5U-4$)zG Compute the number of samples to be drawn and the shape of the output rrz/`size` must be a non-negative integer or `None`) r^r?r&rr<rrr]rr)rr3rPrs r4r0$random_table_gen._process_size_shapes QQ  <e8O}}T"}}TZZ44tax8H8HNO Owwt}eDkE111r6c URX#U5URURS.nXQ$![a [ SUS[ U535ef=f)N)Nboyett patefield'z!' not recognized, must be one of ) _rvs_select _rvs_boyett_rvs_patefieldKeyErrorr]set)clsr.r3rPr known_methodss r4r1$random_table_gen._process_rvs_method/st//!*oo++  E ( ( Eq)//2=/A.BDE E Es 0%AcSn[U5[U5-nX4[R"US-5-U-:a UR$UR$)Nrr)r^r?rfr?r>)rBr3rPrfacr's r4r=random_table_gen._rvs_select<sJ FSVO RVVAE]"Q& &%% %r6c2[R"XX#U5$rz)r rvs_rcont1rrntotrrs r4r>random_table_gen._rvs_boyettE  4|DDr6c2[R"XX#U5$rz)r rvs_rcont2rJs r4r?random_table_gen._rvs_patefieldIrMr6r/rz)rrrrrrprrrrr staticmethodrr0 classmethodr1r=r>r?rrrs@r4rrs@D*.8IV&0P "D%)D.@`< 2 2 E EEEEEr6rc>\rSrSrSS.SjrSrSrSrS SjrS r g) riQNrSc^[U5TlTRRX5TlU4SjnUTRlg)Nc>TR$rz)_params)r3rPris r4r9random_table_frozen.__init__.._process_parametersWs << r6)rrrrV)rirrrrs` r4rprandom_table_frozen.__init__Rs6%d+ zz55c?  )< &r6c<URRUSS5$rz)rrr=s r4rrandom_table_frozen.logpmf[szz  D$//r6c<URRUSS5$rz)rrr=s r4rrandom_table_frozen.pmf^szz~~at,,r6c:URRSS5$rz)rrr}s r4rrandom_table_frozen.meanaszztT**r6c:URRSSXUS9$)Nr-)rr)rirr.rs r4rrandom_table_frozen.rvsds%zz~~dDt+79 9r6)rrVrK) rrrrrprrrrrr/r6r4rrQs)-=0-+9r6rzprow : array_like Sum of table entries in each row. col : array_like Sum of table entries in each column.zx : array-like Two-dimensional table of non-negative integers, or a multi-dimensional array with the last two dimensions corresponding with the tables.zThe row and column vectors must be one-dimensional, not empty, and each sum up to the same value. They cannot contain negative or noninteger entries.z Parameters ---------- )r _doc_row_col_doc_x_doc_mean_params_doc_row_col_note)rarcrdcb[R"U=(d URU5Ulgrz)rrr)objdocdicttemplates r4_docfillris""8#:s{{GDCKr6)rrrrcJ^\rSrSrSrSU4SjjrS SjrSrS SjrSr U=r $) uniform_direction_geniaA vector-valued uniform direction. Return a random direction (unit vector). The `dim` keyword specifies the dimensionality of the space. Methods ------- rvs(dim=None, size=1, random_state=None) Draw random directions. Parameters ---------- dim : scalar Dimension of directions. seed : {None, int, `numpy.random.Generator`, `numpy.random.RandomState`}, optional Used for drawing random variates. If `seed` is `None`, the `~np.random.RandomState` singleton is used. If `seed` is an int, a new ``RandomState`` instance is used, seeded with seed. If `seed` is already a ``RandomState`` or ``Generator`` instance, then that object is used. Default is `None`. Notes ----- This distribution generates unit vectors uniformly distributed on the surface of a hypersphere. These can be interpreted as random directions. For example, if `dim` is 3, 3D vectors from the surface of :math:`S^2` will be sampled. References ---------- .. [1] Marsaglia, G. (1972). "Choosing a Point from the Surface of a Sphere". Annals of Mathematical Statistics. 43 (2): 645-646. Examples -------- >>> import numpy as np >>> from scipy.stats import uniform_direction >>> x = uniform_direction.rvs(3) >>> np.linalg.norm(x) 1. This generates one random direction, a vector on the surface of :math:`S^2`. Alternatively, the object may be called (as a function) to return a frozen distribution with fixed `dim` parameter. Here, we create a `uniform_direction` with ``dim=3`` and draw 5 observations. The samples are then arranged in an array of shape 5x3. >>> rng = np.random.default_rng() >>> uniform_sphere_dist = uniform_direction(3) >>> unit_vectors = uniform_sphere_dist.rvs(5, random_state=rng) >>> unit_vectors array([[ 0.56688642, -0.1332634 , -0.81294566], [-0.427126 , -0.74779278, 0.50830044], [ 0.3793989 , 0.92346629, 0.05715323], [ 0.36428383, -0.92449076, -0.11231259], [-0.27733285, 0.94410968, -0.17816678]]) cn>[TU]U5 [R"UR5Ulgrzrrs r4rpuniform_direction_gen.__init__rr6c[XS9$)zmCreate a frozen n-dimensional uniform direction distribution. See `uniform_direction` for more information. rS)uniform_direction_frozenrs r4runiform_direction_gen.__call__s (77r6cUb0[R"U5(aUS:dU[U5:wa [S5e[U5$)rrzMDimension of vector must be specified, and must be an integer greater than 0.rrs r4r)uniform_direction_gen._process_parameterssE ;bkk#..#'SCH_FG G3xr6cURU5nUc[R"/[S9n[R"U5nUR U5n[ XU5nU$)aDraw random samples from S(N-1). Parameters ---------- dim : integer Dimension of space (N). size : int or tuple of ints, optional Given a shape of, for example, (m,n,k), m*n*k samples are generated, and packed in an m-by-n-by-k arrangement. Because each sample is N-dimensional, the output shape is (m,n,k,N). If no shape is specified, a single (N-D) sample is returned. random_state : {None, int, `numpy.random.Generator`, `numpy.random.RandomState`}, optional Pseudorandom number generator state used to generate resamples. 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 then that instance is used. Returns ------- rvs : ndarray Random direction vectors rK)rr?rLryr&r_sample_uniform_direction)rirrrrs r4runiform_direction_gen.rvssX>--l; <88Bc*D}}T"&&s++C|Dr6r.rzr2rrs@r4rkrks"?B68''r6rkc(\rSrSrSSjrSSjrSrg)roi#Ncd[U5UlURRU5Ulg)a\Create a frozen n-dimensional uniform direction distribution. Parameters ---------- dim : int Dimension of matrices 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. Examples -------- >>> from scipy.stats import uniform_direction >>> x = uniform_direction(3) >>> x.rvs() N)rkrrrrs r4rp!uniform_direction_frozen.__init__$s&0+40 ::11#6r6cNURRURX5$rzrrEs r4runiform_direction_frozen.rvs?rr6rr2rr/r6r4roro#s 76>G Nr6a"alpha : array_like The concentration parameters. The number of entries along the last axis determines the dimensionality of the distribution. Each entry must be strictly positive. n : int or array_like The number of trials. Each element must be a strictly positive integer. )$_dirichlet_mn_doc_default_callparamsrc [R"U5n[R"U5nUbw[R"X 5up [R"U5n[R "US:5(d[R "X%:g5(a [S5eUn[R "US:*5(a [S5e[R"U5n[R "US:*5(d[R "X:g5(a [S5eUn[R "USS9n[R"Xq5upqUcXU4$XX4$![anSn[U5UeSnAff=f)Nz&`x` and `alpha` must be broadcastable.rz,`x` must contain only non-negative integers.z*`alpha` must contain only positive values.z`n` must be a positive integer.r8rs)r?rWrr]floorrre)rrrOrrnx_intn_int sum_alphas r4'_dirichlet_multinomial_check_parametersrhs6 JJu E 1 A} )**14HA   66!a%==BFF1:..KL L  vveqjEFF HHQKE vva1f~~ ++:;; Au2&I&&y4LI$%IEa KEa3KK) ):CS/q ( )sE&& F0E>>FcX^\rSrSrSrS U4SjjrS SjrSrSrSr Sr S r S r U=r $) dirichlet_multinomial_genia@ A Dirichlet multinomial random variable. The Dirichlet multinomial distribution is a compound probability distribution: it is the multinomial distribution with number of trials `n` and class probabilities ``p`` randomly sampled from a Dirichlet distribution with concentration parameters ``alpha``. Methods ------- logpmf(x, alpha, n): Log of the probability mass function. pmf(x, alpha, n): Probability mass function. mean(alpha, n): Mean of the Dirichlet multinomial distribution. var(alpha, n): Variance of the Dirichlet multinomial distribution. cov(alpha, n): The covariance of the Dirichlet multinomial distribution. Parameters ---------- %(_dirichlet_mn_doc_default_callparams)s %(_doc_random_state)s See Also -------- scipy.stats.dirichlet : The dirichlet distribution. scipy.stats.multinomial : The multinomial distribution. References ---------- .. [1] Dirichlet-multinomial distribution, Wikipedia, https://www.wikipedia.org/wiki/Dirichlet-multinomial_distribution Examples -------- >>> from scipy.stats import dirichlet_multinomial Get the PMF >>> n = 6 # number of trials >>> alpha = [3, 4, 5] # concentration parameters >>> x = [1, 2, 3] # counts >>> dirichlet_multinomial.pmf(x, alpha, n) 0.08484162895927604 If the sum of category counts does not equal the number of trials, the probability mass is zero. >>> dirichlet_multinomial.pmf(x, alpha, n=7) 0.0 Get the log of the PMF >>> dirichlet_multinomial.logpmf(x, alpha, n) -2.4669689491013327 Get the mean >>> dirichlet_multinomial.mean(alpha, n) array([1.5, 2. , 2.5]) Get the variance >>> dirichlet_multinomial.var(alpha, n) array([1.55769231, 1.84615385, 2.01923077]) Get the covariance >>> dirichlet_multinomial.cov(alpha, n) array([[ 1.55769231, -0.69230769, -0.86538462], [-0.69230769, 1.84615385, -1.15384615], [-0.86538462, -1.15384615, 2.01923077]]) Alternatively, the object may be called (as a function) to fix the `alpha` and `n` parameters, returning a "frozen" Dirichlet multinomial random variable. >>> dm = dirichlet_multinomial(alpha, n) >>> dm.pmf(x) 0.08484162895927579 All methods are fully vectorized. Each element of `x` and `alpha` is a vector (along the last axis), each element of `n` is an integer (scalar), and the result is computed element-wise. >>> x = [[1, 2, 3], [4, 5, 6]] >>> alpha = [[1, 2, 3], [4, 5, 6]] >>> n = [6, 15] >>> dirichlet_multinomial.pmf(x, alpha, n) array([0.06493506, 0.02626937]) >>> dirichlet_multinomial.cov(alpha, n).shape # both covariance matrices (2, 3, 3) Broadcasting according to standard NumPy conventions is supported. Here, we have four sets of concentration parameters (each a two element vector) for each of three numbers of trials (each a scalar). >>> alpha = [[3, 4], [4, 5], [5, 6], [6, 7]] >>> n = [[6], [7], [8]] >>> dirichlet_multinomial.mean(alpha, n).shape (3, 4, 2) cx>[TU]U5 [R"UR[ 5Ulgrz)rrprrrdirichlet_mn_docdict_paramsrs r4rp"dirichlet_multinomial_gen.__init__s, '' (CE r6c[XUS9$r)dirichlet_multinomial_frozen)rirrrs r4r"dirichlet_multinomial_gen.__call__s+E4@@r6c~[X#U5upEp1[R"[U5[US-5-[X5-5- 5nU[X-5[U5[US-5-- R SS9- n[R "XcUR SS9:g[R *5 US$)a{The log of the probability mass function. Parameters ---------- x: ndarray Category counts (non-negative integers). Must be broadcastable with shape parameter ``alpha``. If multidimensional, the last axis must correspond with the categories. %(_dirichlet_mn_doc_default_callparams)s Returns ------- out: ndarray or scalar Log of the probability mass function. rr8rsr/)rr?rWr replacer)rirOrrr Sar3s r4r dirichlet_multinomial_gen.logpmfs$>eJ qjj"Q7(16:JJK 8A;!a%#@AFFBFOO 155b5>)BFF732wr6cN[R"URXU55$)aProbability mass function for a Dirichlet multinomial distribution. Parameters ---------- x: ndarray Category counts (non-negative integers). Must be broadcastable with shape parameter ``alpha``. If multidimensional, the last axis must correspond with the categories. %(_dirichlet_mn_doc_default_callparams)s Returns ------- out: ndarray or scalar Probability mass function. r)rirOrrs r4rdirichlet_multinomial_gen.pmfs"vvdkk!A.//r6c~[X5up4nUS[R4US[R4pBX#-U- $)zMean of a Dirichlet multinomial distribution. Parameters ---------- %(_dirichlet_mn_doc_default_callparams)s Returns ------- out: ndarray Mean of a Dirichlet multinomial distribution. .rr?rrirrr rs r4rdirichlet_multinomial_gen.mean(s?;5Dq#rzz/"BsBJJ$72urzr6c[X5up4nUS[R4US[R4pBX#-U- SX4- - -X$--SU-- $)aThe variance of the Dirichlet multinomial distribution. Parameters ---------- %(_dirichlet_mn_doc_default_callparams)s Returns ------- out: array_like The variances of the components of the distribution. This is the diagonal of the covariance matrix of the distribution. .rrrs r4rdirichlet_multinomial_gen.var9sZ;5Dq#rzz/"BsBJJ$72urzQX&!&1QV<uH 1 .t4 r6cbURRXRUR5$rz)rrrrr=s r4r#dirichlet_multinomial_frozen.logpmfns!zz  JJ77r6cbURRXRUR5$rz)rrrrr=s r4r dirichlet_multinomial_frozen.pmfqszz~~aTVV44r6cbURRURUR5$rz)rrrrr}s r4r!dirichlet_multinomial_frozen.meantszztzz46622r6cbURRURUR5$rz)rrrrr}s r4r dirichlet_multinomial_frozen.varwzz~~djj$&&11r6cbURRURUR5$rz)rrrrr}s r4r dirichlet_multinomial_frozen.covzrr6)rrrrz) rrrrrprrrrrrr/r6r4rrgs 5 85322r6r)rrrrrc^\rSrSrSrSU4SjjrSSjrSrSrSr Sr SS jr SS jr S r S rS rSrSrSSjrSrSSjrSrSrU=r$)vonmises_fisher_genia0!A von Mises-Fisher variable. The `mu` keyword specifies the mean direction vector. The `kappa` keyword specifies the concentration parameter. Methods ------- pdf(x, mu=None, kappa=1) Probability density function. logpdf(x, mu=None, kappa=1) Log of the probability density function. rvs(mu=None, kappa=1, size=1, random_state=None) Draw random samples from a von Mises-Fisher distribution. entropy(mu=None, kappa=1) Compute the differential entropy of the von Mises-Fisher distribution. fit(data) Fit a von Mises-Fisher distribution to data. Parameters ---------- mu : array_like Mean direction of the distribution. Must be a one-dimensional unit vector of norm 1. kappa : float Concentration parameter. Must be positive. seed : {None, int, np.random.RandomState, np.random.Generator}, optional Used for drawing random variates. If `seed` is `None`, the `~np.random.RandomState` singleton is used. If `seed` is an int, a new ``RandomState`` instance is used, seeded with seed. If `seed` is already a ``RandomState`` or ``Generator`` instance, then that object is used. Default is `None`. See Also -------- scipy.stats.vonmises : Von-Mises Fisher distribution in 2D on a circle uniform_direction : uniform distribution on the surface of a hypersphere Notes ----- The von Mises-Fisher distribution is a directional distribution on the surface of the unit hypersphere. The probability density function of a unit vector :math:`\mathbf{x}` is .. math:: f(\mathbf{x}) = \frac{\kappa^{d/2-1}}{(2\pi)^{d/2}I_{d/2-1}(\kappa)} \exp\left(\kappa \mathbf{\mu}^T\mathbf{x}\right), where :math:`\mathbf{\mu}` is the mean direction, :math:`\kappa` the concentration parameter, :math:`d` the dimension and :math:`I` the modified Bessel function of the first kind. As :math:`\mu` represents a direction, it must be a unit vector or in other words, a point on the hypersphere: :math:`\mathbf{\mu}\in S^{d-1}`. :math:`\kappa` is a concentration parameter, which means that it must be positive (:math:`\kappa>0`) and that the distribution becomes more narrow with increasing :math:`\kappa`. In that sense, the reciprocal value :math:`1/\kappa` resembles the variance parameter of the normal distribution. The von Mises-Fisher distribution often serves as an analogue of the normal distribution on the sphere. Intuitively, for unit vectors, a useful distance measure is given by the angle :math:`\alpha` between them. This is exactly what the scalar product :math:`\mathbf{\mu}^T\mathbf{x}=\cos(\alpha)` in the von Mises-Fisher probability density function describes: the angle between the mean direction :math:`\mathbf{\mu}` and the vector :math:`\mathbf{x}`. The larger the angle between them, the smaller the probability to observe :math:`\mathbf{x}` for this particular mean direction :math:`\mathbf{\mu}`. In dimensions 2 and 3, specialized algorithms are used for fast sampling [2]_, [3]_. For dimensions of 4 or higher the rejection sampling algorithm described in [4]_ is utilized. This implementation is partially based on the geomstats package [5]_, [6]_. .. versionadded:: 1.11 References ---------- .. [1] Von Mises-Fisher distribution, Wikipedia, https://en.wikipedia.org/wiki/Von_Mises%E2%80%93Fisher_distribution .. [2] Mardia, K., and Jupp, P. Directional statistics. Wiley, 2000. .. [3] J. Wenzel. Numerically stable sampling of the von Mises Fisher distribution on S2. https://www.mitsuba-renderer.org/~wenzel/files/vmf.pdf .. [4] Wood, A. Simulation of the von mises fisher distribution. Communications in statistics-simulation and computation 23, 1 (1994), 157-164. https://doi.org/10.1080/03610919408813161 .. [5] geomstats, Github. MIT License. Accessed: 06.01.2023. https://github.com/geomstats/geomstats .. [6] Miolane, N. et al. Geomstats: A Python Package for Riemannian Geometry in Machine Learning. Journal of Machine Learning Research 21 (2020). http://jmlr.org/papers/v21/19-027.html Examples -------- **Visualization of the probability density** Plot the probability density in three dimensions for increasing concentration parameter. The density is calculated by the ``pdf`` method. >>> import numpy as np >>> import matplotlib.pyplot as plt >>> from scipy.stats import vonmises_fisher >>> from matplotlib.colors import Normalize >>> n_grid = 100 >>> u = np.linspace(0, np.pi, n_grid) >>> v = np.linspace(0, 2 * np.pi, n_grid) >>> u_grid, v_grid = np.meshgrid(u, v) >>> vertices = np.stack([np.cos(v_grid) * np.sin(u_grid), ... np.sin(v_grid) * np.sin(u_grid), ... np.cos(u_grid)], ... axis=2) >>> x = np.outer(np.cos(v), np.sin(u)) >>> y = np.outer(np.sin(v), np.sin(u)) >>> z = np.outer(np.ones_like(u), np.cos(u)) >>> def plot_vmf_density(ax, x, y, z, vertices, mu, kappa): ... vmf = vonmises_fisher(mu, kappa) ... pdf_values = vmf.pdf(vertices) ... pdfnorm = Normalize(vmin=pdf_values.min(), vmax=pdf_values.max()) ... ax.plot_surface(x, y, z, rstride=1, cstride=1, ... facecolors=plt.cm.viridis(pdfnorm(pdf_values)), ... linewidth=0) ... ax.set_aspect('equal') ... ax.view_init(azim=-130, elev=0) ... ax.axis('off') ... ax.set_title(rf"$\kappa={kappa}$") >>> fig, axes = plt.subplots(nrows=1, ncols=3, figsize=(9, 4), ... subplot_kw={"projection": "3d"}) >>> left, middle, right = axes >>> mu = np.array([-np.sqrt(0.5), -np.sqrt(0.5), 0]) >>> plot_vmf_density(left, x, y, z, vertices, mu, 5) >>> plot_vmf_density(middle, x, y, z, vertices, mu, 20) >>> plot_vmf_density(right, x, y, z, vertices, mu, 100) >>> plt.subplots_adjust(top=1, bottom=0.0, left=0.0, right=1.0, wspace=0.) >>> plt.show() As we increase the concentration parameter, the points are getting more clustered together around the mean direction. **Sampling** Draw 5 samples from the distribution using the ``rvs`` method resulting in a 5x3 array. >>> rng = np.random.default_rng() >>> mu = np.array([0, 0, 1]) >>> samples = vonmises_fisher(mu, 20).rvs(5, random_state=rng) >>> samples array([[ 0.3884594 , -0.32482588, 0.86231516], [ 0.00611366, -0.09878289, 0.99509023], [-0.04154772, -0.01637135, 0.99900239], [-0.14613735, 0.12553507, 0.98126695], [-0.04429884, -0.23474054, 0.97104814]]) These samples are unit vectors on the sphere :math:`S^2`. To verify, let us calculate their euclidean norms: >>> np.linalg.norm(samples, axis=1) array([1., 1., 1., 1., 1.]) Plot 20 observations drawn from the von Mises-Fisher distribution for increasing concentration parameter :math:`\kappa`. The red dot highlights the mean direction :math:`\mu`. >>> def plot_vmf_samples(ax, x, y, z, mu, kappa): ... vmf = vonmises_fisher(mu, kappa) ... samples = vmf.rvs(20) ... ax.plot_surface(x, y, z, rstride=1, cstride=1, linewidth=0, ... alpha=0.2) ... ax.scatter(samples[:, 0], samples[:, 1], samples[:, 2], c='k', s=5) ... ax.scatter(mu[0], mu[1], mu[2], c='r', s=30) ... ax.set_aspect('equal') ... ax.view_init(azim=-130, elev=0) ... ax.axis('off') ... ax.set_title(rf"$\kappa={kappa}$") >>> mu = np.array([-np.sqrt(0.5), -np.sqrt(0.5), 0]) >>> fig, axes = plt.subplots(nrows=1, ncols=3, ... subplot_kw={"projection": "3d"}, ... figsize=(9, 4)) >>> left, middle, right = axes >>> plot_vmf_samples(left, x, y, z, mu, 5) >>> plot_vmf_samples(middle, x, y, z, mu, 20) >>> plot_vmf_samples(right, x, y, z, mu, 100) >>> plt.subplots_adjust(top=1, bottom=0.0, left=0.0, ... right=1.0, wspace=0.) >>> plt.show() The plots show that with increasing concentration :math:`\kappa` the resulting samples are centered more closely around the mean direction. **Fitting the distribution parameters** The distribution can be fitted to data using the ``fit`` method returning the estimated parameters. As a toy example let's fit the distribution to samples drawn from a known von Mises-Fisher distribution. >>> mu, kappa = np.array([0, 0, 1]), 20 >>> samples = vonmises_fisher(mu, kappa).rvs(1000, random_state=rng) >>> mu_fit, kappa_fit = vonmises_fisher.fit(samples) >>> mu_fit, kappa_fit (array([0.01126519, 0.01044501, 0.99988199]), 19.306398751730995) We see that the estimated parameters `mu_fit` and `kappa_fit` are very close to the ground truth parameters. c$>[TU]U5 grzrrs r4rpvonmises_fisher_gen.__init__\rr6c[XUS9$)zcCreate a frozen von Mises-Fisher distribution. See `vonmises_fisher_frozen` for more information. rS)vonmises_fisher_frozenrirkappars r4rvonmises_fisher_gen.__call___s &bd;;r6c[R"U5nURS:a [S5e[R"[R R U5S5(d [S5eURS:d [S5eSn[R"U5(aUS:a [U5e[U5S:Xa [S 5eURnXAU4$) zf Infer dimensionality from mu and ensure that mu is a one-dimensional unit vector and kappa positive. rz%'mu' must have one-dimensional shape.rz%'mu' must be a unit vector of norm 1.z$'mu' must have at least two entries.z"'kappa' must be a positive scalar.rrzFor 'kappa=0' the von Mises-Fisher distribution becomes the uniform distribution on the sphere surface. Consider using 'scipy.stats.uniform_direction' instead.) r?rWr1r]allcloserZrrrrM)rirrkappa_error_msgrs r4r'vonmises_fisher_gen._process_parametersfs ZZ^ 77Q;DE E{{299>>"-r22DE Eww{CD D>{{5!!UQY_- - <2 HI Igg~r6cURSU:wa [S5e[R"[RR USS9S5(d Sn[U5eg)Nr8znThe dimensionality of the last axis of 'x' must match the dimensionality of the von Mises Fisher distribution.rsr8'x' must be unit vectors of norm 1 along last dimension.)rr]r?rrZr)rirOrrns r4_check_data_vs_dist'vonmises_fisher_gen._check_data_vs_dist~s\ 772;# >? ?{{299>>!">5r::LCS/ !;r6cSU-nSUS- -[R"U5-U[-- [R"[US- U55- U- $Nr"r-r)r?rfrr rirrhalfdims r4_log_norm_factor$vonmises_fisher_gen._log_norm_factorsX)sQwu -(0BBs7Q;./0278 9r6c[R"U5nURX5 [R"SX15nUR X$5XE--$)zLog of the von Mises-Fisher probability density function. As this function does no argument checking, it should not be called directly; use 'logpdf' instead. z i,...i->...)r?rWrr}r)rirOrrr dotproductss r4rvonmises_fisher_gen._logpdfsH JJqM   (ii r5 $$S053FFFr6cNURX#5upBnURXX#5$)aJLog of the von Mises-Fisher probability density function. Parameters ---------- x : array_like Points at which to evaluate the log of the probability density function. The last axis of `x` must correspond to unit vectors of the same dimensionality as the distribution. mu : array_like, default: None Mean direction of the distribution. Must be a one-dimensional unit vector of norm 1. kappa : float, default: 1 Concentration parameter. Must be positive. Returns ------- logpdf : ndarray or scalar Log of the probability density function evaluated at `x`. )rrrirOrrrs r4rvonmises_fisher_gen.logpdfs)*11"<||AB..r6cvURX#5upBn[R"URXX#55$)a Von Mises-Fisher probability density function. Parameters ---------- x : array_like Points at which to evaluate the probability density function. The last axis of `x` must correspond to unit vectors of the same dimensionality as the distribution. mu : array_like Mean direction of the distribution. Must be a one-dimensional unit vector of norm 1. kappa : float Concentration parameter. Must be positive. Returns ------- pdf : ndarray or scalar Probability density function evaluated at `x`. )rr?rrrs r4rvonmises_fisher_gen.pdfs2*11"<vvdll12566r6c[R"USUS5nURXRUS9n[R"[R"U5[R "U5/SS9nU$)z In 2D, the von Mises-Fisher distribution reduces to the von Mises distribution which can be efficiently sampled by numpy. This method is much faster than the general rejection sampling based algorithm. rrrr8rs)r?arctan2vonmisesstackcossin)rirrrr mean_angle angle_samplesrs r4_rvs_2dvonmises_fisher_gen._rvs_2ds`ZZ1r!u- $--jd-K ((BFF=1266-3HI "$r6c UcSnOUnURU5nS[R"USU- [R"SU-5--5U- -n[R"S[R "U5- 5n[ SXC5n[R"XVUS-XgS-/SS9nUc[R"U5nU$) a0 Generate samples from a von Mises-Fisher distribution with mu = [1, 0, 0] and kappa. Samples then have to be rotated towards the desired mean direction mu. This method is much faster than the general rejection sampling based algorithm. Reference: https://www.mitsuba-renderer.org/~wenzel/files/vmf.pdf rrrcr-r).rr8rs) randomr?rfrrarrtrr0) rirrr sample_sizerOtemp uniformcirclers r4_rvs_3dvonmises_fisher_gen._rvs_3ds <KK    , R!Vrvvb5j'999:5@ @wwrBIIaL()1![O ((AmF&;; #88: "$ <jj)Gr6cUS- nUb5[R"U5(dU4n[R"U5nOSn[R"SUS--US--5nSU-U-U- nUS:XaUS- US--US-S - US --- nS U- S U-- n X)-U[R "S5[R "U5-S[R "U5-- --n Sn [R"U45n S U-n X:aURXXk- S 9nSSU-U-- SSU- U-- - nURXk- 5nX/-U[R "SU-U- X--SU-- 5--U - [R "U5:n[R"U5nUUXU U-&U U- n X:aM[X[U5n[R"S[R"SU S-- 5U5n[R"U SU/SS9nUbURX14-5nU$[R"U5nU$)z Generate samples from a n-dimensional von Mises-Fisher distribution with mu = [1, 0, ..., 0] and kappa via rejection sampling. Samples then have to be rotated towards the desired mean direction mu. Reference: https://doi.org/10.1080/03610919408813161 rrrr-rcrgr@rrr"rz...,...i->...ir rs)r?rrHrrarflog1prbetarrertr}rrr0)rirrrr dim_minus_one n_samplesra envelop_paramnode correction n_acceptedrOrsym_betacoord_x accept_tol criterion accepted_iter coord_restrs r4_rejection_sampling'vonmises_fisher_gen._rejection_samplingsa  ;;t$$x $IIwwq5B;!);;<ed*m; A +1_ucz9,a/2UCZ?@M]"rM'9:l]RVVM%::BHH]334&55  HHi] # %$#((.7.D)FHA -99Q&(224G &,,Y-CDJ2661}+y7IAm3 4 - 'J%$(/}/;= YY bgga!q&j1:? ..!I, !;!D  oodWn5Gjj)Gr6c[R"U45nSUS'[R"USSS24[R"US- U45/5n[RR [R "U55upg[R "[R"XdSS2S45SS2S4U5(aSnOSn[R"SXa5U-nU$)aCA QR decomposition is used to find the rotation that maps the north pole (1, 0,...,0) to the vector mu. This rotation is then applied to all samples. Parameters ---------- samples: array_like, shape = [..., n] mu : array-like, shape=[n, ] Point to parametrise the rotation. Returns ------- samples : rotated samples rrNrr8z ij,...j->...i) r?rrrZr/r|rr r}) rirrr base_pointembedded rotmatrixrrotsigns r4_rotate_samples#vonmises_fisher_gen._rotate_samplesEs XXsg&  1 >>2dAg;#'30H"IJyy||BLL$:; ;;ryyq$w,?@AF K KGG))OY@7Jr6cUS:XaURX#XE5nO,US:XaURX4U5nOURXUU5nUS:waURXbU5nU$)Nr-r)rrrr)rirrrrrrs r4r:vonmises_fisher_gen._rvsbsg !8ll2dAG AXll5 =G..s4/;=G !8**7> ?r6cLURX5up4nURX25$)arCompute the differential entropy of the von Mises-Fisher distribution. Parameters ---------- mu : array_like, default: None Mean direction of the distribution. Must be a one-dimensional unit vector of norm 1. kappa : float, default: 1 Concentration parameter. Must be positive. Returns ------- h : scalar Entropy of the von Mises-Fisher distribution. r)rirrrrs r4r#vonmises_fisher_gen.entropys'$00; }}S((r6c^ ^ [R"U5nURS:wa [S5e[R"[R R USS9S5(d Sn[U5eURSn[U5nURnURm SU-m U U 4Sjn[US S S 9nURnXX4$) aFit the von Mises-Fisher distribution to data. Parameters ---------- x : array-like Data the distribution is fitted to. Must be two dimensional. The second axis of `x` must be unit vectors of norm 1 and determine the dimensionality of the fitted von Mises-Fisher distribution. Returns ------- mu : ndarray Estimated mean direction. kappa : float Estimated concentration parameter. r-z'x' must be two dimensional.r8rsrrr"cB>[TTS- /U5nUSUS- T- $)Nrr)r )r bessel_valsrr3s r4solve_for_kappa0vonmises_fisher_gen.fit..solve_for_kappas0w! 4e+a.014 4r6brentq)g:0yE>geA)r.bracket) r?rWr1r]rrZrrrmean_directionmean_resultant_lengthrroot) rirOrnrdirstatsrrroot_resrrr3s @@r4r,vonmises_fisher_gen.fits( JJqM 66Q;;< <{{299>>!">5r::LCS/ !ggbk%Q'  $ $  * *) 5x'24 yr6r/rzNrNr1r0)rrrrrrprrrrrrrrrrrr:rrr#r,rrrs@r4rrshQd<0" 9 G/070 s#zz""488TZZ88r6)rrrrr rI) rrrrrprrrr#rr/r6r4rrs 0D"&"-> 9r6rcl\rSrSrSrSSjrSrSSjrSrSSjr SS jr SS jr S r S r SS jrSrg)normal_inverse_gamma_geniLaNormal-inverse-gamma distribution. The normal-inverse-gamma distribution is the conjugate prior of a normal distribution with unknown mean and variance. Methods ------- pdf(x, s2, mu=0, lmbda=1, a=1, b=1) Probability density function. logpdf(x, s2, mu=0, lmbda=1, a=1, b=1) Log of the probability density function. mean(mu=0, lmbda=1, a=1, b=1) Distribution mean. var(mu=0, lmbda=1, a=1, b=1) Distribution variance. rvs(mu=0, lmbda=1, a=1, b=1, size=None, random_state=None) Draw random samples. Parameters ---------- mu, lmbda, a, b : array_like Shape parameters of the distribution. See notes. seed : {None, int, np.random.RandomState, np.random.Generator}, optional Used for drawing random variates. If `seed` is `None`, the `~np.random.RandomState` singleton is used. If `seed` is an int, a new ``RandomState`` instance is used, seeded with seed. If `seed` is already a ``RandomState`` or ``Generator`` instance, then that object is used. Default is `None`. See Also -------- norm invgamma Notes ----- The probability density function of `normal_inverse_gamma` is: .. math:: f(x, \sigma^2; \mu, \lambda, \alpha, \beta) = \frac{\sqrt{\lambda}}{\sqrt{2 \pi \sigma^2}} \frac{\beta^\alpha}{\Gamma(\alpha)} \left( \frac{1}{\sigma^2} \right)^{\alpha + 1} \exp \left(- \frac{2 \beta + \lambda (x - \mu)^2} {2 \sigma^2} \right) where all parameters are real and finite, and :math:`\sigma^2 > 0`, :math:`\lambda > 0`, :math:`\alpha > 0`, and :math:`\beta > 0`. Methods ``normal_inverse_gamma.pdf`` and ``normal_inverse_gamma.logpdf`` accept `x` and `s2` for arguments :math:`x` and :math:`\sigma^2`. All methods accept `mu`, `lmbda`, `a`, and `b` for shape parameters :math:`\mu`, :math:`\lambda`, :math:`\alpha`, and :math:`\beta`, respectively. .. versionadded:: 1.15 References ---------- .. [1] Normal-inverse-gamma distribution, Wikipedia, https://en.wikipedia.org/wiki/Normal-inverse-gamma_distribution Examples -------- Suppose we wish to investigate the relationship between the normal-inverse-gamma distribution and the inverse gamma distribution. >>> import numpy as np >>> from scipy import stats >>> import matplotlib.pyplot as plt >>> rng = np.random.default_rng(527484872345) >>> mu, lmbda, a, b = 0, 1, 20, 20 >>> norm_inv_gamma = stats.normal_inverse_gamma(mu, lmbda, a, b) >>> inv_gamma = stats.invgamma(a, scale=b) One approach is to compare the distribution of the `s2` elements of random variates against the PDF of an inverse gamma distribution. >>> _, s2 = norm_inv_gamma.rvs(size=10000, random_state=rng) >>> bins = np.linspace(s2.min(), s2.max(), 50) >>> plt.hist(s2, bins=bins, density=True, label='Frequency density') >>> s2 = np.linspace(s2.min(), s2.max(), 300) >>> plt.plot(s2, inv_gamma.pdf(s2), label='PDF') >>> plt.xlabel(r'$\sigma^2$') >>> plt.ylabel('Frequency density / PMF') >>> plt.show() Similarly, we can compare the marginal distribution of `s2` against an inverse gamma distribution. >>> from scipy.integrate import quad_vec >>> from scipy import integrate >>> s2 = np.linspace(0.5, 3, 6) >>> res = quad_vec(lambda x: norm_inv_gamma.pdf(x, s2), -np.inf, np.inf)[0] >>> np.allclose(res, inv_gamma.pdf(s2)) True The sample mean is comparable to the mean of the distribution. >>> x, s2 = norm_inv_gamma.rvs(size=10000, random_state=rng) >>> x.mean(), s2.mean() (np.float64(-0.005254750127304425), np.float64(1.050438111436508)) >>> norm_inv_gamma.mean() (np.float64(0.0), np.float64(1.0526315789473684)) Similarly, for the variance: >>> x.var(ddof=1), s2.var(ddof=1) (np.float64(1.0546150578185023), np.float64(0.061829865266330754)) >>> norm_inv_gamma.var() (np.float64(1.0526315789473684), np.float64(0.061557402277623886)) NcURU5n[X4S9RXVS9nXr- S-n[XS9RXVS9n [R "SXX45n U R U 5UR U 54$)aDraw random samples from the distribution. Parameters ---------- mu, lmbda, a, b : array_like, optional Shape parameters. `lmbda`, `a`, and `b` must be greater than zero. size : int or tuple of ints, optional Shape of samples to draw. random_state : {None, int, np.random.RandomState, np.random.Generator}, optional Used for drawing random variates. If `random_state` is `None`, the `~np.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 ``RandomState`` or ``Generator`` instance, then that object is used. Default is `None`. Returns ------- x, s2 : ndarray Random variates. )rrr")rrr)rrrrr? result_typer) rirlmbdar r rrs2rrOr<s r4rnormal_inverse_gamma_gen.rvss~2--l; a ! % %4 % Kc! R % ) )t ) OsBq4xx % 000r6cS[R"U5[R"S[R-U-5- -nU[R"U5-[R"U5R UR 5- nUS-*[R"U5-n SU-XAU- S---*SU-- n Xx-U -U -$r)r?rfrr rrr< rirOrrrr r t1t2t3t4s r4r normal_inverse_gamma_gen._logpdfs BFF5MBFF1ruu9r>$:: ; rvvay[7??1-44QWW= =1uXr "sUFQ;&& '1R4 0w|b  r6c4URXX4XV5upxUSn[R"SS9 [R"UR"U65n SSS5 [R *W US:*'[R X'U S$!,(df  N<=f)aNLog of the probability density function. Parameters ---------- x, s2 : array_like Arguments. `s2` must be greater than zero. mu, lmbda, a, b : array_like, optional Shape parameters. `lmbda`, `a`, and `b` must be greater than zero. Returns ------- logpdf : ndarray or scalar Log of the probability density function. rrr$Nrr/)_process_parameters_pdfr?r#rWrrr) rirOrrrr r rargsrs r4rnormal_inverse_gamma_gen.logpdfs|"44QBqL  !W [[X &ZZ d 34F'66'rQw&&bz ' &s $B  BcD[R"US[R-U-- 5nXe-[R"U5R UR 5- nSU- US--n [R"SU-XAU- S---*SU-- 5n Xx-U -U -$)Nr-r)r?rarr gammarr<rrs r4_pdfnormal_inverse_gamma_gen._pdfs WWUa"%%i"n- . TGMM!$++AGG4 4"fA  VVacEr6A+--.!B$7 8w|b  r6cURXX4XV5upxUSn[R"SS9 [R"UR"U65n SSS5 SW US:*'[R X'U S$!,(df  N-=f)a@The probability density function. Parameters ---------- x, s2 : array_like Arguments. `s2` must be greater than zero. mu, lmbda, a, b : array_like, optional Shape parameters. `lmbda`, `a`, and `b` must be greater than zero. Returns ------- logpdf : ndarray or scalar The probability density function. rrr$Nrr/)r%r?r#rWr*r) rirOrrrr r rr&rs r4rnormal_inverse_gamma_gen.pdf su"44QBqL  !W [[X &**TYY-.C'B!G vv 2w ' &s $A:: BcURXX45upVUupp4XSS:)-n[R"U5R5n[R"XCS- - 5n[RXu'[RX'USUS4$)aThe mean of the distribution. Parameters ---------- mu, lmbda, a, b : array_like, optional Shape parameters. `lmbda` and `b` must be greater than zero, and `a` must be greater than one. Returns ------- x, s2 : ndarray The mean of the distribution. rr/)_process_shapesr?rWrr) rirrr r rr&mean_xmean_s2s r4rnormal_inverse_gamma_gen.mean#s,,R= 1U8B$$&**Qa%[)&&66bz72;&&r6cBURXX45upVUupp4XSS:)-nXSS:)-nXCS- U-- n US-US- S-US- -- n [R"U 5[R"U 5p[RX'[RX'U SU S4$)aThe variance of the distribution. Parameters ---------- mu, lmbda, a, b : array_like, optional Shape parameters. `lmbda` and `b` must be greater than zero, and `a` must be greater than two. Returns ------- x, s2 : ndarray The variance of the distribution. rr-r/)r/r?rWr) rirrr r rr& invalid_x invalid_s2var_xvar_s2s r4rnormal_inverse_gamma_gen.var;s,,R= 1Ah& Qx' !eu_%A!a%!q1u-. 5)2::f+=v66VVRy&*$$r6c[R"XX4XV5n[R"S/SU5Q76nUV s/sHoRUSS9PM nn Uupp4pVUS:US:-US:-)n X4$s sn f)Nrc38# UHoRv M g7frzrK.0args r4 Cnormal_inverse_gamma_gen._process_parameters_pdf..W%@4Cii4Frrr?rrr) rirOrrrr r r&r<r=rs r4r%0normal_inverse_gamma_gen._process_parameters_pdfUs""1"Q:sA%@4%@A9=># 5u ->!%r!QY1q5)QU34}?sA1c[R"XX45n[R"S/SU5Q76nUVs/sHowRUSS9PM nnUupp4US:US:-US:-)nX4$s snf)Nrc38# UHoRv M g7frzrKr;s r4r>;normal_inverse_gamma_gen._process_shapes.._r@rAFrBrrC) rirrr r r&r<r=rs r4r/(normal_inverse_gamma_gen._process_shapes]s""2a3sA%@4%@A9=># 5u ->1QY1q5)QU34}?sA/c[XX4US9$r)normal_inverse_gamma_frozenrirrr r rs r4r!normal_inverse_gamma_gen.__call__es*2aFFr6r/)rrrrNN)rrrrrrrrN)rrrrrrrrr*rrrr%r/rrr/r6r4rrLs=sh1@!4!4'0%4Gr6rc@\rSrSrS SjrSrSrSrSrS Sjr S r g) rJilNc6[U5UlXX44Ulgrz)rr_shapesrKs r4rp$normal_inverse_gamma_frozen.__init__ns-d3 ! r6cPURR"X/URQ76$rz)rrrPrirOrs r4r"normal_inverse_gamma_frozen.logpdfrs zz  666r6cPURR"X/URQ76$rz)rrrPrSs r4rnormal_inverse_gamma_frozen.pdfuszz~~a3dll33r6cHURR"UR6$rz)rrrPr}s r4r normal_inverse_gamma_frozen.meanxszz --r6cHURR"UR6$rz)rrrPr}s r4rnormal_inverse_gamma_frozen.var{szz~~t||,,r6cNURR"URXS.6$r)rrrPrEs r4rnormal_inverse_gamma_frozen.rvs~szz~~t||$RRr6)rrPrMr2) rrrrrprrrrrrr/r6r4rJrJls!'74.-Sr6rJ)rrrrrr2)r/rz)rH threadingnumpyr? scipy.linalgrY scipy._libr scipy.specialrrrrrr r r r scipy._lib._utilr rscipy.linalg.blasrr_continuous_distnsrr_discrete_distnsrrrrr_qmvntr _morestatsrscipy.optimizer__all__rfrrr_LOG_PILockrrr5rIrPrRrrrr_mvn_doc_frozen_callparams_mvn_doc_frozen_callparams_notermvn_docdict_noparamsrrrname__dict__r. method_frozenrrrJrK_matnorm_doc_frozen_callparams#_matnorm_doc_frozen_callparams_noterOmatnorm_docdict_noparamsrMrrTr _dirichlet_doc_frozen_callparams%_dirichlet_doc_frozen_callparams_noterdirichlet_docdict_noparamsrrrrrr_wishart_doc_default_callparams_wishart_doc_callparams_note_wishart_doc_frozen_callparams#_wishart_doc_frozen_callparams_noterwishart_docdict_noparamsrr rrjr!rn#_multinomial_doc_default_callparams _multinomial_doc_callparams_note"_multinomial_doc_frozen_callparams'_multinomial_doc_frozen_callparams_notermultinomial_docdict_noparamsrr"rrr#rr r$r$r;r%rArmr&rqr|r}_mvt_doc_frozen_callparams_notermvt_docdict_noparamsrrr'_mhg_doc_default_callparams_mhg_doc_callparams_note_mhg_doc_frozen_callparams_mhg_doc_frozen_callparams_notermhg_docdict_noparamsrr(rrr)r_ctab_doc_row_col _ctab_doc_x_ctab_doc_row_col_note_ctab_doc_mean_params_ctab_doc_row_col_note_frozen _ctab_docdictr_ctab_docdict_frozenupdaterirkr*rortr~#_dirichlet_mn_doc_frozen_callparams(_dirichlet_mn_doc_frozen_callparams_noterdirichlet_mn_docdict_noparamsrrrrrr+rrr,rJr/r6r4rsW  ***;2.#'')& #$ 66!bee)   &&- >>  DK&UUp&&D < < #B$? 8*$> ?*s.sl./b8b8N 6D $ - -d 3F.77=M",,V^^-ACM%%fnn6HIFN 6# "$'B#(G$@*(F$G*`*(`*F "# 69?69v 0D  ' ' -F(11$7M",,V^^-EGM%%fnn6LMFN 0%! $& )B%*K* *J* ) X;*W8$W8t O >>: FD  # #D )F$--d3M",,24M%%fnn6NOFN F# "!#'B# ?8* >?*a  "a  H -5J_5Jt GD  ! !$ 'F"++D1M",,02M%%fnn6LMFN G]5[]5@  9J9J| M",,V^^-ACM%%fnn6HIFN 4r6