a acY@sddlZddlZddlmZmZddlZddlmZddl m Z m Z m Z m Z mZmZddlmZddlmZddlmZddlmZd d lmZd d lmZgd Zed ejZed Z eejZ!dZ"ddZ#diddZ$djddZ%GdddZ&GdddZ'GdddZ(dZ)dZ*dZ+dZ,e)e*e"d Z-e+e,e"d Z.Gd!d"d"e'Z/e/Z0Gd#d$d$e(Z1d%D]:Z2e/j3e2Z4e1j3e2Z5e6e4j7e.e5_7e6e4j7e-e4_7qfd&Z8d'Z9dZ:dZ;e8e9e"d(Ze>Z?Gd+d,d,e(Z@d-D]:Z2e>j3e2Z4e@j3e2Z5e6e4j7e=e5_7e6e4j7e<e4_7qd.ZAdZBdZCeAe"d/ZDeBe"d/ZEd0d1ZFd2d3ZGd4d5ZHGd6d7d7e'ZIeIZJGd8d9d9e(ZKd:D]:Z2eIj3e2Z4eKj3e2Z5e6e4j7eEe5_7e6e4j7eDe4_7qd;ZLdZMdZNdZOeLeMe"d<ZPeNeOe"d<ZQGd=d>d>e'ZReRZSGd?d@d@e(ZTdAD]:Z2eRj3e2Z4eTj3e2Z5e6e4j7eQe5_7e6e4j7ePe4_7q dkdCdDZUGdEdFdFeRZVeVZWGdGdHdHe(ZXdID]:Z2eVj3e2Z4eTj3e2Z5e6e4j7eQe5_7e6e4j7ePe4_7qdJZYdKZZdZ[dZ\eYeZe"d<Z]e[e\e"d<Z^GdLdMdMe'Z_e_Z`GdNdOdOe(ZadPD]:Z2e_j3e2Z4eaj3e2Z5e6e4j7e^e5_7e6e4j7e]e4_7qGdQdRdRe'ZbebZcGdSdTdTe(ZdGdUdVdVe'ZeeeZfGdWdXdXe'ZgegZhGdYdZdZe'ZieiZjd[Zkd\ZldZmekele"d]Zndeme"d]ZoGd^d_d_e'ZpGd`dadae(ZqepZrd-D]:Z2epj3e2Z4eqj3e2Z5e6e4j7eoe5_7e6e4j7ene4_7qdbZsdcZtdZudZvesete"d<Zweueve"d<ZxGdddedee'ZyeyZzGdfdgdge(Z{dhD]:Z2eyj3e2Z4e{j3e2Z5e6e4j7exe5_7e6e4j7ewe4_7qdS)lN)asarray_chkfiniteasarray)doccer)gammalnpsi multigammalnxlogyentrbetaln)check_random_state)drot) LinAlgError)get_lapack_funcs)binom)mvn) multivariate_normal matrix_normal dirichletwishart invwishart multinomialspecial_ortho_group ortho_grouprandom_correlation unitary_groupmultivariate_tmultivariate_hypergeomarandom_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. cCs|}|jdkr|d}|S)z_ Remove single-dimensional entries from array and convert to scalar, if necessary. r)Zsqueezendim)outrri/Users/vegardjervell/Documents/master/model/venv/lib/python3.9/site-packages/scipy/stats/_multivariate.py_squeeze_output1s r#cCsT|dur |}|dvr>|jj}ddd}||t|j}|tt|}|S)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)Ng@@g.A)fd)dtypecharlowernpZfinfoepsmaxabs)ZspectrumcondrcondtZfactorr+rrr"_eigvalsh_to_eps<s  r1h㈵>cstjfdd|DtdS)aA 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)rr)r-).0xr+rr" nz_pinv_1d..r')r*arrayfloat)vr+rr5r"_pinv_1d^sr<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)scipylinalgZeighr1r*min ValueErrorlenr r<multiplysqrtrankUsumloglog_pdet_pinv) selfMr.r/r)r>allow_singularsur+r&Zs_pinvrGrrr"__init__s     z _PSD.__init__cCs$|jdurt|j|jj|_|jSN)rKr*dotrGTrLrrr"pinvs z _PSD.pinv)NNTTT)__name__ __module__ __qualname____doc__rQpropertyrVrrrr"r=qs ' r=csDeZdZdZd fdd ZeddZejddZdd ZZ S) multi_rv_genericzc Class which encapsulates common functionality between all multivariate distributions. Ncstt||_dSrR)superrQr _random_staterLseed __class__rr"rQs zmulti_rv_generic.__init__cCs|jS)a Get 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. )r^rUrrr" random_states zmulti_rv_generic.random_statecCst||_dSrRr r^r_rrr"rcscCs|durt|S|jSdSrRrd)rLrcrrr"_get_random_statesz"multi_rv_generic._get_random_state)N) rWrXrYrZrQr[rcsetterre __classcell__rrrar"r\s  r\c@s*eZdZdZeddZejddZdS)multi_rv_frozenzj Class which encapsulates common functionality between all frozen multivariate distributions. cCs|jjSrR)_distr^rUrrr"rcszmulti_rv_frozen.random_statecCst||j_dSrR)r rir^r_rrr"rcsN)rWrXrYrZr[rcrfrrrr"rhs  rhamean : 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 t|t|jt|_dSrR)r]rQr docformatrZmvn_docdict_paramsr_rarr"rQ_s z multivariate_normal_gen.__init__rFcCst||||dS)zzCreate a frozen multivariate normal distribution. See `multivariate_normal_frozen` for more information. )rNr`)multivariate_normal_frozen)rLmeancovrNr`rrr"__call__csz multivariate_normal_gen.__call__cCs|dur^|durH|durd}q\tj|td}|jdkrArray 'cov' must be at most two-dimensional, but cov.ndim = %d)r*rr:r shapesizeisscalarrBzerosreshapeeyediagstrrC)rLdimrrrsrowscolsmsgrrr"_process_parameterslsV             z+multivariate_normal_gen._process_parameterscCs`tj|td}|jdkr$|tj}n8|jdkr\|dkrJ|ddtjf}n|tjddf}|Sl Adjust quantiles array so that last axis labels the components of each data point. r8rrNr*rr:r newaxisrLr4rrrr"_process_quantiless   z*multivariate_normal_gen._process_quantilescCs8||}tjtt||dd}d|t||S)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 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$axis)r*rHsquarerS_LOG_2PI)rLr4rrprec_UZ log_det_covrFdevmaharrr"_logpdfszmultivariate_normal_gen._logpdfcCsL|d||\}}}|||}t||d}||||j|j|j}t|S)aLog 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 NrN)rrr=rrGrJrFr#rLr4rrrsrNrZpsdr!rrr"logpdfs   zmultivariate_normal_gen.logpdfc CsR|d||\}}}|||}t||d}t||||j|j|j}t |S)aMultivariate 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 Nr) rrr=r*exprrGrJrFr#rrrr"pdfs   zmultivariate_normal_gen.pdfc s>tjtj fdd}t|d|}t|S)aLog of the multivariate normal cumulative distribution function. 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_sliceabsepsrsr)maxptsrrrelepsrr"$s z.multivariate_normal_gen._cdf..r$)r*fullrxinfZapply_along_axisr#) rLr4rrrsrrrZfunc1dr!rrr"_cdfszmultivariate_normal_gen._cdfr2c CsV|d||\}}}|||}t||d|s8d|}t|||||||} | S)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) 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=r*rIr rLr4rrrsrNrrrrr!rrr"logcdf)s  zmultivariate_normal_gen.logcdfc CsP|d||\}}}|||}t||d|s8d|}|||||||} | S)aMultivariate 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=rrrrr"cdfOs  zmultivariate_normal_gen.cdfcCs4|d||\}}}||}||||}t|S)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 N)rrerr#)rLrrrsryrcrr!rrr"rvsus zmultivariate_normal_gen.rvscCs<|d||\}}}tjdtjtj|\}}d|S)aGCompute 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?)rr*r@Zslogdetpie)rLrrrsr_logdetrrr"entropys zmultivariate_normal_gen.entropy)N)NrFN)NrF)NrF)NrFNr2r2)NrFNr2r2)NrrN)Nr)rWrXrYrZrQrtrrrrrrrrrrrgrrrar"rn s"S =  ! & & rnc@sHeZdZdddZddZd d Zd d Zd dZdddZddZ dS)rqNrFr2cCsZt||_|jd||\|_|_|_t|j|d|_|sDd|j}||_||_ ||_ dS)axCreate 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, `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.]]) Nrr) rnrirrrrrsr=cov_inforrr)rLrrrsrNr`rrrrrr"rQs-  z#multivariate_normal_frozen.__init__cCs:|j||j}|j||j|jj|jj|jj}t |SrR) rirrrrrrrGrJrFr#rLr4r!rrr"rs  z!multivariate_normal_frozen.logpdfcCst||SrRr*rrrLr4rrr"rszmultivariate_normal_frozen.pdfcCst||SrR)r*rIrrrrr"rsz!multivariate_normal_frozen.logcdfcCs8|j||j}|j||j|j|j|j|j}t |SrR) rirrrrrrsrrrr#rrrr"rs zmultivariate_normal_frozen.cdfcCs|j|j|j||SrR)rirrrrsrLryrcrrr"rszmultivariate_normal_frozen.rvscCs$|jj}|jj}d|td|S)zComputes the differential entropy of the multivariate normal. Returns ------- h : scalar Entropy of the multivariate normal distribution rr)rrJrFr)rLrJrFrrr"rs z"multivariate_normal_frozen.entropy)NrFNNr2r2)rN) rWrXrYrQrrrrrrrrrr"rqs 7 rq)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_notermcsbeZdZdZdfdd ZdddZdd Zd d Zd d ZdddZ dddZ dddZ Z S)matrix_normal_gena` 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. Parameters ---------- X : array_like Quantiles, with the last two axes of `X` denoting the components. %(_matnorm_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" 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. 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 -------- >>> 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 Ncs t|t|jt|_dSrR)r]rQrrorZmatnorm_docdict_paramsr_rarr"rQs zmatrix_normal_gen.__init__rcCst||||dS)zoCreate a frozen matrix normal distribution. See `matrix_normal_frozen` for more information. r`)matrix_normal_frozenrLrrrowcovcolcovr`rrr"rtszmatrix_normal_gen.__call__c Cs|durFtj|td}|j}t|dkr0tdt|dkrFtdtj|td}|jdkr|durz|t|d}q|td}n|jdkrt |}|j}t|dkrtd|d|dkrtd |ddkrtd |d}tj|td}|jdkr4|dur$|t|d}n|td}n|jdkrJt |}|j}t|dkrftd |d|dkrtd |ddkrtd |d}|dur|d|krtd|d|krtdnt ||f}||f} | |||fS)z Infer dimensionality from mean or covariance matrices. Handle defaults. Ensure compatible dimensions. Nr8rz%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*rr:rxrCrBanyr identityr~r{) rLrrrrZ meanshapeZrowshapenumrowsZcolshapenumcolsdimsrrr"rsZ            z%matrix_normal_gen._process_parameterscCsHtj|td}|jdkr*|tjddf}|jdd|krDtd|S)zp Adjust quantiles array so that last two axes labels the components of each data point. r8rNzJThe shape of array `X` is not compatible with the distribution parameters.)r*rr:r rrxrB)rLXrrrr"rs  z$matrix_normal_gen._process_quantilesc Csv|\}} tj||ddd} t|jt| |d} tjtjt| dddd} d|| t| |||| S)aLog 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. r$rrstartrrr)r*rollaxis tensordotrTrSrHrr) rLrrrrZ row_prec_rtZlog_det_rowcovZ col_prec_rtZlog_det_colcovrrZroll_devZ scale_devrrrr"rs zmatrix_normal_gen._logpdfc Cs`||||\}}}}|||}t|dd}t|dd}|||||j|j|j|j}t|S)aLog 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)rrr=rrGrJr#) rLrrrrrrrowpsdcolpsdr!rrr"rs    zmatrix_normal_gen.logpdfcCst|||||S)aMatrix 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)rLrrrrrrrr"r5szmatrix_normal_gen.pdfc Cst|}||||\}}}}tjj|dd}tjj|dd}||}|j|d||dfd} t|t | |j d} tj | j ddd|tj ddddf} |dkr| |j} | S)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)rrryrN)intrr?r@choleskyreZstandard_normalr*rrSrTrrr|rx) rLrrrrryrcrZrowcholZcolcholZstd_normZroll_rvsr!rrr"rJs  * zmatrix_normal_gen.rvs)N)NrrN)Nrr)Nrr)NrrrN) rWrXrYrZrQrtrrrrrrrgrrrar"r4sc B &  rc@s4eZdZdZd ddZddZdd Zd d d ZdS)raCreate 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 (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 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 NrcCsNt||_|j|||\|_|_|_|_t|jdd|_t|jdd|_ dS)NFr) rrirrrrrrr=rrrrrr"rQs  zmatrix_normal_frozen.__init__c CsD|j||j}|j|j||j|jj|jj|jj|jj}t |SrR) rirrrrrrrGrJrr#)rLrr!rrr"rs  zmatrix_normal_frozen.logpdfcCst||SrRr)rLrrrr"rszmatrix_normal_frozen.pdfcCs|j|j|j|j||SrR)rirrrrrrrrr"rszmatrix_normal_frozen.rvs)NrrN)rN)rWrXrYrZrQrrrrrrr"rps  r)rrrzalpha : array_like The concentration parameters. The number of entries determines the dimensionality of the distribution. )!_dirichlet_doc_default_callparamsrmcCs@t|}t|dkr"tdn|jdkrzOThe input vector 'x' must lie within the normal simplex. but np.sum(x, 0) = %s.)r*rrxrBr9rHr appendZvstackrAr,repeatr| logical_andr-r)rr4ZxkZxeq0Zalphalt1Zchkrrr"_dirichlet_check_inputs8 ,       rcCstt|tt|S)avInternal 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*rHrrrrr"_lnBsrcsfeZdZdZdfdd ZdddZddZd d Zd d Zd dZ ddZ ddZ dddZ Z S) dirichlet_gena 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 ``entropy(alpha)`` Compute the differential entropy of the Dirichlet distribution. Parameters ---------- x : array_like Quantiles, with the last axis of `x` denoting the components. %(_dirichlet_doc_default_callparams)s %(_doc_random_state)s 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. 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 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 -------- >>> 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]]) Ncs t|t|jt|_dSrR)r]rQrrorZdirichlet_docdict_paramsr_rarr"rQzs zdirichlet_gen.__init__cCs t||dS)Nr)dirichlet_frozenrLrr`rrr"rt~szdirichlet_gen.__call__cCs(t|}| tt|d|jjdS)aLog 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*rHrrT)rLr4rlnBrrr"rszdirichlet_gen._logpdfcCs&t|}t||}|||}t|S)ayLog 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`. )rrrr#rLr4rr!rrr"rs  zdirichlet_gen.logpdfcCs,t|}t||}t|||}t|S)akThe 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*rrr#rrrr"rs zdirichlet_gen.pdfcCst|}|t|}t|S)zCompute the mean of the dirichlet distribution. Parameters ---------- %(_dirichlet_doc_default_callparams)s Returns ------- mu : ndarray or scalar Mean of the Dirichlet distribution. rr*rHr#)rLrr!rrr"rrs zdirichlet_gen.meancCs6t|}t|}||||||d}t|S)aCompute the variance of the dirichlet distribution. Parameters ---------- %(_dirichlet_doc_default_callparams)s Returns ------- v : ndarray or scalar Variance of the Dirichlet distribution. rr)rLralpha0r!rrr"vars zdirichlet_gen.varcCs^t|}t|}t|}|jd}|||tj|t|dtj|}t|S)aCompute the differential entropy of the dirichlet distribution. Parameters ---------- %(_dirichlet_doc_default_callparams)s Returns ------- h : scalar Entropy of the Dirichlet distribution rr) rr*rHrrxr?Zspecialrr#)rLrrrKr!rrr"rs  zdirichlet_gen.entropyrcCs t|}||}|j||dS)aDraw random samples from a Dirichlet distribution. Parameters ---------- %(_dirichlet_doc_default_callparams)s size : int, 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. r)rrer)rLrryrcrrr"rs zdirichlet_gen.rvs)N)N)rN)rWrXrYrZrQrtrrrrrrrrrgrrrar"rsj rc@sHeZdZdddZddZddZdd Zd d Zd d ZdddZ dS)rNcCst||_t||_dSrR)rrrrirrrr"rQs zdirichlet_frozen.__init__cCs|j||jSrR)rirrrrrr"rszdirichlet_frozen.logpdfcCs|j||jSrR)rirrrrrr"rszdirichlet_frozen.pdfcCs|j|jSrR)rirrrrUrrr"rr szdirichlet_frozen.meancCs|j|jSrR)rirrrUrrr"r#szdirichlet_frozen.varcCs|j|jSrR)rirrrUrrr"r&szdirichlet_frozen.entropyrcCs|j|j||SrR)rirrrrrr"r)szdirichlet_frozen.rvs)N)rN) rWrXrYrQrrrrrrrrrrr"rs r)rrrrrrrzdf : 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 )Z_doc_default_callparamsZ_doc_callparams_notermcseZdZdZd,fdd Zd-ddZddZd d Zd d Zd dZ ddZ ddZ ddZ ddZ ddZddZddZddZdd Zd!d"Zd.d$d%Zd&d'Zd(d)Zd*d+ZZS)/ wishart_gena 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 ---------- x : array_like Quantiles, with the last axis of `x` denoting the components. %(_doc_default_callparams)s %(_doc_random_state)s 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. 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. 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 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) The input quantiles can be any shape of array, as long as the last axis labels the components. Ncs t|t|jt|_dSrRr]rQrrorZwishart_docdict_paramsr_rarr"rQs zwishart_gen.__init__cCs t|||S)zbCreate a frozen Wishart distribution. See `wishart_frozen` for more information. )wishart_frozenrLdfscaler`rrr"rtszwishart_gen.__call__cCs|dur d}tj|td}|jdkr6|tjtjf}n`|jdkrLt|}nJ|jdkr~|jd|jdks~tdt|jn|jdkrtd|j|jd}|dur|}n(t |stdn||dkrtd |||fS) Nrur8rrrzLArray 'scale' must be square if it is two dimensional, but scale.scale = %s.zBArray '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*rr:r rr~rxrBrrz)rLrrrrrr"rs.        zwishart_gen._process_parameterscCsXtj|td}|jdkr:|t|ddddtjf}|jdkr|dkrd|tjtjddf}nt|ddddtjf}n|jdkr|jd|jdkstdt |j|ddddtjf}nP|jdkr|jd|jdkstdt |jn|jdkrtd |j|jdd||fksTtd ||f|jddf|S) rr8rNrrzGQuantiles must be square if they are two dimensional, but x.shape = %s.zeQuantiles must be square in the first two dimensions if they are three dimensional, but x.shape = %s.znQuantiles must be at most two-dimensional with an additional dimension for multiplecomponents, but x.ndim = %dz=Quantiles have incompatible dimensions: should be %s, got %s.) r*rr:r r}rr~rxrBrrrrr"rs6 "     zwishart_gen._process_quantilescCsVt|}|jdkr |tj}n|jdkr>tdtt||}t|}||fS)Nrrz_Size must be an integer or tuple of integers; thus must have dimension <= 1. Got size.ndim = %s)r*rr rrBrtupleprod)rLrynrxrrr" _process_size s     zwishart_gen._process_sizec Cst|jd}t|j}t|jd} t|jdD]|} ||dddd| f\} || <tj|df|dddd| f|dddd| f<|dddd| f| | <q:d||d|d| d||t d||t d||} | S)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 triagular. Notes ----- As this function does no argument checking, it should not be called directly; use 'logpdf' instead. r$NTrr) r*emptyrxrange_cholesky_logdetr?r@ cho_solvetrace_LOG_2r) rLr4rrr log_det_scaleC log_det_xZ scale_inv_xZtr_scale_inv_xirr!rrr"rs $6  zwishart_gen._logpdfcCsH|||\}}}|||}||\}}|||||||}t|S)aLog of the 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 rrrrr#)rLr4rrrrrr!rrr"rFs  zwishart_gen.logpdfcCst||||S)aWishart 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 rrLr4rrrrr"rcszwishart_gen.pdfcCs||S)aAMean of the 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. rrLrrrrrr"_meanyszwishart_gen._meancCs(|||\}}}||||}t|S)zMean of the Wishart distribution. Parameters ---------- %(_doc_default_callparams)s Returns ------- mean : float The mean of the distribution rrr#rLrrrr!rrr"rrs zwishart_gen.meancCs&||dkr||d|}nd}|S)aAMode of the 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. rNrrLrrrr!rrr"_modes zwishart_gen._modecCs4|||\}}}||||}|dur0t|S|S)aEMode of the Wishart distribution Only valid if the degrees of freedom are greater than the dimension of the scale matrix. Parameters ---------- %(_doc_default_callparams)s Returns ------- mode : float or None The Mode of the distribution Nrrr#rrrr"modeszwishart_gen.modecCs,|d}|}|t||7}||9}|S)aDVariance of the 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. rdiagonalr*outerrLrrrrr~rrr"_vars zwishart_gen._varcCs(|||\}}}||||}t|S)zVariance of the Wishart distribution. Parameters ---------- %(_doc_default_callparams)s Returns ------- var : float The variance of the distribution rrr#rrrr"rs zwishart_gen.varc s||dd}j|d||f}tjfddt|D|f|dddj}t|||f} ttdddgt |} tj |dd} || | | <t |} || | | <| S) ax 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. Notes ----- As this function does no argument checking, it should not be called directly; use 'rvs' instead. rrrcs*g|]"}j|ddddqS)rrr) chisquarer3rrrrcrr"r6 sz-wishart_gen._standard_rvs..Nr$k) normalr|r*r_rrTr{rslicerCZ tril_indicesZ diag_indices) rLrrxrrrcZn_trilZ covariancesZ variancesAZsize_idxZtril_idxZdiag_idxrrr" _standard_rvss(    zwishart_gen._standard_rvsc CsR||}||||||}t|D]&}t|||} t| | j||<q&|S)a]Draw 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. )rer r*ndindexrSrT) rLrrxrrrrcr indexCArrr"_rvss   zwishart_gen._rvsrc CsL||\}}|||\}}}tjj|dd}|||||||} t| S)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 Tr)rrr?r@rrr#) rLrrryrcrrxrrr!rrr"rHs zwishart_gen.rvscsjd|d|d||dttd|d|dtfddt|Dd|S)aCompute 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. rrcs$g|]}tdd|dqS)rr)rrrrr"r6~r7z(wishart_gen._entropy..)rrr*rHr)rLrrrrrr"_entropygs  zwishart_gen._entropycCs.|||\}}}||\}}||||S)a'Compute the differential entropy of the Wishart. Parameters ---------- %(_doc_default_callparams)s Returns ------- h : scalar Entropy of the Wishart distribution Notes ----- %(_doc_callparams_note)s )rrr)rLrrrrrrrr"rszwishart_gen.entropycCs0tjj|dd}dtt|}||fS)aCompute 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. Trr)r?r@rr*rHrIr)rLrZc_decomprrrr"rszwishart_gen._cholesky_logdet)N)NNN)rN)rWrXrYrZrQrtrrrrrrrrrrrrrr rrrrrrgrrrar"rSs*i %.4- rc@sTeZdZdZdddZddZddZd d Zd d Zd dZ dddZ ddZ dS)raeCreate 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. NcCs>t||_|j||\|_|_|_|j|j\|_|_dSrR) rrirrrrrrrrrrr"rQs  zwishart_frozen.__init__cCs8|j||j}|j||j|j|j|j|j}t|SrR) rirrrrrrrr#rrrr"rs zwishart_frozen.logpdfcCst||SrRrrrrr"rszwishart_frozen.pdfcCs|j|j|j|j}t|SrRrirrrrr#rLr!rrr"rrszwishart_frozen.meancCs*|j|j|j|j}|dur&t|S|SrRrirrrrr#rrrr"rszwishart_frozen.modecCs|j|j|j|j}t|SrRrirrrrr#rrrr"rszwishart_frozen.varrcCs4|j|\}}|j|||j|j|j|}t|SrRrirrrrrr#rLryrcrrxr!rrr"rs zwishart_frozen.rvscCs|j|j|j|jSrR)rirrrrrUrrr"rszwishart_frozen.entropy)N)rN) rWrXrYrZrQrrrrrrrrrrrr"rs  r)rrrrrrrrTc Cs*|rt|}nt|}t|jdks8|jd|jdkr@tdtd|f\}}tj|jddd\}}t|jddD]}|||d d d d \||<}|d krt d ||d krtd| |||d d d\||<}|d krt d|d krtd| ||||f||||f<q||S)a* Invert the matrices a_i, using a Cholesky factorization of A, where a_i resides in the last two dimensions of a and the other indices describe the index i. Overwrites the data in a. Parameters ---------- a : array Array of matrices to invert, where the matrices themselves are stored in the last two dimensions. 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. Returns ------- x : array Array of inverses of the matrices ``a_i``. See Also -------- scipy.linalg.cholesky : Cholesky factorization of a matrix rrr$z-expected square matrix in last two dimensions)potrfpotrirrNTF)r)Z overwrite_acleanrz)%d-th leading minor not positive definitez1illegal value in %d-th argument of internal potrf)r)Z overwrite_cz!the inverse could not be computed) rrrCrxrBrr*Z triu_indicesrr ) ar>Za1rrZ triu_rowsZ triu_colsrinforrr"_cho_inv_batchs8 "  rcseZdZdZd fdd Zd!ddZddZd d Zd d Zd dZ ddZ ddZ ddZ ddZ ddZfddZd"ddZddZZS)#invwishart_gena 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. Parameters ---------- x : array_like Quantiles, with the last axis of `x` denoting the components. %(_doc_default_callparams)s %(_doc_random_state)s 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. 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. 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}`. .. 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. Examples -------- >>> 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) The input quantiles can be any shape of array, as long as the last axis labels the components. Ncs t|t|jt|_dSrRrr_rarr"rQ s zinvwishart_gen.__init__cCs t|||S)znCreate a frozen inverse Wishart distribution. See `invwishart_frozen` for more information. )invwishart_frozenrrrr"rt szinvwishart_gen.__call__c Cst|jd}t|j}|dkr.t|nd|}t|jd}t|jdD]^} tjj |dddd| fdd\} } dt t | || <t ||| || <qTd||d|d||td||d|td||} | S) agLog 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 scale : ndarray Scale matrix 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 'logpdf' instead. r$rruNTrrr)r*rrxcopyrTrrr?r@ cho_factorrHrIrrSrrr) rLr4rrrrrZx_invZtr_scale_x_invrrr)r!rrr"r s   &" zinvwishart_gen._logpdfcCsF|||\}}}|||}||\}}||||||}t|S)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 r)rLr4rrrrrr!rrr"r s  zinvwishart_gen.logpdfcCst||||S)aInverse 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 rrrrr"r szinvwishart_gen.pdfcCs&||dkr|||d}nd}|S)aIMean 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. rNrrrrr"r s zinvwishart_gen._meancCs4|||\}}}||||}|dur0t|S|S)aXMean 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 Nrrrrr"rr szinvwishart_gen.meancCs|||dS)aIMode 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. rrrrrr"r- szinvwishart_gen._modecCs(|||\}}}||||}t|S)zMode of the inverse Wishart distribution. Parameters ---------- %(_doc_default_callparams)s Returns ------- mode : float The Mode of the distribution rrrrr"r> s zinvwishart_gen.modecCsv||dkrn||d|d}|}|||dt||7}|||||dd||d}nd}|S)aLVariance 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. rrrNrrrrr"rO s *zinvwishart_gen._varcCs4|||\}}}||||}|dur0t|S|S)aXVariance 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 Nrrrrr"rg szinvwishart_gen.varc s||}t|||||}t|}td|f} t|jddD]p} t||| } |dkr| | |dd\} } | dkrt d| dkrt d | nd | } t| j | || <qH|S) aeDraw 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 triagular. %(_doc_random_state)s Notes ----- As this function does no argument checking, it should not be called directly; use 'rvs' instead. trtrsNrrTrrzSingular matrix.z1Illegal value in %d-th argument of internal trtrsru) rer]r r*r}rrrxrSr rBrT) rLrrxrrrrcr r}r$rrrrarr"rz s"   zinvwishart_gen._rvsrcCs|||\}}|||\}}}t|}tjj|dd\} } tj| | f|} tjj| dd} | ||||| |} t | S)a Draw 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 Tr) rrr*r}r?r@r#rrrr#)rLrrryrcrrxrr}Lr) inv_scalerr!rrr"r s zinvwishart_gen.rvscCstdSrRAttributeErrorrUrrr"r szinvwishart_gen.entropy)N)NNN)rN)rWrXrYrZrQrtrrrrrrrrrrrrrrgrrrar"r 8 sb - 1 #r c@sPeZdZdddZddZddZdd Zd d Zd d ZdddZ ddZ dS)r!NcCst||_|j||\|_|_|_tjj|jdd\}}dt t | |_ t |j}tj||f||_tjj|jdd|_dS)aGCreate 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. TrrN)r rirrrrr?r@r#r*rHrIrrr}rr&rr)rLrrr`rr)r}rrr"rQ s  zinvwishart_frozen.__init__cCs4|j||j}|j||j|j|j|j}t|SrR)rirrrrrrr#rrrr"r s zinvwishart_frozen.logpdfcCst||SrRrrrrr"r szinvwishart_frozen.pdfcCs*|j|j|j|j}|dur&t|S|SrRrrrrr"rr szinvwishart_frozen.meancCs|j|j|j|j}t|SrRrrrrr"r szinvwishart_frozen.modecCs*|j|j|j|j}|dur&t|S|SrRrrrrr"r szinvwishart_frozen.varrcCs4|j|\}}|j|||j|j|j|}t|SrRrrrrr"r s zinvwishart_frozen.rvscCstdSrRr'rUrrr"r szinvwishart_frozen.entropy)N)rN) rWrXrYrQrrrrrrrrrrrr"r! s ! r!)rrrrrrrzsn : int Number of trials p : array_like Probability of a trial falling into each category; should sum to 1 a`n` should be a positive 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. cs~eZdZdZdfdd ZdddZddZd d Zd d Zd dZ ddZ ddZ ddZ ddZ ddZdddZZS)multinomial_gena 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 ---------- x : array_like Quantiles, with the last axis of `x` denoting the components. %(_doc_default_callparams)s %(_doc_random_state)s Notes ----- %(_doc_callparams_note)s Alternatively, the object may be called (as a function) to fix the `n` and `p` parameters, returning a "frozen" multinomial random variable: 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])``. 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. Ncs t|t|jt|_dSrR)r]rQrrorZmultinomial_docdict_paramsr_rarr"rQ s  zmultinomial_gen.__init__cCs t|||S)zjCreate a frozen multinomial distribution. See `multinomial_frozen` for more information. )multinomial_frozen)rLrpr`rrr"rt szmultinomial_gen.__call__cCstj|tjdd}d|dddfjdd|d<tj|d kdd}|tj|d kddO}tj|tjdd}|d k}||||BfS) zReturns: n_, p_, npcond. n_ and p_ are arrays of the correct shape; npcond is a boolean array flagging values out of the domain. T)r'r"ru.Nr$r).r$rr)r*r9float64rHrint_)rLrr,Zpcondncondrrr"r s z#multinomial_gen._process_parameterscCstj|tjd}|jdkr"td|jdkr\|jd|jdks\td|jd|jdftj||kdd}|tj|dkddO}|tj|dd|kB}||fS)z}Returns: x_, xcond. x_ is an int array; xcond is a boolean array flagging values out of the domain. r8rzx must be an array.r$zHSize of each quantile should be size of p: received %d, but expected %d.r) r*rr.r rBryrxrrH)rLr4rr,xxr.rrr"r s z"multinomial_gen._process_quantilescCs<t|}|jdkr|||<n|r8|jdkr0|S||d<|S)Nr.r*rr rLresultr.Z bad_valuerrr" _checkresult s    zmultinomial_gen._checkresultcCs,t|dtjt||t|dddS)Nrr$r)rr*rHrrLr4rr,rrr"_logpmf szmultinomial_gen._logpmfc Cs~|||\}}}||||\}}||||}|tj|jtjdB}|||tj}|tj|jtjdB}|||tj S)aLog 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 r8) rrr6r*r{rxbool_r4NINFNAN) rLr4rr,npcondxcondr3xcond_Znpcond_rrr"logpmf szmultinomial_gen.logpmfcCst||||S)aMultinomial 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*rr=r5rrr"pmf szmultinomial_gen.pmfcCs4|||\}}}|dtjf|}|||tjS)zMean of the Multinomial distribution. Parameters ---------- %(_doc_default_callparams)s Returns ------- mean : float The mean of the distribution .)rr*rr4r9)rLrr,r:r3rrr"rr# s zmultinomial_gen.meancCs~|||\}}}|dtjtjf}|td| |}t|jdD]&}|d||f||d|f7<qF|||tjS)zCovariance matrix of the multinomial distribution. Parameters ---------- %(_doc_default_callparams)s Returns ------- cov : ndarray The covariance matrix of the distribution .z...j,...k->...jkr$)rr*reinsumrrxr4nan)rLrr,r:nnr3rrrr"rs3 s $zmultinomial_gen.covcCs|||\}}}tjdt|d}|tjt|dd}|t|d8}|dtjf}t|j|j|jd}|j d|7_ tjt |||t|ddd|fd}| |||tj S)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 rr$r.)r)rr*r r,rHr rrr rxrr?r4rA)rLrr,r:r4Zterm1Znew_axes_neededZterm2rrr"rJ s zmultinomial_gen.entropycCs*|||\}}}||}||||S)aDraw 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 )rrer)rLrr,ryrcr:rrr"rq s zmultinomial_gen.rvs)N)N)NN)rWrXrYrZrQrtrrr4r6r=r?rrrsrrrgrrrar"r)C sf   'r)c@sLeZdZdZdddZddZddZd d Zd d Zd dZ dddZ dS)r+agCreate a frozen Multinomial distribution. Parameters ---------- n : int number of trials p: array_like probability of a trial falling into each category; should sum to 1 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. Ncs<t|_j||\___fdd}|j_dS)NcsjjjfSrR)rr,r:)rr,rUrr"r sz8multinomial_frozen.__init__.._process_parameters)r)rirrr,r:)rLrr,r`rrrUr"rQ s  zmultinomial_frozen.__init__cCs|j||j|jSrR)rir=rr,rrrr"r= szmultinomial_frozen.logpmfcCs|j||j|jSrR)rir?rr,rrrr"r? szmultinomial_frozen.pmfcCs|j|j|jSrR)rirrrr,rUrrr"rr szmultinomial_frozen.meancCs|j|j|jSrR)rirsrr,rUrrr"rs szmultinomial_frozen.covcCs|j|j|jSrR)rirrr,rUrrr"r szmultinomial_frozen.entropyrcCs|j|j|j||SrR)rirrr,rrrr"r szmultinomial_frozen.rvs)N)rN) rWrXrYrZrQr=r?rrrsrrrrrr"r+ s r+)r=r?rrrsrcs>eZdZdZd fdd Zd ddZddZdd d ZZS)special_ortho_group_genaA matrix-valued SO(N) random variable. Return a random rotation matrix, drawn from the Haar distribution (the only uniform distribution on SO(n)). 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 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 -------- >>> 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. See Also -------- ortho_group, scipy.spatial.transform.Rotation.random Ncst|t|j|_dSrRr]rQrrorZr_rarr"rQ s z special_ortho_group_gen.__init__cCs t||dS)zlCreate a frozen SO(N) distribution. See `special_ortho_group_frozen` for more information. r)special_ortho_group_frozenrLrr`rrr"rt sz special_ortho_group_gen.__call__cCs2|dus&t|r&|dks&|t|kr.td|S)5Dimension N must be specified; it cannot be inferred.NrzmDimension of rotation must be specified, and must be a scalar greater than 1.r*rzrrBrLrrrr"r s&z+special_ortho_group_gen._process_parametersrc sht|}|dkr:tfddt|DSt}tf}tdD]}j|fd}t ||}|d } |ddkrt |dnd||<|d||t |7<|t || d|ddd}|dd|dft t |dd|df||8<qfd d|dd |d <||jj}|S) asDraw 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) rcsg|]}jddqSrryrcrrrrcrLrr"r6( sz/special_ortho_group_gen.rvs..rrr@Nr$)rerr*r9rrr}rr rSitemsignrErrrT) rLrryrcHDrr4norm2x0rrMr"r s(      "&>  zspecial_ortho_group_gen.rvs)N)NN)rN) rWrXrYrZrQrtrrrgrrrar"rC s 9 rCc@s eZdZdddZdddZdS) rENcCst||_|j||_dS)aCreate 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)rCrirrrFrrr"rQB s z#special_ortho_group_frozen.__init__rcCs|j|j||SrR)rirrrrrr"r] szspecial_ortho_group_frozen.rvs)NN)rN)rWrXrYrQrrrrr"rEA s rEcs4eZdZdZd fdd ZddZd dd ZZS) ortho_group_genaA matrix-valued O(N) random variable. Return a random orthogonal matrix, drawn from the O(N) Haar distribution (the only uniform distribution on O(N)). The `dim` keyword specifies the dimension N. Methods ------- ``rvs(dim=None, size=1, random_state=None)`` Draw random samples from O(N). Parameters ---------- dim : scalar Dimension of matrices Notes ----- This class is closely related to `special_ortho_group`. Some care is taken to avoid numerical error, as per the paper by Mezzadri. References ---------- .. [1] F. Mezzadri, "How to generate random matrices from the classical compact groups", :arXiv:`math-ph/0609050v2`. Examples -------- >>> 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. Ncst|t|j|_dSrRrDr_rarr"rQ s zortho_group_gen.__init__cCs2|dus&t|r&|dks&|t|kr.td|SrGNrzLDimension of rotation must be specified,and must be a scalar greater than 1.rHrIrrr"r s&z#ortho_group_gen._process_parametersrc s6t|}|dkr:tfddt|DSt}tD]}j|fd}t||}|d }|ddkrt |dnd} |d| t |7<|t ||d|ddd}| |dd|dft t|dd|df|||dd|df<qV|S) arDraw 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) rcsg|]}jddqSrJrLrrMrr"r6 sz'ortho_group_gen.rvs..rrrrNN) rerr*r9rrr}r rSrOrPrEr) rLrryrcrQrr4rSrTrRrrMr"r s"      &Pzortho_group_gen.rvs)N)rNrWrXrYrZrQrrrgrrrar"rUa s/rUcsDeZdZdZdfdd ZddZddZd d Zdd dZZ S)random_correlation_gena0A 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. 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 -------- >>> 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.07198934, -0.20411041, -0.24385796], [-0.07198934, 1. , 0.12968613, -0.29471382], [-0.20411041, 0.12968613, 1. , 0.2828693 ], [-0.24385796, -0.29471382, 0.2828693 , 1. ]]) >>> import scipy.linalg >>> e, v = scipy.linalg.eigh(x) >>> e array([ 0.5, 0.8, 1.2, 1.5]) Ncst|t|j|_dSrRrDr_rarr"rQ s zrandom_correlation_gen.__init__cCstj|td}|j}|jdks4|jd|ks4|dkr= 1 and floating point issues do not occur. Otherwise, some other valid rotation is returned. When tr(M)==2, also bjj=1. rur)grur)mathrEr,copysign) rLZaiiZajjZaijZaiidZajjdddr0crOrrr" _givens_to_1sz#random_correlation_gen._givens_to_1cCs>|jjr(|jtjkr(|jd|jdks.t|jd}t|dD]}|||fdkr\qDnb|||fdkrt|d|D]}|||fdkrzqqzn(t|d|D]}|||fdkrqq||||f|||f|||f\}}| }t |||| |||d||dddd t |||| |||||ddd qD|S)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)rZoffxZincxZoffyZincyZ overwrite_xZ overwrite_y) flags c_contiguousr'r*r-rxrBrr`Zravelr )rLmr&rjr_rOmvrrr"_to_corr0s4 *zrandom_correlation_gen._to_corrvIh%<=Hz>cCst|j||d\}}||}tj||d}tt|t||j}||}t | d |krpt d|S)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[)rcrz-Failed to generate a valid correlation matrix) rrerrr*rSr~rTrfr-rr, RuntimeError)rLrZrcr[Zdiag_tolrrcrrr"rYs  zrandom_correlation_gen.rvs)N)Nrgrh) rWrXrYrZrQrr`rfrrgrrrar"rX s 2!)rXcs4eZdZdZd fdd ZddZd dd ZZS) unitary_group_genaA 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 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 -------- >>> 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]]) This generates one random matrix from U(3). The dot product confirms that it is unitary up to machine precision. Ncst|t|j|_dSrRrDr_rarr"rQs zunitary_group_gen.__init__cCs2|dus&t|r&|dks&|t|kr.td|SrVrHrIrrr"rs&z%unitary_group_gen._process_parametersrcst|}|dkr:tfddt|DSdtdjfddjfd}t j |\}}| }||t |9}|S)aiDraw 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) rcsg|]}jddqSrJrLrrMrr"r6sz)unitary_group_gen.rvs..rry?)rerr*r9rrr\rEr r?r@Zqrrr-)rLrryrczqrr&rrMr"rs  zunitary_group_gen.rvs)N)rNrWrrrar"rjs(rja 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_notermcsbeZdZdZdfdd 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*t|t|jt|_t||_dS)zInitialize a multivariate t-distributed random variable. Parameters ---------- seed : Random state. N)r]rQrrorZmvt_docdict_paramsr r^r_rarr"rQBs zmultivariate_t_gen.__init__rFcCs,|tjkrt||||dSt|||||dS)zjCreate a frozen multivariate t-distribution. See `multivariate_t_frozen` for parameters. )rrrsrNr`)locrxrrNr`)r*rrqmultivariate_t_frozen)rLrrrxrrNr`rrr"rtNs zmultivariate_t_gen.__call__c CsT||||\}}}}|||}t||d}||||j|j|||j}t|S)acMultivariate 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=rrGrJrFr*r) rLr4rrrxrrNr shape_inforrrr"r[s  zmultivariate_t_gen.pdfc CsF||||\}}}}|||}t|}||||j|j|||jS)aLog 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=rrGrJrF)rLr4rrrxrrrtrrr"rzs  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$rrrNrru) r*rrrrrSrHrrIrr#)rLr4rrrrJrrrFrrr0r BrrRErrr"rs   zmultivariate_t_gen._logpdfc Cs||||\}}}}|dur(t|}n|j}t|rDt|}n|j||d|}|jt|||d} || t |dddf} t | S)aDraw 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]]) Nr) rr r^r*isinfZonesrrr{rEr#) rLrrrxrryrcrrngr4rkZsamplesrrr"rs    zmultivariate_t_gen.rvscCs`tj|td}|jdkr$|tj}n8|jdkr\|dkrJ|ddtjf}n|tjddf}|Srrrrrr"rs   z%multivariate_t_gen._process_quantilescCs|dur2|dur2tjdtd}tjdtd}d}n|durntj|td}|jdkrXd}n |jd}t|}nJ|durtj|td}|j}t|}n"tj|td}tj|td}|j}|dkr|d}|dd}|jdks|jd|krt d||jdkr|t|}n|jdkr.t |}n~|jdkr|j||fkr|j\}}||krndt |j}nd}|t |jt |f}t |n|jdkrt d |j|durd}n(|dkrt d nt |rt d ||||fS) z Infer dimensionality from location array and shape matrix, handle defaults, and ensure compatible dimensions. Nrr8rrz*Array 'loc' must be a vector of length %d.rvzSDimension mismatch: array 'cov' is of shape %s, but 'loc' is a vector of length %d.rwz'df' must be greater than zero.z8'df' is 'nan' but must be greater than zero or 'np.inf'.)r*rr:r rxr{ryr}r|rBr~rrCisnan)rLrrrxrrrrrrrr"rs`                 z&multivariate_t_gen._process_parameters)N)NrrFN)NrrF)Nrr)NrrrN) rWrXrYrZrQrtrrrrrrrgrrrar"rps?   #+ /rpc@s0eZdZd ddZddZdd Zd d d ZdS)rsNrFcCsPt||_|j|||\}}}}||||f\|_|_|_|_t||d|_dS)aCreate 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) rprirrrrrxrr=rt)rLrrrxrrNr`rrrr"rQEs zmultivariate_t_frozen.__init__c CsB|j||j}|jj}|jj}|j||j|||j|j|jj SrR) rirrrtrGrJrrrrrF)rLr4rGrJrrr"r^s zmultivariate_t_frozen.logpdfcCst||SrRrrrrr"reszmultivariate_t_frozen.pdfcCs|jj|j|j|j||dS)N)rrrxrryrc)rirrrrxrrrrr"rhs  zmultivariate_t_frozen.rvs)NrrFN)rN)rWrXrYrQrrrrrrr"rsCs  rszm : array_like The number of each type of object in the population. That is, :math:`m[i]` is the number of objects of type :math:`i`. n : array_like The number of samples taken from the population. a`m` must be an array of positive integers. If the quantile :math:`i` contains values out of the range :math:`[0, m_i]` where :math:`m_i` is the number of objects of type :math:`i` in the population or if the parameters are inconsistent with one another (e.g. ``x.sum() != n``), methods return the appropriate value (e.g. ``0`` for ``pmf``). If `m` or `n` contain negative values, the result will contain ``nan`` there. cs~eZdZdZdfdd ZdddZddZd d Zd d Zd dZ ddZ ddZ ddZ ddZ ddZdddZZS)multivariate_hypergeom_genaA multivariate hypergeometric random variable. Methods ------- ``pmf(x, m, n)`` Probability mass function. ``logpmf(x, m, n)`` Log of the probability mass function. ``rvs(m, n, size=1, random_state=None)`` Draw random samples from a multivariate hypergeometric distribution. ``mean(m, n)`` Mean of the multivariate hypergeometric distribution. ``var(m, n)`` Variance of the multivariate hypergeometric distribution. ``cov(m, n)`` Compute the covariance matrix of the multivariate hypergeometric distribution. Parameters ---------- %(_doc_default_callparams)s %(_doc_random_state)s Notes ----- %(_doc_callparams_note)s The probability mass function for `multivariate_hypergeom` is .. math:: P(X_1 = x_1, X_2 = x_2, \ldots, X_k = x_k) = \frac{\binom{m_1}{x_1} \binom{m_2}{x_2} \cdots \binom{m_k}{x_k}}{\binom{M}{n}}, \\ \quad (x_1, x_2, \ldots, x_k) \in \mathbb{N}^k \text{ with } \sum_{i=1}^k x_i = n where :math:`m_i` are the number of objects of type :math:`i`, :math:`M` is the total number of objects in the population (sum of all the :math:`m_i`), and :math:`n` is the size of the sample to be taken from the population. .. versionadded:: 1.6.0 Examples -------- To evaluate the probability mass function of the multivariate hypergeometric distribution, with a dichotomous population of size :math:`10` and :math:`20`, at a sample of size :math:`12` with :math:`8` objects of the first type and :math:`4` objects of the second type, use: >>> 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/_downloads/pdf/multi_hyper.pdf Ncs t|t|jt|_dSrR)r]rQrrorZmhg_docdict_paramsr_rarr"rQs z#multivariate_hypergeom_gen.__init__cCst|||dS)zCreate a frozen multivariate_hypergeom distribution. See `multivariate_hypergeom_frozen` for more information. r)multivariate_hypergeom_frozen)rLrcrr`rrr"rtsz#multivariate_hypergeom_gen.__call__c Cst|}t|}|jdkr(|t}|jdkr<|t}t|jtjsTtdt|jtjsltd|j dkr~t d|jdkr|dtj f}t ||\}}|jdkr|d}|dk}|j dd}|dk||kB}|||||tj|dd|BfS) 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...rr$r)r*rryZastyper issubdtyper'integer TypeErrorr rBrbroadcast_arraysrHr)rLrcrmcondrMr/rrr"rs*          z.multivariate_hypergeom_gen._process_parametersc Cst|}t|jtjs"td|jdkr4td|jd|jdksjtd|jdd|jdd|j dkr|dtj f}|dtj f}t ||||\}}}}|j dkr|d |d }}|dk||kB}|||||tj |dd |j dd |kBfS) Nz'x' must an array of integers.rz1'x' must be an array with at least one dimension.r$z4Size of each quantile must be size of 'm': received z, but expected ..r}r)r*rr~r'rrr rBrxryrrrrH)rLr4rMrcrr;rrr"r>s*      z-multivariate_hypergeom_gen._process_quantilescCs<t|}|jdkr|||<n|r&|S|jdkr8|dS|S)Nrrr1r2rrr"r4Ys    z'multivariate_hypergeom_gen._checkresultc Cstj|tjd}tj|tjd}||||}}||||}}t|ddt|d||d||<t|ddt|d||d||<tj||<tj||<|jdd}||S)Nr8rr$r)r*Z zeros_likeZfloat_r rArH) rLr4rMrcrmxcondr/numZdenrrr"r6cs**   z"multivariate_hypergeom_gen._logpmfcCs|||\}}}}}}|||||\}}}}}} ||B} |tj|jtjdB}|||||| |} | tj|jtjdB} || | tj} |tj| jtjdB} || | tj S)aLog 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 r8) rrr*r{rxr7r6r4r8rA)rLr4rcrrMrr/mncondr;Z xcond_reducedrr3r<Zmncond_rrr"r=qs z!multivariate_hypergeom_gen.logpmfcCst||||}|S)aMultivariate 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>)rLr4rcrr!rrr"r?szmultivariate_hypergeom_gen.pmfcCs|||\}}}}}}|jdkr@|dtjf|dtjf}}|dk}tjj||d}|||}|jdkr|dtjftj|jtjdB}| ||tj S)zMean of the multivariate hypergeometric distribution. Parameters ---------- %(_doc_default_callparams)s Returns ------- mean : array_like or scalar The mean of the distribution r.maskr8 rryr*rma masked_arrayr{rxr7r4rA)rLrcrrMrrr.murrr"rrs     zmultivariate_hypergeom_gen.meancCs|||\}}}}}}|jdkr@|dtjf|dtjf}}|dk|ddk@}tjj||d}|||||||||d}|jdkr|dtjftj|jtjdB}| ||tj S)aQVariance 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.rrr8r)rLrcrrMrrr.outputrrr"rs  (  zmultivariate_hypergeom_gen.varc Cs|||\}}}}}}|jdkrF|dtjtjf}|dtjtjf}|dk|ddk@}tjj||d}| |||dtd|||d}|jdkr|d|d}}|d}|jd}t|D]v} ||||d| f||d| f|d| | f<|d| | f|d|d| | f<|d| | f|d|d| | f<q|jdkrt|dtjtjftj |jtj d B}| ||tj S) aCovariance 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).rrr$r8) rryr*rrrr@rxrr{r7r4rA) rLrcrrMrrr.rrrrrr"rss0     2 " zmultivariate_hypergeom_gen.covc Cs|||\}}}}}}||}|dur:t|tr:|f}|durVtj|j|jd}ntj||jdf|jd}|}t|jddD]V} ||d| f}|dk|j |d| f|||dk|d|d| f<||d| f}q||d|jddf<|S)aDraw 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. Nr8r$r.rr) rre isinstancerr*rrxr'rZhypergeometric) rLrcrryrcrMrrremr_rrr"rs&   zmultivariate_hypergeom_gen.rvs)N)N)NN)rWrXrYrZrQrtrrr4r6r=r?rrrrsrrgrrrar"rzsp   $&rzc@sHeZdZdddZddZddZdd Zd d Zd d ZdddZ dS)r|NcsHt|_j||\______fdd}|j_dS)NcsjjjjjjfSrR)rMrcrrr/r)rcrrUrr"r?s zCmultivariate_hypergeom_frozen.__init__.._process_parameters) rzrirrMrcrrr/r)rLrcrr`rrrUr"rQ8s   z&multivariate_hypergeom_frozen.__init__cCs|j||j|jSrR)rir=rcrrrrr"r=Esz$multivariate_hypergeom_frozen.logpmfcCs|j||j|jSrR)rir?rcrrrrr"r?Hsz!multivariate_hypergeom_frozen.pmfcCs|j|j|jSrR)rirrrcrrUrrr"rrKsz"multivariate_hypergeom_frozen.meancCs|j|j|jSrR)rirrcrrUrrr"rNsz!multivariate_hypergeom_frozen.varcCs|j|j|jSrR)rirsrcrrUrrr"rsQsz!multivariate_hypergeom_frozen.covrcCs|jj|j|j||dS)NrK)rirrcrrrrr"rTsz!multivariate_hypergeom_frozen.rvs)N)rN) rWrXrYrQr=r?rrrrsrrrrr"r|7s r|)r=r?rrrrsr)NN)r2)T)|r\Znumpyr*rrZ scipy.linalgr?Z scipy._librZ scipy.specialrrrrr r Zscipy._lib._utilr Zscipy.linalg.blasr Zscipy.linalg.miscr Zscipy.linalg.lapackrZ_discrete_distnsrrjr__all__rIrrrZ_LOG_PIrmr#r1r<r=r\rhrkrlZ_mvn_doc_frozen_callparamsZ_mvn_doc_frozen_callparams_noterpZmvn_docdict_noparamsrnrrqname__dict__methodZ method_frozenrorZrrZ_matnorm_doc_frozen_callparamsZ#_matnorm_doc_frozen_callparams_noterZmatnorm_docdict_noparamsrrrrZ _dirichlet_doc_frozen_callparamsZ%_dirichlet_doc_frozen_callparams_noterZdirichlet_docdict_noparamsrrrrrrZ_wishart_doc_default_callparamsZ_wishart_doc_callparams_noteZ_wishart_doc_frozen_callparamsZ#_wishart_doc_frozen_callparams_noterZwishart_docdict_noparamsrrrrr rr!Z#_multinomial_doc_default_callparamsZ _multinomial_doc_callparams_noteZ"_multinomial_doc_frozen_callparamsZ'_multinomial_doc_frozen_callparams_noter*Zmultinomial_docdict_noparamsr)rr+rCrrErUrrXrrjrrnroZ_mvt_doc_frozen_callparams_noterqZmvt_docdict_noparamsrprsrZ_mhg_doc_default_callparamsZ_mhg_doc_callparams_noteZ_mhg_doc_frozen_callparamsZ_mhg_doc_frozen_callparams_noter{Zmhg_docdict_noparamsrzrr|rrrr"s             " G" ]    ;8   ,  c<   ?F  H2   w c<VC-    %