M/PhddlZddlZddlmZddlmZddlm Z ddl m Z ej dej zZej dZej ej ZdZdZd#d Zd$d ZGd d ZGddZGddZdZdZdZdZeeedZeeedZGddeZeZGddeZ dZ!dZ"dZ#e!e"edZ$de#edZ%GddeZ&Gd d!eZ'e&Z(d"D]RZ)e&j*e)Z+e'j*e)Z,ej-e+j.e%e,_.ej-e+j.e$e+_.SdS)%N)doccer)gammaln)check_random_state)mvnarandom_state : {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. cT|}|jdkr|d}|S)z` Remove single-dimensional entries from array and convert to scalar, if necessary. r)squeezendim)outs h/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/statsmodels/compat/_scipy_multivariate_t.py_squeeze_outputr s* ++--C x1}}"g Jc||}|dvrE|jj}ddd}||tj|jz}|tjt|z}|S)a Determine 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)Ng@@g.A)fd)dtypecharlowernpfinfoepsmaxabs)spectrumcondrcondtfactorrs r _eigvalsh_to_epsr!,st2  z N  % % ' '%%ay28A;;?* H && &C Jrh㈵>cRtjfd|DtS)a A 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. cDg|]}t|krdnd|z S)r)r).0xrs r z_pinv_1d..`s/<<?)''(9:: :!S!! K276?? + +FF rvayy))  rcp|j)tj|j|jj|_|jSN)r@rdotr<TrAs r pinvz _PSD.pinvs+ : 11DJzr)NNTTT)__name__ __module__ __qualname____doc__rGpropertyrMr rr r/r/csV%%N8<370Xrr/c`eZdZdZdfd ZedZejdZdZxZ S)multi_rv_genericzd Class which encapsulates common functionality between all multivariate distributions. Ncptt||_dSrI)superrGr _random_staterAseed __class__s r rGzmulti_rv_generic.__init__s/ /55rc|jS)a Get or set the RandomState object for generating random variates. This can be either None, int, a RandomState instance, or a np.random.Generator instance. If None (or np.random), use the RandomState singleton used by np.random. If already a RandomState or Generator instance, use it. If an int, use a new RandomState instance seeded with seed. )rWrLs r random_statezmulti_rv_generic.random_states !!rc.t||_dSrIrrWrArYs r r\zmulti_rv_generic.random_states/55rc2|t|S|jSrIr^)rAr\s r _get_random_statez"multi_rv_generic._get_random_states  #%l33 3% %rrI) rNrOrPrQrGrRr\setterra __classcell__rZs@r rTrTs 666666 " "X "666&&&&&&&rrTcHeZdZdZedZejdZdS)multi_rv_frozenzj Class which encapsulates common functionality between all frozen multivariate distributions. c|jjSrI)_distrWrLs r r\zmulti_rv_frozen.random_states z''rc8t||j_dSrI)rrhrWr_s r r\zmulti_rv_frozen.random_states#5d#;#;    rN)rNrOrPrQrRr\rbr rr rfrfsX((X(<<<<See class definition for a detailed description of parameters.)_mvn_doc_default_callparams_mvn_doc_callparams_note_doc_random_statec|eZdZdZdfd ZddZdZdZd Zdd Z dd Z d Z ddZ ddZ ddZddZxZS)multivariate_normal_gena 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)`` 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()`` Compute the differential entropy of the multivariate normal. Parameters ---------- x : array_like Quantiles, with the last axis of `x` denoting the components. %(_mvn_doc_default_callparams)s %(_doc_random_state)s 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. Notes ----- %(_mvn_doc_callparams_note)s The covariance matrix `cov` must be a (symmetric) positive semi-definite matrix. 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, and :math:`k` is the dimension of the space where :math:`x` takes values. .. versionadded:: 0.14.0 Examples -------- >>> 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) 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)) Nct|tj|jt |_dSrI)rVrGr docformatrQmvn_docdict_paramsrXs r rGz multivariate_normal_gen.__init__Ts6 ' 6HII rr%Fc(t||||S)z Create a frozen multivariate normal distribution. See `multivariate_normal_frozen` for more information. )rCrY)multivariate_normal_frozen)rAmeancovrCrYs r __call__z multivariate_normal_gen.__call__Xs%*$9G/3555 5rc|a|<|d}n}tj|t}|jdkrd}nT|jd}nFtj|t}|j}n#tj|std|tj|}tj|t}|d}tj|t}|dkrd|_d |_|jdks|jd|krtd |z|jdkr|tj |z}n|jdkrtj |}n|jdkrl|j||fkr_|j\}}||krd t|jz}n(d }|t|jt|fz}t||jdkrtd |jz|||fS)z Infer dimensionality from mean or covariance matrix, ensure that mean and covariance are full vector resp. matrix. Nr%r)rrz.Dimension of random variable must be a scalar.?r%r%r%z+Array 'mean' must be a vector of length %d.HArray 'cov' must be square if it is two dimensional, but cov.shape = %s.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) rasarrayr+r shapesizeisscalarr6zeroseyediagstrr7)rAdimrurvrowscolsmsgs r _process_parametersz+multivariate_normal_gen._process_parameterscs ;|;CC*S666Cx!||!ilz$e444i;s## . "-... <8C==Dz$e,,, ;CjE*** !88DJCI 9>>TZ]c11J !"" " 8q==s #CC X]]'#,,CC X]]syS#J66JD$t||.03CI??S^^SYY77S// ! X\\247H=>> >D#~rctj|t}|jdkr|tj}n>|jdkr3|dkr|ddtjf}n|tjddf}|Szm Adjust quantiles array so that last axis labels the components of each data point. r)rr%Nrr~r+r newaxisrAr'rs r _process_quantilesz*multivariate_normal_gen._process_quantilesss Jq & & & 6Q;;"* AA Vq[[axxaaam$bj!!!m$rc||z }tjtjtj||d}d|tz|z|zzS)a Parameters ---------- x : ndarray Points at which to evaluate the log of the probability density function mean : ndarray Mean of the distribution prec_U : ndarray A decomposition such that np.dot(prec_U, prec_U.T) is the precision matrix, i.e. inverse of the covariance matrix. log_det_cov : float Logarithm of the determinant of the covariance matrix rank : int Rank of the covariance matrix. Notes ----- As this function does no argument checking, it should not be called directly; use 'logpdf' instead. raxisg)rr=squarerJ_LOG_2PI)rAr'ruprec_U log_det_covr;devmahas r _logpdfzmultivariate_normal_gen._logpdfsP.$hvbisF 3 3442>>>th4t;<z.multivariate_normal_gen._cdf..s-5'4+166"C"CCD"Frr)rfullrinfapply_along_axisr) rAr'rurvrrrfunc1dr rs ````` @r _cdfzmultivariate_normal_gen._cdfs{2 RVG,,FFFFFFFFF!&"a00s###rr"c |d||\}}}|||}t|||sd|z}tj|||||||} | S)a Log 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) Returns ------- cdf : ndarray or scalar Log of the cumulative distribution function evaluated at `x` Notes ----- %(_mvn_doc_callparams_note)s .. versionadded:: 1.0.0 Nr@B)rrr/rr>r rAr'rurvrCrrrrr s r logcdfzmultivariate_normal_gen.logcdf#s<11$cBBT3  # #As + + S0000 #s]FfTYYq$VVVDDEE rc|d||\}}}|||}t|||sd|z}|||||||} | S)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) Returns ------- cdf : ndarray or scalar Cumulative distribution function evaluated at `x` Notes ----- %(_mvn_doc_callparams_note)s .. versionadded:: 1.0.0 Nrr)rrr/rrs r cdfzmultivariate_normal_gen.cdfJsz<11$cBBT3  # #As + + S0000 #s]Fii4fff== rc|d||\}}}||}||||}t|S)a Draw 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 N)rramultivariate_normalr)rArurvrr\rr s r rvszmultivariate_normal_gen.rvsqsY,11$cBBT3--l;; ..tS$??s###rc|d||\}}}tjdtjztjz|z\}}d|zS)aP Compute 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 Nr?)rrr3slogdetpie)rArurvr_logdets r entropyzmultivariate_normal_gen.entropysV$11$cBBT3I%%a"%i"$&6&<== 6V|rrI)Nr%FN)Nr%F)Nr%FNr"r")Nr%r%N)Nr%)rNrOrPrQrGrwrrrrrrrrrrrcrds@r roros0RRhJJJJJJ 5 5 5 5===~$===6$$$$4$$$$4$$$@HL#'%%%%NEI $%%%%N$$$$8rroc@eZdZ d dZdZdZdZd Zd d Zd Z dS)rtNr%Fr"ct||_|jd||\|_|_|_t |j||_|s d|jz}||_||_ ||_ dS)a Create a frozen multivariate normal distribution. Parameters ---------- mean : array_like, optional Mean of the distribution (default zero) cov : array_like, optional Covariance matrix of the distribution (default one) allow_singular : bool, optional If this flag is True then tolerate a singular covariance matrix (default False). seed : {None, int, `~np.random.RandomState`, `~np.random.Generator`}, optional This parameter defines the object to use 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. 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.]]) Nrr) rorhrrrurvr/cov_inforrr)rArurvrCrYrrrs r rGz#multivariate_normal_frozen.__init__s\-T22 (, (F(F<@$)M)M%$)TXTXnEEE  (tx'F   rc|j||j}|j||j|jj|jj|jj}t|SrI) rhrrrrurr<r?r;rrAr'r s r rz!multivariate_normal_frozen.logpdfs] J ) )!TX 6 6j  DIt}!%!79KMMs###rcPtj||SrIrrrrAr's r rzmultivariate_normal_frozen.pdfvdkk!nn%%%rcPtj||SrI)rr>rrs r rz!multivariate_normal_frozen.logcdfsvdhhqkk"""rc|j||j}|j||j|j|j|j|j}t|SrI) rhrrrrurvrrrrrs r rzmultivariate_normal_frozen.cdfsU J ) )!TX 6 6jooaDHdk4;"k++s###rcP|j|j|j||SrI)rhrrurvrArr\s r rzmultivariate_normal_frozen.rvss z~~di4FFFrcX|jj}|jj}d|tdzz|zzS)z Computes the differential entropy of the multivariate normal. Returns ------- h : scalar Entropy of the multivariate normal distribution rr%)rr?r;r)rAr?r;s r rz"multivariate_normal_frozen.entropys1=)}!dhl+h677r)Nr%FNNr"r"r%N) rNrOrPrGrrrrrrr rr rtrtsDH266666p$$$ &&&###$$$ GGGG 8 8 8 8 8rrta loc : 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_notermcZeZdZdZd fd Z ddZddZddZd Zdd Z d Z d Z xZ S)multivariate_t_gena 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. ``rvs(loc=None, shape=1, df=1, size=1, random_state=None)`` Draw random samples from a multivariate t-distribution. Parameters ---------- x : array_like Quantiles, with the last axis of `x` denoting the components. %(_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}} \exp\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 Examples -------- >>> import matplotlib.pyplot as plt >>> from scipy.stats import multivariate_t >>> x, y = np.mgrid[-1:3:.01, -2:1.5:.01] >>> pos = np.dstack((x, y)) >>> rv = multivariate_t([1.0, -0.5], [[2.1, 0.3], [0.3, 1.5]], df=2) >>> fig, ax = plt.subplots(1, 1) >>> ax.set_aspect('equal') >>> plt.contourf(x, y, rv.pdf(pos)) Nct|tj|jt |_t ||_dS)z Initialize a multivariate t-distributed random variable. Parameters ---------- seed : Random state. N)rVrGrrqrQmvt_docdict_paramsrrWrXs r rGzmultivariate_t_gen.__init__isJ ' 6HII /55rr%Fcp|tjkrt||||St|||||S)zs Create a frozen multivariate t-distribution. See `multivariate_t_frozen` for parameters. )rurvrCrY)locrdfrCrY)rrrtmultivariate_t_frozen)rArrrrCrYs r rwzmultivariate_t_gen.__call__vsX <<-3E=K37999 9%Eb4BOOO Orc ||||\}}}}|||}t||}||||j|j|||j}tj|S)al Multivariate 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) array([0.00075713]) r) rrr/rr<r?r;rr) rAr'rrrrCr shape_infors r rzmultivariate_t_gen.pdfs2#66sE2FFS%  # #As + +%??? ajlJ4G!:?44vf~~rc ||||\}}}}|||}t|}||||j|j|||jS)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) array([-7.1859802]) See Also -------- pdf : Probability density function. )rrr/rr<r?r;)rAr'rrrrrs r rzmultivariate_t_gen.logpdfsp<#66sE2FFS%  # #As + +%[[ ||AsJL*2Er3&O-- -rc|tjkrt|||||S||z }tjtj||d} d||zz} t| } td|z} |dz tj|tj zz} d|z}| tjdd|z | zzz}t| | z | z |z |zS)aBUtility 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. rrrg@r%ry) rrrrrrJr=rr>rr)rAr'rrr?rrr;rrrABCDEs r rzmultivariate_t_gen._logpdfs8 <<&..q#vxNN N#gyV,,--11r1:: 28  AJJ C"H   FRVBJ'' ' (N BRUdN*++ +q1uqy1}q0111rc||||\}}}}|t|}n|j}tj|rtj|}n||||z }|tj|||} || tj |dddfz z} t| S)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]]) N)r) rrrWrisinfones chisquarerrr:r) rArrrrr\rrngr'zsampless r rzmultivariate_t_gen.rvssB#66sE2FFS%  #$\22CC$C 8B<< 2 AA bt ,,r1A  # #BHSMM5t # D DBGAJJqqq$w///w'''rctj|t}|jdkr|tj}n>|jdkr3|dkr|ddtjf}n|tjddf}|Srrrs r rz%multivariate_t_gen._process_quantiles#ss Jq & & & 6Q;;"* AA Vq[[axxaaam$bj!!!m$rc|;|9tjdt}tjdt}d}n|Ktj|t}|jdkrd}n |jd}tj|}nv|7tj|t}|j}tj|}n=tj|t}tj|t}|j}|dkrd|_d|_|jdks|jd|krtd|z|jdkr|tj|z}n|jdkrtj |}n|jdkrl|j||fkr_|j\}}||krd t|jz}n(d }|t|jt|fz}t||jdkrtd |jz|d}n8|dkrtd tj |rtd ||||fS)z Infer dimensionality from location array and shape matrix, handle defaults, and ensure compatible dimensions. Nrr)r%rrzr{z*Array 'loc' must be a vector of length %d.r|zSDimension mismatch: array 'cov' is of shape %s, but 'loc' is a vector of length %d.r}z'df' must be greater than zero.z8'df' is 'nan' but must be greater than zero or 'np.inf'.) rr~r+r rrrrr6rrr7isnan)rArrrrrrrs r rz&multivariate_t_gen._process_parameters3sh ;5=*Qe,,,CJq...ECC [JuE222EzA~~k!n(3--CC ]*S...C(CF3KKEEJuE222E*S...C(C !88CI EK 8q==CIaLC//I !"" " :??BF3KK'EE Z1__GENNEE Z1__c !:!:JD$t||.03EK0@0@A>S--s3xx88S// ! Z!^^249J?@@ @ :BB 1WW>?? ? Xb\\ YWXX XC""rrINr%r%FN)Nr%r%F)Nr%r%)Nr%r%r%N) rNrOrPrQrGrwrrrrrrrcrds@r rr(s>>@ 6 6 6 6 6 6@E O O O O@"-"-"-"-H)2)2)2V.(.(.(.(` ;#;#;#;#;#;#;#rrc.eZdZ ddZdZdZd dZdS) rNr%Fct||_|j|||\}}}}||||f\|_|_|_|_t|||_dS)a Create a frozen multivariate t distribution. Parameters ---------- %(_mvt_doc_default_callparams)s Examples -------- >>> 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) rrhrrrrrr/r)rArrrrCrYrs r rGzmultivariate_t_frozen.__init__ssl*(-- "j<rr_LOG_2_LOG_PIrmrr!r-r/rTrfrkrl_mvn_doc_frozen_callparams_mvn_doc_frozen_callparams_noterrmvn_docdict_noparamsrorrtrr_mvt_doc_frozen_callparams_notermvt_docdict_noparamsrrmultivariate_tname__dict__method method_frozenrqrQr rr rsc !!!!!!////// 26!be)    "&--        FKKKK(DDDDDDDDN!&!&!&!&!&!&!&!&H < < < < < < < < I $? 8*$> ?*bbbbb.bbbJ .-//Z8Z8Z8Z8Z8Z8Z8Z8| E $? 8*$& ?*F#F#F#F#F#)F#F#F#R +9+9+9+9+9O+9+9+9\$#%% %JJD  ( .F)248M,F,V^-ACCM%V%fn6HIIFNN JJr