U Kv fY@sddlZddlZddlmZddlmZddlm Z ddl m Z e dej Ze dZe ej ZdZdd Zd&d d Zd'd dZGdddZGdddZGdddZdZdZdZdZeeedZeeedZGdddeZeZGdddeZ dZ!dZ"dZ#e!e"ed Z$de#ed Z%Gd!d"d"eZ&Gd#d$d$eZ'e&Z(d%D]:Z)e&j*e)Z+e'j*e)Z,e-e+j.e%e,_.e-e+j.e$e+_.qLdS)(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. cCs|}|jdkr|d}|S)z` Remove single-dimensional entries from array and convert to scalar, if necessary. r)Zsqueezendim)outrrL/tmp/pip-unpacked-wheel-2v6byqio/statsmodels/compat/_scipy_multivariate_t.py_squeeze_output s r cCsT|dk r |}|dkr>|jj}ddd}||t|j}|tt|}|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)dtypecharlowernpZfinfoepsmaxabs)ZspectrumcondrcondtZfactorrrrr _eigvalsh_to_eps,s  rh㈵>cstjfdd|DtdS)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. cs$g|]}t|krdnd|qS)r)r).0xrrr `sz_pinv_1d..r)rarrayfloat)vrrrr _pinv_1dOsr$c@s&eZdZdZdddZeddZdS) _PSDaN Compute coordinated functions of a symmetric positive semidefinite matrix. This class addresses two issues. Firstly it allows the pseudoinverse, the logarithm of the pseudo-determinant, and the rank of the matrix to be computed using one call to eigh instead of three. Secondly it allows these functions to be computed in a way that gives mutually compatible results. All of the functions are computed with a common understanding as to which of the eigenvalues are to be considered negligibly small. The functions are designed to coordinate with scipy.linalg.pinvh() but not necessarily with np.linalg.det() or with np.linalg.matrix_rank(). Parameters ---------- M : array_like Symmetric positive semidefinite matrix (2-D). 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. lower : bool, optional Whether the pertinent array data is taken from the lower or upper triangle of M. (Default: lower) check_finite : bool, optional Whether to check that the input matrices contain only finite numbers. Disabling may give a performance gain, but may result in problems (crashes, non-termination) if the inputs do contain infinities or NaNs. allow_singular : bool, optional Whether to allow a singular matrix. (Default: True) Notes ----- The arguments are similar to those of scipy.linalg.pinvh(). NTc Cstjj|||d\}}t|||} t|| kr:td||| k} t| t|krf|sftjdt || } t |t | } t| |_ | |_ tt| |_d|_dS)N)r check_finitez.the input matrix must be positive semidefinitezsingular matrix)scipylinalgZeighrrmin ValueErrorlenZ LinAlgErrorr$multiplysqrtrankUsumloglog_pdet_pinv) selfMrrrr&allow_singularsurrZs_pinvr/rrr __init__s     z _PSD.__init__cCs$|jdkrt|j|jj|_|jSN)r3rdotr/Tr4rrr pinvs z _PSD.pinv)NNTTT)__name__ __module__ __qualname____doc__r9propertyr>rrrr r%cs' r%csDeZdZdZd fdd ZeddZejddZdd ZZ S) multi_rv_genericzd Class which encapsulates common functionality between all multivariate distributions. Ncstt|t||_dSr:)superrDr9r _random_stater4seed __class__rr r9szmulti_rv_generic.__init__cCs|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. )rFr=rrr random_states zmulti_rv_generic.random_statecCst||_dSr:rrFrGrrr rKscCs|dk rt|S|jSdSr:rL)r4rKrrr _get_random_statesz"multi_rv_generic._get_random_state)N) r?r@rArBr9rCrKsetterrM __classcell__rrrIr rDs  rDc@s*eZdZdZeddZejddZdS)multi_rv_frozenzj Class which encapsulates common functionality between all frozen multivariate distributions. cCs|jjSr:)_distrFr=rrr rKszmulti_rv_frozen.random_statecCst||j_dSr:)rrQrFrGrrr rKsN)r?r@rArBrCrKrNrrrr rPs  rPamean : array_like, optional Mean of the distribution (default zero) cov : array_like, optional Covariance matrix of the distribution (default one) allow_singular : bool, optional Whether to allow a singular covariance matrix. (Default: False) a2Setting the parameter `mean` to `None` is equivalent to having `mean` be the zero-vector. The parameter `cov` can be a scalar, in which case the covariance matrix is the identity times that value, a vector of diagonal entries for the covariance matrix, or a two-dimensional array_like. z>See class definition for a detailed description of parameters.)_mvn_doc_default_callparams_mvn_doc_callparams_note_doc_random_statecseZdZdZdfdd ZdddZd d Zd d Zd dZd ddZ d!ddZ ddZ d"ddZ d#ddZ d$ddZd%ddZZS)&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)) Ncs$tt||t|jt|_dSr:)rErVr9r docformatrBmvn_docdict_paramsrGrIrr r9Tsz multivariate_normal_gen.__init__rFcCst||||dS)z Create a frozen multivariate normal distribution. See `multivariate_normal_frozen` for more information. )r6rH)multivariate_normal_frozen)r4meancovr6rHrrr __call__Xsz multivariate_normal_gen.__call__cCs|dkr^|dkrH|dkrd}q\tj|td}|jdkrArray 'cov' must be at most two-dimensional, but cov.ndim = %d) rasarrayr"rshapesizeZisscalarr*zeroseyediagstrr+)r4dimrZr[rowscolsmsgrrr _process_parameterscsV           z+multivariate_normal_gen._process_parameterscCs`tj|td}|jdkr$|tj}n8|jdkr\|dkrJ|ddtjf}n|tjddf}|Szm Adjust quantiles array so that last axis labels the components of each data point. r rrNrrbr"rZnewaxisr4rrirrr _process_quantiless   z*multivariate_normal_gen._process_quantilescCs8||}tjtt||dd}d|t||S)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. r Zaxisg)rr0squarer;_LOG_2PI)r4rrZprec_UZ log_det_covr.devmaharrr _logpdfszmultivariate_normal_gen._logpdfcCsL|d||\}}}|||}t||d}||||j|j|j}t|S)a Log of the multivariate normal probability density function. Parameters ---------- x : array_like Quantiles, with the last axis of `x` denoting the components. %(_mvn_doc_default_callparams)s Returns ------- pdf : ndarray or scalar Log of the probability density function evaluated at `x` Notes ----- %(_mvn_doc_callparams_note)s Nr6)rmrqr%rxr/r2r.r r4rrZr[r6riZpsdr rrr logpdfs   zmultivariate_normal_gen.logpdfc CsR|d||\}}}|||}t||d}t||||j|j|j}t |S)a Multivariate normal probability density function. Parameters ---------- x : array_like Quantiles, with the last axis of `x` denoting the components. %(_mvn_doc_default_callparams)s Returns ------- pdf : ndarray or scalar Probability density function evaluated at `x` Notes ----- %(_mvn_doc_callparams_note)s Nry) rmrqr%rexprxr/r2r.r rzrrr pdfs   zmultivariate_normal_gen.pdfc s>tjtj fdd}t|d|}t|S)a Parameters ---------- x : ndarray Points at which to evaluate the cumulative distribution function. mean : ndarray Mean of the distribution cov : array_like Covariance matrix of the distribution maxpts: integer The maximum number of points to use for integration abseps: float Absolute error tolerance releps: float Relative error tolerance Notes ----- As this function does no argument checking, it should not be called directly; use 'cdf' instead. .. versionadded:: 1.0.0 c st|dS)Nr)rZmvnun)Zx_sliceabsepsr[rmaxptsrZrelepsrr s z.multivariate_normal_gen._cdf..r )rfullrcinfZapply_along_axisr ) r4rrZr[rrrZfunc1dr rr~r _cdfszmultivariate_normal_gen._cdfrc CsV|d||\}}}|||}t||d|s8d|}t|||||||} | 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 Nry@B)rmrqr%rr1r r4rrZr[r6rrrrir rrr logcdf#s  zmultivariate_normal_gen.logcdfc CsP|d||\}}}|||}t||d|s8d|}|||||||} | 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 Nryr)rmrqr%rrrrr cdfJs  zmultivariate_normal_gen.cdfcCs4|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)rmrMmultivariate_normalr )r4rZr[rdrKrir rrr rvsqs zmultivariate_normal_gen.rvscCs<|d||\}}}tjdtjtj|\}}d|S)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?)rmrr(Zslogdetpie)r4rZr[ri_Zlogdetrrr entropys zmultivariate_normal_gen.entropy)N)NrFN)NrF)NrF)NrFNrr)NrFNrr)NrrN)Nr)r?r@rArBr9r\rmrqrxr{r}rrrrrrOrrrIr rVs&T ?    ' ' rVc@sHeZdZdddZddZd d Zd d Zd dZdddZddZ dS)rYNrFrcCsZt||_|jd||\|_|_|_t|j|d|_|sDd|j}||_||_ ||_ 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.]]) Nryr) rVrQrmrirZr[r%cov_inforrr)r4rZr[r6rHrrrrrr r9s.  z#multivariate_normal_frozen.__init__cCs:|j||j}|j||j|jj|jj|jj}t |Sr:) rQrqrirxrZrr/r2r.r r4rr rrr r{s z!multivariate_normal_frozen.logpdfcCst||Sr:rr|r{r4rrrr r}szmultivariate_normal_frozen.pdfcCst||Sr:)rr1rrrrr rsz!multivariate_normal_frozen.logcdfcCs8|j||j}|j||j|j|j|j|j}t |Sr:) rQrqrirrZr[rrrr rrrr rs zmultivariate_normal_frozen.cdfcCs|j|j|j||Sr:)rQrrZr[r4rdrKrrr rszmultivariate_normal_frozen.rvscCs$|jj}|jj}d|td|S)z Computes the differential entropy of the multivariate normal. Returns ------- h : scalar Entropy of the multivariate normal distribution rr)rr2r.rt)r4r2r.rrr rs z"multivariate_normal_frozen.entropy)NrFNNrr)rN) r?r@rAr9r{r}rrrrrrrr rYs 8 rYa 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_noterUcsbeZdZdZdfdd ZdddZdd d Zdd d Zd dZdddZ ddZ ddZ Z 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)) Ncs.tt||t|jt|_t||_dS)z Initialize a multivariate t-distributed random variable. Parameters ---------- seed : Random state. N) rErr9rrWrBmvt_docdict_paramsrrFrGrIrr r9is zmultivariate_t_gen.__init__rFcCs,|tjkrt||||dSt|||||dS)zs Create a frozen multivariate t-distribution. See `multivariate_t_frozen` for parameters. )rZr[r6rH)locrcdfr6rH)rrrYmultivariate_t_frozen)r4rrcrr6rHrrr r\vs zmultivariate_t_gen.__call__c CsT||||\}}}}|||}t||d}||||j|j|||j}t|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]) ry) rmrqr%rxr/r2r.rr|) r4rrrcrr6ri shape_infor{rrr r}s  zmultivariate_t_gen.pdfc CsF||||\}}}}|||}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. )rmrqr%rxr/r2r.)r4rrrcrrirrrr r{s  zmultivariate_t_gen.logpdfcCs|tjkrt|||||S||}tt||jdd} d||} t| } td|} |dt|tj } d|}| tdd|| }t | | | ||S)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. r rrrg@rr]) rrrrxrsr;r0rr1rr )r4rrrur2rrir.rvrwrABCDErrr rxs   zmultivariate_t_gen._logpdfc Cs||||\}}}}|dk r(t|}n|j}t|rDt|}n|j||d|}|jt|||d} || t |dddf} 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)rd) rmrrFrisinfZonesZ chisquarerrer-r ) r4rrcrrdrKrirngrzZsamplesrrr rs!   zmultivariate_t_gen.rvscCs`tj|td}|jdkr$|tj}n8|jdkr\|dkrJ|ddtjf}n|tjddf}|Srnrorprrr rq#s   z%multivariate_t_gen._process_quantilescCs|dkr2|dkr2tjdtd}tjdtd}d}n|dkrntj|td}|jdkrXd}n |jd}t|}nJ|dkrtj|td}|j}t|}n"tj|td}tj|td}|j}|dkrd|_d|_|jdks|jd|krtd||jdkr |t|}n|jdkr$t |}n~|jdkr|j||fkr|j\}}||krdd t |j}nd }|t |jt |f}t|n|jdkrtd |j|dkrd}n(|dkrtd nt |rtd ||||fS)z Infer dimensionality from location array and shape matrix, handle defaults, and ensure compatible dimensions. Nrr rrr^r_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.raz'df' must be greater than zero.z8'df' is 'nan' but must be greater than zero or 'np.inf'.) rrbr"rrcrerdrfr*rgrhr+isnan)r4rrcrrirjrkrlrrr rm3s`               z&multivariate_t_gen._process_parameters)N)NrrFN)NrrF)Nrr)NrrrN) r?r@rArBr9r\r}r{rxrrqrmrOrrrIr r(s@   $+ 0rc@s0eZdZd ddZddZdd Zd d d ZdS)rNrFcCsPt||_|j|||\}}}}||||f\|_|_|_|_t||d|_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]) ryN) rrQrmrirrcrr%r)r4rrcrr6rHrirrr r9ss zmultivariate_t_frozen.__init__c CsB|j||j}|jj}|jj}|j||j|||j|j|jj Sr:) rQrqrirr/r2rxrrr.)r4rr/r2rrr r{s zmultivariate_t_frozen.logpdfcCst||Sr:rrrrr r}szmultivariate_t_frozen.pdfcCs|jj|j|j|j||dS)N)rrcrrdrK)rQrrrcrrrrr rs  zmultivariate_t_frozen.rvs)NrrFN)rN)r?r@rAr9r{r}rrrrr rqs  r)r{r}r)NN)r)/ZnumpyrZ scipy.linalgr'Z scipy._librZ scipy.specialrZscipy._lib._utilrZ scipy.statsrr1rrtZ_LOG_2Z_LOG_PIrUr rr$r%rDrPrSrTZ_mvn_doc_frozen_callparamsZ_mvn_doc_frozen_callparams_noterXZmvn_docdict_noparamsrVrrYrrZ_mvt_doc_frozen_callparams_noterZmvt_docdict_noparamsrrZmultivariate_tname__dict__methodZ method_frozenrWrBrrrr sz        # G$ (^K.