"gddlZddlZddlmZddlmZddlm Z ddl m Z ejdejzZejdZejejZdZdZd"d Zd#d ZGd d ZGd dZGddZdZdZdZdZeeedZeeedZGddeZeZGddeZ dZ!dZ"dZ#e!e"edZ$de#edZ%GddeZ&Gdd eZ'e&Z(d!D]dZ)e&jTe)Z+e'jTe)Z,ejZe+j\e%e,_.ejZe+j\e$e+_.fy)$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. cN|j}|jdk(r|d}|S)z` Remove single-dimensional entries from array and convert to scalar, if necessary. r)squeezendim)outs e/var/www/dash_apps/app1/venv/lib/python3.12/site-packages/statsmodels/compat/_scipy_multivariate_t.py_squeeze_outputr s( ++-C xx1}"g Jc||}|dvrN|jjj}ddd}||tj|j z}|tj t|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. )Ng@@g.A)fd)dtypecharlowernpfinfoepsmaxabs)spectrumcondrcondtfactorrs r _eigvalsh_to_epsr!,so2  z NN   % % '%ay288A;??* H & &C Jrctj|Dcgc]}t||krdnd|z c}tScc}w)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. rr)rarrayrfloat)vrxs r _pinv_1dr)Os6" 88!))''(9: :!S! KK2776? +F rvvay)  rc|j9tj|j|jj|_|jSN)r<rdotr8Tr=s r pinvz _PSD.pinvs4 :: 1DJzzr)NNTTT)__name__ __module__ __qualname____doc__rCpropertyrIr rr r+r+cs)%N8<370rr+c^eZdZdZdfd ZedZejdZdZxZ S)multi_rv_genericzd Class which encapsulates common functionality between all multivariate distributions. cBt|t||_yrE)superrCr _random_stater=seed __class__s r rCzmulti_rv_generic.__init__s /5rc|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. )rSrHs r random_statezmulti_rv_generic.random_states!!!rc$t||_yrErrSr=rUs r rXzmulti_rv_generic.random_states/5rc4| t|S|jSrErZ)r=rXs r _get_random_statez"multi_rv_generic._get_random_states  #%l3 3%% %rrE) rJrKrLrMrCrNrXsetterr] __classcell__rVs@r rPrPs@ 6 " "66&rrPcDeZdZdZedZej dZy)multi_rv_frozenzj Class which encapsulates common functionality between all frozen multivariate distributions. c.|jjSrE)_distrSrHs r rXzmulti_rv_frozen.random_stateszz'''rc8t||j_yrE)rrdrSr[s r rXzmulti_rv_frozen.random_states#5d#;  rN)rJrKrLrMrNrXr^r rr rbrbs5((<See class definition for a detailed description of parameters.)_mvn_doc_default_callparams_mvn_doc_callparams_note_doc_random_statec|eZdZdZdfd ZddZdZdZdZddZ ddZ d Z dd Z dd Z dd Zdd ZxZS)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)) cvt||tj|jt |_yrE)rRrCr docformatrMmvn_docdict_paramsrTs r rCz multivariate_normal_gen.__init__Ts) '' 6HI rc t||||S)z Create a frozen multivariate normal distribution. See `multivariate_normal_frozen` for more information. )r?rU)multivariate_normal_frozen)r=meancovr?rUs r __call__z multivariate_normal_gen.__call__Xs*$9G/35 5rcD|l|B|d}ntj|t}|jdkrd}nX|jd}nHtj|t}|j }n tj |s td|tj|}tj|t}|d}tj|t}|dk(rd|_d|_|jdk7s|jd|k7rtd |z|jdk(r|tj|z}n|jdk(rtj|}n|jdk(rx|j||fk7rg|j\}}||k7r#d t|jz}t|d }|t|jt|fz}t||jdkDrtd |jz|||fS) z Infer dimensionality from mean or covariance matrix, ensure that mean and covariance are full vector resp. matrix. r#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 shapesizeisscalarr2zeroseyediagstrr3)r=dimrqrrrowscolsmsgs r _process_parametersz+multivariate_normal_gen._process_parameterscs ;|;C**S6Cxx!|!iilzz$e4ii;;s# "-.. <88C=Dzz$e, ;CjjE* !8DJCI 99>TZZ]c1J !" " 88q=s #C XX]''#,C XX]syyS#J6JD$t|.03CII? S/ !?S^SY77S/ ! XX\247HH=> >D#~rc tj|t}|jdk(r|tj}|S|jdk(r5|dk(r|ddtjf}|S|tjddf}|Szm Adjust quantiles array so that last axis labels the components of each data point. r$rr#Nrrzr&r newaxisr=r(rs r _process_quantilesz*multivariate_normal_gen._process_quantilessy JJq & 66Q;"** A VVq[axam$bjj!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)rr9squarerF_LOG_2PI)r=r(rqprec_U log_det_covr7devmahas r _logpdfzmultivariate_normal_gen._logpdfsJ.$hvvbiisF 342>th4t;<z.multivariate_normal_gen._cdf..s)5'4+166"CCD"Frr)rfullr{infapply_along_axisr) r=r(rqrrrrrfunc1dr rs ````` @r _cdfzmultivariate_normal_gen._cdfsL2 RVVG,FF!!&"a0s##rc |jd||\}}}|j||}t|||sd|z}tj|j ||||||} | 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 r=r(rqrrr?rrrrr s r logcdfzmultivariate_normal_gen.logcdf#sl<11$cBT3  # #As + S0s]FffTYYq$VVVDE rc|jd||\}}}|j||}t|||sd|z}|j||||||} | 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.cdfJsc<11$cBT3  # #As + S0s]Fii4fff= rc|jd||\}}}|j|}|j|||}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)rr]multivariate_normalr)r=rqrrr|rXrr s r rvszmultivariate_normal_gen.rvsqsM,11$cBT3--l; ..tS$?s##rc|jd||\}}}tjjdtjztj z|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?)rrr/slogdetpie)r=rqrrr_logdets r entropyzmultivariate_normal_gen.entropysV$11$cBT3II%%a"%%i"$$&6&<= 6V|rrE)Nr#FN)Nr#F)Nr#FNh㈵>r)Nr#r#N)Nr#)rJrKrLrMrCrsrrrrrrrrrrr_r`s@r rkrks_RhJ 5=~$=6$4$4$@HL#'%NEI $%N$8rrkc>eZdZ d dZdZdZdZdZd dZdZ y) rpNct||_|jjd||\|_|_|_t |j ||_|sd|jz}||_||_ ||_ y)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) rkrdrrrqrrr+cov_inforrr)r=rqrrr?rUrrrs r rCz#multivariate_normal_frozen.__init__sr\-T2 (, (F(F<@$)M%$)TXTXXnE txx'F   rc.|jj||j}|jj||j|j j |j j|j j}t|SrE) rdrrrrqrr8r;r7rr=r(r s r rz!multivariate_normal_frozen.logpdfsg JJ ) )!TXX 6jj  DIIt}}!%!7!79K9KMs##rcJtj|j|SrErrrr=r(s r rzmultivariate_normal_frozen.pdfvvdkk!n%%rcJtj|j|SrE)rr:rrs r rz!multivariate_normal_frozen.logcdfsvvdhhqk""rc|jj||j}|jj||j|j |j |j|j}t|SrE) rdrrrrqrrrrrrrs r rzmultivariate_normal_frozen.cdfsZ JJ ) )!TXX 6jjooaDHHdkk4;;"kk+s##rcf|jj|j|j||SrE)rdrrqrrr=r|rXs r rzmultivariate_normal_frozen.rvss#zz~~dii4FFrc~|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;r7r)r=r;r7s r rz"multivariate_normal_frozen.entropys;==))}}!!dhl+h677r)Nr#FNNrrr#N) rJrKrLrCrrrrrrr rr rprps-DH266p$ &#$ G 8rrpa 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_notericZeZdZdZd fd Z d dZd dZd dZdZddZ dZ 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)) ct||tj|jt |_t ||_y)z Initialize a multivariate t-distributed random variable. Parameters ---------- seed : Random state. N)rRrCrrmrMmvt_docdict_paramsrrSrTs r rCzmultivariate_t_gen.__init__is8 '' 6HI /5rcf|tjk(rt||||St|||||S)zs Create a frozen multivariate t-distribution. See `multivariate_t_frozen` for parameters. )rqrrr?rU)locr{dfr?rU)rrrpmultivariate_t_frozen)r=rr{rr?rUs r rszmultivariate_t_gen.__call__vsB <-3E=K379 9%Eb4BO Orc |j|||\}}}}|j||}t||}|j|||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+rr8r;r7rr) r=r(rr{rr?r shape_infors r rzmultivariate_t_gen.pdfsx2#66sE2FS%  # #As +%? ajllJ4G4G!:??4vvf~rc |j|||\}}}}|j||}t|}|j|||j|j |||j S)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+rr8r;r7)r=r(rr{rrrs r rzmultivariate_t_gen.logpdfsj<#66sE2FS%  # #As +%[ ||AsJLL*2E2Er3&OO- -rc|tjk(rtj|||||S||z }tjtj ||j d} d||zz} t| } td|z} |dz tj|tjzz} 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#ru) rrrrrrFr9rr:rr)r=r(rrr;rrr7rrrABCDEs r rzmultivariate_t_gen._logpdfs8 <&..q#vxN N#gyyV,-11r1: 28  AJ C"H  FRVVBJ' ' (N BRUdN*+ +q1uqy1}q011rc|j|||\}}}}| t|}n |j}tj|rtj |}n|j |||z }|jtj|||} || 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|) rrrSrisinfones chisquarerr~r6r) r=rr{rr|rXrrngr(zsampless r rzmultivariate_t_gen.rvssB#66sE2FS%  #$\2C$$C 88B< A bt ,r1A  # #BHHSM5t # DBGGAJq$w///w''rc tj|t}|jdk(r|tj}|S|jdk(r5|dk(r|ddtjf}|S|tjddf}|Srrrs r rz%multivariate_t_gen._process_quantiles#sy JJq & 66Q;"** A  VVq[axam$bjj!m$rc|;|9tjdt}tjdt}d}n|Rtj|t}|jdkrd}n|jd}tj |}n|=tj|t}|j }tj|}nBtj|t}tj|t}|j }|dk(rd|_d|_|jdk7s|jd|k7rtd|z|jdk(r|tj|z}n|jdk(rtj|}n|jdk(rx|j||fk7rg|j\}}||k7r#dt|jz}t|d }|t|jt|fz}t||jdkDrtd |jz|d}n0|dkr td tj|r td ||||fS) z Infer dimensionality from location array and shape matrix, handle defaults, and ensure compatible dimensions. rr$r#rrvrwz*Array 'loc' must be a vector of length %d.rxzSDimension mismatch: array 'cov' is of shape %s, but 'loc' is a vector of length %d.ryz'df' must be greater than zero.z8'df' is 'nan' but must be greater than zero or 'np.inf'.) rrzr&r r{r~r|rr2rrr3isnan)r=rr{rrrrrs r rz&multivariate_t_gen._process_parameters3s1 ;5=**Qe,CJJq.EC [JJuE2EzzA~kk!n((3-C ]**S.C((CFF3KEJJuE2E**S.C((C !8CI EK 88q=CIIaLC/I !" " ::?BFF3K'E ZZ1_GGENE ZZ1_c !:JD$t|.03EKK0@A S/ !>S-s3x88S/ ! ZZ!^249JJ?@ @ :B 1W>? ? XXb\WX XC""rrENr#r#FN)Nr#r#F)Nr#r#)Nr#r#r#N) rJrKrLrMrCrsrrrrrrr_r`s@r rr(s@>@ 6@E O@"-H)2V.(` ;#rrc,eZdZ ddZdZdZddZy)rNct||_|jj|||\}}}}||||f\|_|_|_|_t|||_y)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) rrdrrrr{rr+r)r=rr{rr?rUrs r rCzmultivariate_t_frozen.__init__ss^*(- "jj<rs !/ 266!bee)   "&&-   FK(DDN!&!&H < < I $? 8*$> ?*b.bJ ./Z8Z8| E $? 8*$& ?*F#)F#R +9O+9\$% %JD  ( ( .F)2248M,F,,V^^-ACM%V%%fnn6HIFN Jr