SciPy 1.12 中文文档（五十八）

原文：docs.scipy.org/doc/scipy-1.12.0/index.html

`scipy.stats.invwishart`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.invwishart.html#scipy.stats.invwishart

scipy.stats.invwishart = <scipy.stats._multivariate.invwishart_gen object>

一个逆 Wishart 随机变量。

df 关键字指定自由度。scale 关键字指定比例矩阵，它必须是对称的正定矩阵。在这种情况下，比例矩阵通常解释为多元正态协方差矩阵。

参数：

dfint

自由度，必须大于或等于比例矩阵的维数

scalearray_like

分布的对称正定比例矩阵

seed{None, int, np.random.RandomState, np.random.Generator}, 可选

用于生成随机变量。如果 seed 是 None，则使用 RandomState 单例。如果 seed 是一个整数，则使用一个新的 RandomState 实例，并使用 seed 进行种子。如果 seed 已经是 RandomState 或 Generator 实例，则使用该对象。默认值为 None。

Raises:

scipy.linalg.LinAlgError

如果比例矩阵 scale 不是正定的。

参见

wishart

注意

scale 比例矩阵必须是对称正定矩阵。不支持奇异矩阵，包括对称正半定的情况。只检查对称性；只使用下三角部分。

逆 Wishart 分布通常表示为

[W_p^{-1}(\nu, \Psi)]

其中 (\nu) 是自由度，(\Psi) 是 (p \times p) 的比例矩阵。

对 invwishart 的概率密度函数在正定矩阵 (S) 上有支持；如果 (S \sim W^{-1}_p(\nu, \Sigma))，则其 PDF 给出为：

[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)]

如果 (S \sim W_p^{-1}(\nu, \Psi))（逆 Wishart），则 (S^{-1} \sim W_p(\nu, \Psi^{-1}))（Wishart）。

如果比例矩阵是一维的且等于一，则逆 Wishart 分布 (W_1(\nu, 1)) 将折叠为具有参数形状 = (\frac{\nu}{2}) 和尺度 = (\frac{1}{2}) 的逆 Gamma 分布。

与描述的随机生成 Wishart 矩阵的反向操作不同，在这里使用的算法在 [4] 中直接生成随机逆 Wishart 矩阵而无需反向操作。

版本 0.16.0 中的新内容。

参考文献

[1]

M.L. Eaton，《多元统计学：向量空间方法》，Wiley，1983 年。

[2]

M.C. Jones，《生成逆 Wishart 矩阵》，《统计 - 模拟与计算》通信，第 14.2 卷，第 511-514 页，1985 年。

[3]

Gupta, M. 和 Srivastava, S.，“参数贝叶斯估计的差分熵和相对熵”。Entropy 12, 818 - 843. 2010.

[4]

S.D. Axen，“高效生成逆 Wishart 矩阵及其 Cholesky 因子”，arXiv:2310.15884v1。2023 年。

示例

>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.stats import invwishart, invgamma
>>> x = np.linspace(0.01, 1, 100)
>>> iw = invwishart.pdf(x, df=6, scale=1)
>>> iw[:3]
array([  1.20546865e-15,   5.42497807e-06,   4.45813929e-03])
>>> ig = invgamma.pdf(x, 6/2., scale=1./2)
>>> ig[:3]
array([  1.20546865e-15,   5.42497807e-06,   4.45813929e-03])
>>> plt.plot(x, iw)
>>> plt.show()

../../_images/scipy-stats-invwishart-1_00_00.png

输入分位数可以是任何形状的数组，只要最后一个轴标记组件。

或者，可以将对象（作为函数）调用以固定自由度和比例参数，返回一个“冻结”的逆 Wishart 随机变量：

>>> rv = invwishart(df=1, scale=1)
>>> # Frozen object with the same methods but holding the given
>>> # degrees of freedom and scale fixed.

方法

pdf(x, df, scale)	概率密度函数。
logpdf(x, df, scale)	概率密度函数的对数。
rvs(df, scale, size=1, random_state=None)	从逆 Wishart 分布中抽取随机样本。
entropy(df, scale)	分布的微分熵。

`scipy.stats.multinomial`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.multinomial.html#scipy.stats.multinomial

scipy.stats.multinomial = <scipy.stats._multivariate.multinomial_gen object>

一个多项式随机变量。

参数：

nint

试验次数

parray_like

每个类别落入的概率；应该总和为 1

seed{None, int, np.random.RandomState, np.random.Generator}, optional

用于生成随机变量。如果seed为None，则使用RandomState单例。如果seed是一个整数，则使用一个新的RandomState实例，并使用该种子进行初始化。如果seed已经是RandomState或Generator实例，则直接使用该对象。默认为None。

参见

scipy.stats.binom

二项式分布。

numpy.random.Generator.multinomial

从多项式分布中抽样。

scipy.stats.multivariate_hypergeom

多元超几何分布。

注意事项

n应为非负整数。p的每个元素应在区间([0,1])内，并且元素应总和为 1。如果它们的总和不为 1，则不使用p数组的最后一个元素，并用前面元素剩余的概率代替。

multinomial的概率质量函数是

[f(x) = \frac{n!}{x_1! \cdots x_k!} p_1^{x_1} \cdots p_k^{x_k},]

在(x=(x_1, \ldots, x_k))且每个(x_i)为非负整数且它们的和为(n)的情况下受支持。

版本 0.19.0 中的新功能。

示例

>>> from scipy.stats import multinomial
>>> rv = multinomial(8, [0.3, 0.2, 0.5])
>>> rv.pmf([1, 3, 4])
0.042000000000000072

对于(k=2)的多项式分布与相应的二项式分布完全相同（尽管存在微小的数值差异）：

>>> 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

函数pmf，logpmf，entropy和cov支持广播，遵循的约定是向量参数（x和p）被解释为沿着最后一个轴的每一行都是单个对象。例如：

>>> multinomial.pmf([[3, 4], [3, 5]], n=[7, 8], p=[.3, .7])
array([0.2268945,  0.25412184])

在这里，x.shape == (2, 2)，n.shape == (2,)，p.shape == (2,)，但根据上述规则，它们表现得好像行[3, 4]和[3, 5]在x中以及[.3, .7]在p中是单个对象，并且好像我们有x.shape = (2,)，n.shape = (2,)，p.shape = ()。要获取不进行广播的各个元素，我们可以这样做：

>>> multinomial.pmf([3, 4], n=7, p=[.3, .7])
0.2268945
>>> multinomial.pmf([3, 5], 8, p=[.3, .7])
0.25412184

这种广播在cov中也适用，其中输出对象是大小为p.shape[-1]的方阵。例如：

>>> 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 ]]])

在这个例子中，n.shape == (2,)，p.shape == (2, 2)，并且根据以上规则，这些会像p.shape == (2,)一样进行广播。因此结果应该也是形状为(2,)，但由于每个输出是一个(2 \times 2)的矩阵，实际上结果的形状是(2, 2, 2)，其中result[0]等于multinomial.cov(n=4, p=[.3, .7])，而result[1]等于multinomial.cov(n=5, p=[.4, .6])。

另外，该对象可以被调用（作为一个函数）来固定n和p参数，返回一个“冻结”的多项随机变量：

>>> rv = multinomial(n=7, p=[.3, .7])
>>> # Frozen object with the same methods but holding the given
>>> # degrees of freedom and scale fixed.

方法

pmf(x, n, p)	概率质量函数。
logpmf(x, n, p)	概率质量函数的对数。
rvs(n, p, size=1, random_state=None)	从多项分布中抽取随机样本。
entropy(n, p)	计算多项分布的熵。
cov(n, p)	计算多项分布的协方差矩阵。

`scipy.stats.special_ortho_group`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.special_ortho_group.html#scipy.stats.special_ortho_group

scipy.stats.special_ortho_group = <scipy.stats._multivariate.special_ortho_group_gen object>

特殊正交矩阵（SO(N)）随机变量。

从 Haar 分布中返回一个随机旋转矩阵（SO(N)上唯一的均匀分布），其行列式为+1。

关键词dim指定维度 N。

参数：

dim标量

矩阵的维度

seed{None, int, np.random.RandomState, np.random.Generator}，可选

用于绘制随机变量。如果seed为None，则使用RandomState单例。如果seed为 int，则使用带有 seed 种子的新的RandomState实例。如果seed已经是RandomState或Generator实例，则使用该对象。默认值为None。

参见

ortho_group，scipy.spatial.transform.Rotation.random

注意事项

该类封装了 MDP Toolkit 中的 random_rot 代码，github.com/mdp-toolkit/mdp-toolkit

从 Haar 分布中返回一个随机旋转矩阵（SO(N)上唯一的均匀分布）。该算法在文章 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 中有描述。更多信息请参见en.wikipedia.org/wiki/Orthogonal_matrix#Randomization

另请参见类似的ortho_group。关于三维空间中的随机旋转，请参见scipy.spatial.transform.Rotation.random。

示例

>>> import numpy as np
>>> from scipy.stats import special_ortho_group
>>> x = special_ortho_group.rvs(3)

>>> np.dot(x, x.T)
array([[  1.00000000e+00,   1.13231364e-17,  -2.86852790e-16],
 [  1.13231364e-17,   1.00000000e+00,  -1.46845020e-16],
 [ -2.86852790e-16,  -1.46845020e-16,   1.00000000e+00]])

>>> import scipy.linalg
>>> scipy.linalg.det(x)
1.0

这会生成一个来自 SO(3)的随机矩阵。它是正交的，并且行列式为 1。

或者，该对象可以作为函数调用以固定dim参数，返回一个“冻结”的 special_ortho_group 随机变量：

>>> rv = special_ortho_group(5)
>>> # Frozen object with the same methods but holding the
>>> # dimension parameter fixed.

方法

rvs(dim=None, size=1, random_state=None)	从 SO(N)中抽取随机样本。

`scipy.stats.ortho_group`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.ortho_group.html#scipy.stats.ortho_group

scipy.stats.ortho_group = <scipy.stats._multivariate.ortho_group_gen object>

正交矩阵（O(N)）随机变量。

返回一个从 O(N) Haar 分布（O(N) 上唯一的均匀分布）中抽取的随机正交矩阵。

dim 关键字指定维度 N。

参数:

dim 标量

矩阵的维度

seed{None, int, np.random.RandomState, np.random.Generator}, optional

用于绘制随机变量。如果 seed 为 None，则使用 RandomState 单例。如果 seed 是一个整数，则使用一个新的 RandomState 实例，种子为 seed。如果 seed 已经是 RandomState 或 Generator 实例，则使用该对象。默认为 None。

另见

special_ortho_group

注意事项

该类与 special_ortho_group 密切相关。

一些小心措施用于避免数值误差，如 Mezzadri 所述的论文。

参考文献

[1]

F. Mezzadri，《如何从经典紧致群中生成随机矩阵》，arXiv:math-ph/0609050v2。

示例

>>> import numpy as np
>>> from scipy.stats import ortho_group
>>> x = ortho_group.rvs(3)

>>> np.dot(x, x.T)
array([[  1.00000000e+00,   1.13231364e-17,  -2.86852790e-16],
 [  1.13231364e-17,   1.00000000e+00,  -1.46845020e-16],
 [ -2.86852790e-16,  -1.46845020e-16,   1.00000000e+00]])

>>> import scipy.linalg
>>> np.fabs(scipy.linalg.det(x))
1.0

这会生成一个来自 O(3) 的随机矩阵。它是正交的，并且行列式为 +1 或 -1。

或者，对象可以被称为（作为一个函数）来固定 dim 参数，返回一个“冻结的” ortho_group 随机变量：

>>> rv = ortho_group(5)
>>> # Frozen object with the same methods but holding the
>>> # dimension parameter fixed.

方法

rvs(dim=None, size=1, random_state=None)	从 O(N) 中抽取随机样本。

`scipy.stats.unitary_group`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.unitary_group.html#scipy.stats.unitary_group

scipy.stats.unitary_group = <scipy.stats._multivariate.unitary_group_gen object>

一个矩阵值 U(N) 随机变量。

返回一个随机酉矩阵。

dim 关键字指定维度 N。

参数：

dim 标量

矩阵的维度

seed{None, int, np.random.RandomState, np.random.Generator}，可选

用于绘制随机变量。如果 seed 为 None，则使用 RandomState 单例。如果 seed 是整数，则使用带有 seed 的新 RandomState 实例。如果 seed 已经是 RandomState 或 Generator 实例，则使用该对象。默认为 None。

另见

ortho_group

注释

此类与 ortho_group 类似。

参考文献

[1]

F. Mezzadri，《如何从经典紧致群生成随机矩阵》，arXiv:math-ph/0609050v2。

示例

>>> import numpy as np
>>> from scipy.stats import unitary_group
>>> x = unitary_group.rvs(3)

>>> np.dot(x, x.conj().T)
array([[  1.00000000e+00,   1.13231364e-17,  -2.86852790e-16],
 [  1.13231364e-17,   1.00000000e+00,  -1.46845020e-16],
 [ -2.86852790e-16,  -1.46845020e-16,   1.00000000e+00]])

这会生成一个来自 U(3) 的随机矩阵。点积确认其在机器精度下是酉的。

或者，可以调用对象（作为函数）来固定 dim 参数，返回一个“冻结”的 unitary_group 随机变量：

>>> rv = unitary_group(5)

方法

rvs(dim=None, size=1, random_state=None)	从 U(N) 中抽取随机样本。

`scipy.stats.random_correlation`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.random_correlation.html#scipy.stats.random_correlation

scipy.stats.random_correlation = <scipy.stats._multivariate.random_correlation_gen object>

一个随机相关矩阵。

给定特征值向量，返回一个随机相关矩阵。

eigs 关键字指定相关矩阵的特征值，并暗示其维度。

参数：

eigs1d ndarray

`scipy.stats.multivariate_t`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.multivariate_t.html#scipy.stats.multivariate_t

scipy.stats.multivariate_t = <scipy.stats._multivariate.multivariate_t_gen object>

多元 t 分布随机变量。

loc 参数指定位置。shape 参数指定正半定形状矩阵。df 参数指定自由度。

除了调用下面的方法，对象本身也可以作为一个函数调用，以固定位置、形状矩阵和自由度参数，返回一个“冻结”的多元 t 分布随机对象。

参数：

locarray_like，可选

分布的位置。（默认0）

shapearray_like，可选

分布的正半定矩阵。（默认1）

dffloat，可选

分布的自由度；必须大于零。如果 np.inf，则结果为多元正态分布。默认为 1。

allow_singularbool，可选

是否允许奇异矩阵。（默认False）

seed{None, int, np.random.RandomState, np.random.Generator}，可选

用于生成随机变量。如果 seed 为 None，则使用 RandomState 单例。如果 seed 是整数，则使用一个新的 RandomState 实例，并用 seed 进行初始化。如果 seed 已经是 RandomState 或 Generator 实例，则使用该对象。默认为 None。

注意事项

将 loc 参数设为 None 相当于将 loc 设为零向量。shape 参数可以是标量，此时形状矩阵为单位矩阵乘以该值，也可以是形状矩阵的对角线条目的向量，或者是二维数组。矩阵 shape 必须是（对称的）正半定矩阵。其伪行列式和伪逆分别计算为矩阵 shape 的行列式和逆，因此 shape 不需要具有完全秩。

multivariate_t 的概率密度函数为

[f(x) = \frac{\Gamma((\nu + p)/2)}{\Gamma(\nu/2)\nu^{p/2}\pi^{p/2}|\Sigma|^{1/2}} \left[1 + \frac{1}{\nu} (\mathbf{x} - \boldsymbol{\mu})^{\top} \boldsymbol{\Sigma}^{-1} (\mathbf{x} - \boldsymbol{\mu}) \right]^{-(\nu + p)/2},]

其中 (p) 是 (\mathbf{x}) 的维度，(\boldsymbol{\mu}) 是 (p) 维位置，(\boldsymbol{\Sigma}) 是 (p \times p) 维形状矩阵，(\nu) 是自由度。

版本 1.6.0 中的新增内容。

参考文献

[1]

Arellano-Valle 等人的“多元斜椭圆分布的香农熵和互信息”。《斯堪的纳维亚统计学杂志》。第 40 卷，第 1 期。

示例

该对象可以被调用（作为函数），以固定 loc、shape、df 和 allow_singular 参数，返回一个“冻结”的多元 t 随机变量：

>>> import numpy as np
>>> from scipy.stats import multivariate_t
>>> rv = multivariate_t([1.0, -0.5], [[2.1, 0.3], [0.3, 1.5]], df=2)
>>> # Frozen object with the same methods but holding the given location,
>>> # scale, and degrees of freedom fixed.

创建概率密度函数的等高线图。

>>> import matplotlib.pyplot as plt
>>> x, y = np.mgrid[-1:3:.01, -2:1.5:.01]
>>> pos = np.dstack((x, y))
>>> fig, ax = plt.subplots(1, 1)
>>> ax.set_aspect('equal')
>>> plt.contourf(x, y, rv.pdf(pos))

../../_images/scipy-stats-multivariate_t-1.png

方法

pdf(x, loc=None, shape=1, df=1, allow_singular=False)	概率密度函数。
logpdf(x, loc=None, shape=1, df=1, allow_singular=False)	概率密度函数的对数。
*cdf(x, loc=None, shape=1, df=1, allow_singular=False, ,	maxpts=None, lower_limit=None, random_state=None) 累积分布函数。
rvs(loc=None, shape=1, df=1, size=1, random_state=None)	从多元 t 分布中抽取随机样本。
entropy(loc=None, shape=1, df=1)	多元 t 分布的微分熵。

`scipy.stats.multivariate_hypergeom`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.multivariate_hypergeom.html#scipy.stats.multivariate_hypergeom

scipy.stats.multivariate_hypergeom = <scipy.stats._multivariate.multivariate_hypergeom_gen object>

多元超几何随机变量。

参数：

marray_like

人口中每种对象的数量。即，(m[i]) 是类型 (i) 的对象数量。

narray_like

从人口中取样的样本数量。

seed{None, int, np.random.RandomState, np.random.Generator}, 可选

用于绘制随机变量。如果 seed 为 None，则使用 RandomState 单例。如果 seed 是整数，则使用一个新的 RandomState 实例，并用 seed 初始化。如果 seed 已经是 RandomState 或 Generator 实例，则使用该对象。默认为 None。

另见

scipy.stats.hypergeom

超几何分布。

scipy.stats.multinomial

多项分布。

注意事项

m 必须是正整数数组。如果分位数 (i) 包含超出范围 ([0, m_i]) 的值，其中 (m_i) 是人群中类型 (i) 的对象数量，或者如果参数不一致（例如 x.sum() != n），则方法返回适当的值（例如 0 对于 pmf）。如果 m 或 n 包含负值，则结果将包含 nan。

用于 multivariate_hypergeom 的概率质量函数为

[\begin{split}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\end{split}]

其中 (m_i) 是种类 (i) 的对象数量，(M) 是总人口中的对象总数（所有 (m_i) 的总和），(n) 是从人口中取样的样本大小。

自 1.6.0 版本新增。

参考文献

[1]

多元超几何分布，www.randomservices.org/random/urn/MultiHypergeometric.html

[2]

Thomas J. Sargent 和 John Stachurski，2020，多元超几何分布 python.quantecon.org/_downloads/pdf/multi_hyper.pdf

示例

要评估多元超几何分布的概率质量函数，在大小为 (10) 和 (20) 的二元人口中，取样大小为 (12)，第一类对象有 (8) 个，第二类对象有 (4) 个，请使用：

>>> from scipy.stats import multivariate_hypergeom
>>> multivariate_hypergeom.pmf(x=[8, 4], m=[10, 20], n=12)
0.0025207176631464523

多变量超几何分布（multivariate_hypergeom）在人口中仅有两种类型（好的和坏的）物体（如上例）时与相应的hypergeom分布完全相同（尽管存在微小的数值差异）。考虑另一个例子，用于与超几何分布进行比较：

>>> 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

函数 pmf, logpmf, mean, var, cov, 和 rvs 支持广播，遵循向量参数（x, m, 和 n）被解释为最后轴上的每行作为单个对象的约定。例如，我们可以结合前两次调用multivariate_hypergeom：

>>> multivariate_hypergeom.pmf(x=[[8, 4], [3, 1]], m=[[10, 20], [10, 5]],
...                            n=[12, 4])
array([0.00252072, 0.43956044])

这种广播也适用于 cov，其中输出对象是大小为 m.shape[-1] 的方阵。例如：

>>> 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]]])

即，result[0] 等于 multivariate_hypergeom.cov(m=[7, 9], n=8)，而 result[1] 等于 multivariate_hypergeom.cov(m=[10, 15], n=12)。

或者，可以调用该对象（作为函数）来固定参数 m 和 n，返回一个“冻结”的多变量超几何随机变量。

>>> rv = multivariate_hypergeom(m=[10, 20], n=12)
>>> rv.pmf(x=[8, 4])
0.0025207176631464523

方法

pmf(x, m, n)	概率质量函数。
logpmf(x, m, n)	概率质量函数的对数。
rvs(m, n, size=1, random_state=None)	从多变量超几何分布中抽取随机样本。
mean(m, n)	多变量超几何分布的均值。
var(m, n)	多变量超几何分布的方差。
cov(m, n)	计算多变量超几何分布的协方差矩阵。

`scipy.stats.random_table`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.random_table.html#scipy.stats.random_table

scipy.stats.random_table = <scipy.stats._multivariate.random_table_gen object>

来自固定边际和的独立样本的列联表。

这是具有给定行和列向量总和的随机表的分布。该分布表示在假设行和列是独立的零假设下的随机表集合。它用于独立性假设检验。

由于假设独立性，可以从行和列总和计算出每个表元素的期望频率，因此该分布完全由这两个向量确定。

参数：

行array_like

每行中表条目的总和。

列array_like

每列中表条目的总和。

种子{None, int, np.random.RandomState, np.random.Generator}，可选

用于绘制随机变量。如果seed为None，则使用RandomState单例。如果seed为 int，则使用一个新的RandomState实例，并用 seed 种子。如果seed已经是RandomState或Generator实例，则使用该对象。默认值为None。

注释

行和列向量必须是一维的，不能是空的，并且每个都加起来到相同的值。它们不能包含负数或非整数条目。

从分布中生成的随机元素可以使用 Boyett 的[1]或 Patefield 的算法[2]。 Boyett 算法具有 O(N)的时间和空间复杂度，其中 N 是表中条目的总和。 Patefield 的算法具有 O(K x log(N))的时间复杂度，其中 K 是表中的单元格数，并且仅需要一个小的常数工作空间。默认情况下，rvs方法根据输入选择最快的算法，但您可以使用关键字method指定算法。允许的值为“boyett”和“patefield”。

新版本 1.10.0 中。

参考文献

[1]

Boyett, AS 144 Appl. Statist. 28 (1979) 329-332

[2]

W.M. Patefield, AS 159 Appl. Statist. 30 (1981) 91-97

示例

>>> from scipy.stats import random_table

>>> row = [1, 5]
>>> col = [2, 3, 1]
>>> random_table.mean(row, col)
array([[0.33333333, 0.5       , 0.16666667],
 [1.66666667, 2.5       , 0.83333333]])

或者，对象可以被称为（作为一个函数），以修正行和列向量的总和，返回一个“冻结”的分布。

>>> dist = random_table(row, col)
>>> dist.rvs(random_state=123)
array([[1., 0., 0.],
 [1., 3., 1.]])

方法

logpmf(x)	表x在分布中发生的对数概率。
pmf(x)	表x在分布中发生的概率。
mean(row, col)	平均表。
rvs(row, col, size=None, method=None, random_state=None)	用给定的行和列向量总和绘制随机表。

`scipy.stats.uniform_direction`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.uniform_direction.html#scipy.stats.uniform_direction

scipy.stats.uniform_direction = <scipy.stats._multivariate.uniform_direction_gen object>

一个向量值均匀方向。

返回一个随机方向（单位向量）。dim关键字指定空间的维数。

参数：

dim标量

方向的维度。

seed{None, int, numpy.random.Generator,

numpy.random.RandomState}, 可选项

用于绘制随机变量。如果seed为None，则使用RandomState单例。如果seed为整数，则使用带有该种子的新RandomState实例。如果seed已经是RandomState或Generator实例，则使用该对象。默认为None。

笔记

此分布生成在超球面表面均匀分布的单位向量。这些可以解释为随机方向。例如，如果dim为 3，则会从(S²)的表面采样 3D 向量。

参考文献

[1]

Marsaglia, G. (1972). “Choosing a Point from the Surface of a Sphere”. Annals of Mathematical Statistics. 43 (2): 645-646.

示例

>>> import numpy as np
>>> from scipy.stats import uniform_direction
>>> x = uniform_direction.rvs(3)
>>> np.linalg.norm(x)
1.

这生成一个随机方向，一个位于(S²)表面的向量。

或者，对象可以被称为（作为函数）以返回一个具有固定dim参数的冻结分布。在这里，我们创建一个uniform_direction，其中dim=3并绘制 5 个观测值。然后，样本被安排在形状为 5x3 的数组中。

>>> rng = np.random.default_rng()
>>> uniform_sphere_dist = uniform_direction(3)
>>> unit_vectors = uniform_sphere_dist.rvs(5, random_state=rng)
>>> unit_vectors
array([[ 0.56688642, -0.1332634 , -0.81294566],
 [-0.427126  , -0.74779278,  0.50830044],
 [ 0.3793989 ,  0.92346629,  0.05715323],
 [ 0.36428383, -0.92449076, -0.11231259],
 [-0.27733285,  0.94410968, -0.17816678]])

方法

rvs(dim=None, size=1, random_state=None)	绘制随机方向。

`scipy.stats.vonmises_fisher`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.vonmises_fisher.html#scipy.stats.vonmises_fisher

scipy.stats.vonmises_fisher = <scipy.stats._multivariate.vonmises_fisher_gen object>

冯·米塞斯-费舍尔变量。

关键词mu指定均值方向向量。关键词kappa指定集中参数。

参数：

mu类似数组

分布的均值方向。必须是一个单位范数的一维向量。

kappa浮点数

集中参数。必须为正。

种子{None, int, np.random.RandomState, np.random.Generator}，可选

用于绘制随机变量。如果seed为None，则使用RandomState单例。如果seed为整数，则使用一个新的RandomState实例，种子为 seed。如果seed已经是RandomState或Generator实例，则使用该对象。默认为None。

另请参见

scipy.stats.vonmises

在 2D 上的冯·米塞斯-费舍尔分布，圆上

uniform_direction

在超球面上的均匀分布

注意事项

冯·米塞斯-费舍尔分布是单位超球面上的方向分布。单位向量(\mathbf{x})的概率密度函数为

[f(\mathbf{x}) = \frac{\kappa^{d/2-1}}{(2\pi)^{d/2}I_{d/2-1}(\kappa)} \exp\left(\kappa \mathbf{\mu}^T\mathbf{x}\right),]

其中(\mathbf{\mu})是均值方向，(\kappa)是集中参数，(d)是维数，(I)是第一类修正贝塞尔函数。由于(\mu)表示一个方向，它必须是一个单位向量，或者换句话说，是超球面上的一个点：(\mathbf{\mu}\in S^{d-1})。(\kappa)是一个集中参数，这意味着它必须是正的（(\kappa>0)），且随着(\kappa)的增加，分布变得更加狭窄。在这种意义上，倒数(1/\kappa)类似于正态分布的方差参数。

冯·米塞斯-费舍尔分布通常作为球面上正态分布的类比。直观地，对于单位向量，一个有用的距离度量由它们之间的角度(\alpha)给出。这正是冯·米塞斯-费舍尔概率密度函数中标量积(\mathbf{\mu}^T\mathbf{x}=\cos(\alpha))描述的：均值方向(\mathbf{\mu})与向量(\mathbf{x})之间的角度。它们之间的角度越大，观察到特定均值方向(\mathbf{\mu})的向量(\mathbf{x})的概率就越小。

在 2 维和 3 维中，使用了专门的算法进行快速抽样 [2]，[3]。对于 4 维或更高维度，使用了[4]中描述的拒绝抽样算法。此实现部分基于 geomstats 软件包 [5]，[6]。

1.11 版本更新内容。

参考文献

[1]

Von Mises-Fisher 分布，维基百科，en.wikipedia.org/wiki/Von_Mises%E2%80%93Fisher_distribution

[2]

Mardia，K.，和 Jupp，P. 方向统计。Wiley，2000 年。

[3]

J. Wenzel。在 S2 上对 von Mises Fisher 分布进行数值稳定抽样。www.mitsuba-renderer.org/~wenzel/files/vmf.pdf

[4]

Wood，A. von Mises Fisher 分布的模拟。统计学沟通 - 模拟与计算 23，1（1994 年），157-164。doi.org/10.1080/03610919408813161

[5]

geomstats，Github。MIT 许可证。访问日期：2023 年 06 月 01 日。github.com/geomstats/geomstats

[6]

Miolane，N. 等。Geomstats：机器学习中的黎曼几何 Python 包。机器学习研究杂志 21（2020 年）。jmlr.org/papers/v21/19-027.html

示例

概率密度的可视化

绘制三维中随着浓度参数增加的概率密度。密度由pdf方法计算得出。

>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.stats import vonmises_fisher
>>> from matplotlib.colors import Normalize
>>> n_grid = 100
>>> u = np.linspace(0, np.pi, n_grid)
>>> v = np.linspace(0, 2 * np.pi, n_grid)
>>> u_grid, v_grid = np.meshgrid(u, v)
>>> vertices = np.stack([np.cos(v_grid) * np.sin(u_grid),
...                      np.sin(v_grid) * np.sin(u_grid),
...                      np.cos(u_grid)],
...                     axis=2)
>>> x = np.outer(np.cos(v), np.sin(u))
>>> y = np.outer(np.sin(v), np.sin(u))
>>> z = np.outer(np.ones_like(u), np.cos(u))
>>> def plot_vmf_density(ax, x, y, z, vertices, mu, kappa):
...     vmf = vonmises_fisher(mu, kappa)
...     pdf_values = vmf.pdf(vertices)
...     pdfnorm = Normalize(vmin=pdf_values.min(), vmax=pdf_values.max())
...     ax.plot_surface(x, y, z, rstride=1, cstride=1,
...                     facecolors=plt.cm.viridis(pdfnorm(pdf_values)),
...                     linewidth=0)
...     ax.set_aspect('equal')
...     ax.view_init(azim=-130, elev=0)
...     ax.axis('off')
...     ax.set_title(rf"$\kappa={kappa}$")
>>> fig, axes = plt.subplots(nrows=1, ncols=3, figsize=(9, 4),
...                          subplot_kw={"projection": "3d"})
>>> left, middle, right = axes
>>> mu = np.array([-np.sqrt(0.5), -np.sqrt(0.5), 0])
>>> plot_vmf_density(left, x, y, z, vertices, mu, 5)
>>> plot_vmf_density(middle, x, y, z, vertices, mu, 20)
>>> plot_vmf_density(right, x, y, z, vertices, mu, 100)
>>> plt.subplots_adjust(top=1, bottom=0.0, left=0.0, right=1.0, wspace=0.)
>>> plt.show()

../../_images/scipy-stats-vonmises_fisher-1_00_00.png

随着浓度参数的增加，点围绕平均方向越来越聚集。

抽样

使用rvs方法从分布中抽取 5 个样本，生成一个 5x3 的数组。

>>> rng = np.random.default_rng()
>>> mu = np.array([0, 0, 1])
>>> samples = vonmises_fisher(mu, 20).rvs(5, random_state=rng)
>>> samples
array([[ 0.3884594 , -0.32482588,  0.86231516],
 [ 0.00611366, -0.09878289,  0.99509023],
 [-0.04154772, -0.01637135,  0.99900239],
 [-0.14613735,  0.12553507,  0.98126695],
 [-0.04429884, -0.23474054,  0.97104814]])

这些样本是单位球面上的单位向量 (S²)。为了验证，让我们计算它们的欧几里德范数：

>>> np.linalg.norm(samples, axis=1)
array([1., 1., 1., 1., 1.])

绘制从 von Mises-Fisher 分布中抽取的 20 个观测值，随着浓度参数 (\kappa) 的增加。红点突出显示平均方向 (\mu)。

>>> def plot_vmf_samples(ax, x, y, z, mu, kappa):
...     vmf = vonmises_fisher(mu, kappa)
...     samples = vmf.rvs(20)
...     ax.plot_surface(x, y, z, rstride=1, cstride=1, linewidth=0,
...                     alpha=0.2)
...     ax.scatter(samples[:, 0], samples[:, 1], samples[:, 2], c='k', s=5)
...     ax.scatter(mu[0], mu[1], mu[2], c='r', s=30)
...     ax.set_aspect('equal')
...     ax.view_init(azim=-130, elev=0)
...     ax.axis('off')
...     ax.set_title(rf"$\kappa={kappa}$")
>>> mu = np.array([-np.sqrt(0.5), -np.sqrt(0.5), 0])
>>> fig, axes = plt.subplots(nrows=1, ncols=3,
...                          subplot_kw={"projection": "3d"},
...                          figsize=(9, 4))
>>> left, middle, right = axes
>>> plot_vmf_samples(left, x, y, z, mu, 5)
>>> plot_vmf_samples(middle, x, y, z, mu, 20)
>>> plot_vmf_samples(right, x, y, z, mu, 100)
>>> plt.subplots_adjust(top=1, bottom=0.0, left=0.0,
...                     right=1.0, wspace=0.)
>>> plt.show()

../../_images/scipy-stats-vonmises_fisher-1_01_00.png

图表显示，随着浓度参数 (\kappa) 的增加，结果样本更集中地围绕平均方向。

拟合分布参数

可以使用fit方法将分布拟合到数据中，返回估计的参数。作为一个示例，让我们将分布拟合到从已知 von Mises-Fisher 分布中抽取的样本。

>>> mu, kappa = np.array([0, 0, 1]), 20
>>> samples = vonmises_fisher(mu, kappa).rvs(1000, random_state=rng)
>>> mu_fit, kappa_fit = vonmises_fisher.fit(samples)
>>> mu_fit, kappa_fit
(array([0.01126519, 0.01044501, 0.99988199]), 19.306398751730995)

我们看到估计的参数 mu_fit 和 kappa_fit 与真实参数非常接近。

方法

pdf(x, mu=None, kappa=1)	概率密度函数。
logpdf(x, mu=None, kappa=1)	概率密度函数的对数。
rvs(mu=None, kappa=1, size=1, random_state=None)	从 von Mises-Fisher 分布中抽取随机样本。
entropy(mu=None, kappa=1)	计算 von Mises-Fisher 分布的差分熵。
fit(data)	拟合数据到 von Mises-Fisher 分布。

`scipy.stats.Covariance`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.Covariance.html#scipy.stats.Covariance

class scipy.stats.Covariance

协方差矩阵的表示

对涉及协方差矩阵的计算（例如数据白化、多元正态函数评估），通常使用协方差矩阵的分解而不是协方差矩阵本身效率更高。此类允许用户使用多种分解构建代表协方差矩阵的对象，并使用通用接口进行计算。

注意

不能直接实例化Covariance类。而是使用其中的一个工厂方法（例如Covariance.from_diagonal）。

示例

通过调用其工厂方法之一来创建Covariance对象，然后将该表示传递给多元分布的形状参数，从而使用Covariance矩阵的表示来计算概率密度函数。

例如，多元正态分布可以接受表示协方差矩阵的数组：

>>> from scipy import stats
>>> import numpy as np
>>> d = [1, 2, 3]
>>> A = np.diag(d)  # a diagonal covariance matrix
>>> x = [4, -2, 5]  # a point of interest
>>> dist = stats.multivariate_normal(mean=[0, 0, 0], cov=A)
>>> dist.pdf(x)
4.9595685102808205e-08

但是计算是以一种通用方式进行的，不利用协方差矩阵的任何特殊属性。因为我们的协方差矩阵是对角的，我们可以使用Covariance.from_diagonal创建代表协方差矩阵的对象，并且multivariate_normal可以利用这一点更有效地计算概率密度函数。

>>> cov = stats.Covariance.from_diagonal(d)
>>> dist = stats.multivariate_normal(mean=[0, 0, 0], cov=cov)
>>> dist.pdf(x)
4.9595685102808205e-08

属性：

covariance

协方差矩阵的显式表示

log_pdet

协方差矩阵伪行列式的对数

rank

协方差矩阵的秩

shape

协方差数组的形状

方法

`colorize`(x)	对数据执行颜色变换。
`from_cholesky`(cholesky)	通过（下三角）Cholesky 因子提供的协方差的表示。
`from_diagonal`(diagonal)	从其对角线返回协方差矩阵的表示。
`from_eigendecomposition`(eigendecomposition)	通过特征分解提供的协方差的表示。
`from_precision`(precision[, covariance])	从其精度矩阵返回协方差的表示。
`whiten`(x)	对数据执行白化变换。

`scipy.stats.bernoulli`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.bernoulli.html#scipy.stats.bernoulli

scipy.stats.bernoulli = <scipy.stats._discrete_distns.bernoulli_gen object>

一个伯努利离散随机变量。

作为rv_discrete类的实例，伯努利分布对象继承了一组通用方法（下面列出完整列表），并用特定于该特定分布的细节完成了它们。

注意事项

伯努利分布的概率质量函数为：

[\begin{split}f(k) = \begin{cases}1-p &\text{如果 } k = 0\ p &\text{如果 } k = 1\end{cases}\end{split}]

对于(k)在({0, 1})中，(0 \leq p \leq 1)

伯努利分布以(p)作为形状参数，其中(p)是单次成功的概率，(1-p)是单次失败的概率。

上述概率质量函数以“标准化”形式定义。使用loc参数来移动分布。具体来说，bernoulli.pmf(k, p, loc)与bernoulli.pmf(k - loc, p)完全等价。

示例

>>> import numpy as np
>>> from scipy.stats import bernoulli
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)

计算前四个矩：

>>> p = 0.3
>>> mean, var, skew, kurt = bernoulli.stats(p, moments='mvsk')

显示概率质量函数（pmf）：

>>> x = np.arange(bernoulli.ppf(0.01, p),
...               bernoulli.ppf(0.99, p))
>>> ax.plot(x, bernoulli.pmf(x, p), 'bo', ms=8, label='bernoulli pmf')
>>> ax.vlines(x, 0, bernoulli.pmf(x, p), colors='b', lw=5, alpha=0.5)

或者，可以调用分布对象（作为函数）来固定形状和位置。这将返回一个“冻结”的随机变量对象，保持给定的参数不变。

冻结分布并显示冻结的pmf：

>>> rv = bernoulli(p)
>>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1,
...         label='frozen pmf')
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()

../../_images/scipy-stats-bernoulli-1_00_00.png

检查cdf和ppf的准确性：

>>> prob = bernoulli.cdf(x, p)
>>> np.allclose(x, bernoulli.ppf(prob, p))
True

生成随机数：

>>> r = bernoulli.rvs(p, size=1000)

方法

rvs(p, loc=0, size=1, random_state=None)	随机变量。
pmf(k, p, loc=0)	概率质量函数。
logpmf(k, p, loc=0)	概率质量函数的对数。
cdf(k, p, loc=0)	累积分布函数。
logcdf(k, p, loc=0)	累积分布函数的对数。
sf(k, p, loc=0)	生存函数（也定义为`1 - cdf`，但sf有时更准确）。
logsf(k, p, loc=0)	生存函数的对数。
ppf(q, p, loc=0)	百分点函数（`cdf`的逆 - 百分位数）。
isf(q, p, loc=0)	逆生存函数（`sf`的逆）。
stats(p, loc=0, moments=’mv’)	均值（‘m’）、方差（‘v’）、偏度（‘s’）、峰度（‘k’）。
entropy(p, loc=0)	随机变量的（微分）熵。
expect(func, args=(p,), loc=0, lb=None, ub=None, conditional=False)	期望值函数（一元函数）关于分布的期望值。
median(p, loc=0)	分布的中位数。
mean(p, loc=0)	分布的均值。
var(p, loc=0)	分布的方差。
std(p, loc=0)	分布的标准差。
interval(confidence, p, loc=0)	置信区间，围绕中位数具有相等面积。

`scipy.stats.betabinom`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.betabinom.html#scipy.stats.betabinom

scipy.stats.betabinom = <scipy.stats._discrete_distns.betabinom_gen object>

贝塔二项离散随机变量。

作为 rv_discrete 类的一个实例，betabinom 对象从中继承了一系列通用方法（详见下面的完整列表），并为此特定分布补充了特定的细节。

另见

beta, binom

注释

贝塔二项分布是一个具有成功概率 p 的二项分布，其符合贝塔分布。

betabinom 的概率质量函数为：

[f(k) = \binom{n}{k} \frac{B(k + a, n - k + b)}{B(a, b)}]

对于 (k \in {0, 1, \dots, n})，(n \geq 0)，(a > 0)，(b > 0)，其中 (B(a, b)) 是贝塔函数。

betabinom 以 (n)、(a) 和 (b) 作为形状参数。

参考资料

[1]

zh.wikipedia.org/wiki/贝塔二项分布

上述概率质量函数定义为“标准化”形式。要移动分布，请使用 loc 参数。具体而言，betabinom.pmf(k, n, a, b, loc) 等同于 betabinom.pmf(k - loc, n, a, b)。

新版本 1.4.0 中引入。

示例

>>> import numpy as np
>>> from scipy.stats import betabinom
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)

计算前四个矩：

>>> n, a, b = 5, 2.3, 0.63
>>> mean, var, skew, kurt = betabinom.stats(n, a, b, moments='mvsk')

显示概率质量函数（pmf）：

>>> x = np.arange(betabinom.ppf(0.01, n, a, b),
...               betabinom.ppf(0.99, n, a, b))
>>> ax.plot(x, betabinom.pmf(x, n, a, b), 'bo', ms=8, label='betabinom pmf')
>>> ax.vlines(x, 0, betabinom.pmf(x, n, a, b), colors='b', lw=5, alpha=0.5)

或者，可以调用分布对象（作为函数）来固定形状和位置。这将返回一个保持给定参数固定的“冻结”随机变量对象。

冻结分布并显示冻结的 pmf：

>>> rv = betabinom(n, a, b)
>>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1,
...         label='frozen pmf')
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()

../../_images/scipy-stats-betabinom-1_00_00.png

检查 cdf 和 ppf 的准确性：

>>> prob = betabinom.cdf(x, n, a, b)
>>> np.allclose(x, betabinom.ppf(prob, n, a, b))
True

生成随机数：

>>> r = betabinom.rvs(n, a, b, size=1000)

方法

rvs(n, a, b, loc=0, size=1, random_state=None)	随机变量。
pmf(k, n, a, b, loc=0)	概率质量函数。
logpmf(k, n, a, b, loc=0)	概率质量函数的对数。
cdf(k, n, a, b, loc=0)	累积分布函数。
logcdf(k, n, a, b, loc=0)	累积分布函数的对数。
sf(k, n, a, b, loc=0)	生存函数（也被定义为 `1 - cdf`，但sf有时更准确）。
logsf(k, n, a, b, loc=0)	生存函数的对数。
ppf(q, n, a, b, loc=0)	百分位点函数（`cdf`的反函数 — 百分位数）。
isf(q, n, a, b, loc=0)	生存函数的反函数（`sf`的反函数）。
stats(n, a, b, loc=0, moments=’mv’)	均值（‘m’）、方差（‘v’）、偏度（‘s’）、峰度（‘k’）。
entropy(n, a, b, loc=0)	(微分) 随机变量的熵。
expect(func, args=(n, a, b), loc=0, lb=None, ub=None, conditional=False)	对分布的一个函数（一个参数）的期望值。
median(n, a, b, loc=0)	分布的中位数。
mean(n, a, b, loc=0)	分布的均值。
var(n, a, b, loc=0)	分布的方差。
std(n, a, b, loc=0)	分布的标准偏差。
interval(confidence, n, a, b, loc=0)	中位数周围面积相等的置信区间。

`scipy.stats.betanbinom`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.betanbinom.html#scipy.stats.betanbinom

scipy.stats.betanbinom = <scipy.stats._discrete_distns.betanbinom_gen object>

贝塔负二项离散随机变量。

作为 rv_discrete 类的一个实例，betanbinom 对象继承了一组通用方法（请参阅下文的完整列表），并用此特定分布的详细信息补充了它们。

另请参见

贝塔二项分布

Beta 负二项分布

注意

贝塔负二项分布是具有成功概率 p 的贝塔分布的负二项分布。

betanbinom 的概率质量函数为：

[f(k) = \binom{n + k - 1}{k} \frac{B(a + n, b + k)}{B(a, b)}]

对于 (k \ge 0), (n \geq 0), (a > 0), (b > 0)，其中 (B(a, b)) 是贝塔函数。

betanbinom 接受 (n)、(a) 和 (b) 作为形状参数。

参考资料

[1]

en.wikipedia.org/wiki/Beta_negative_binomial_distribution

上述概率质量函数定义为“标准化”形式。要转移分布，请使用 loc 参数。具体来说，betanbinom.pmf(k, n, a, b, loc) 等同于 betanbinom.pmf(k - loc, n, a, b)。

自版本 1.12.0 起新增。

示例

>>> import numpy as np
>>> from scipy.stats import betanbinom
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)

计算前四个时刻：

>>> n, a, b = 5, 9.3, 1
>>> mean, var, skew, kurt = betanbinom.stats(n, a, b, moments='mvsk')

显示概率质量函数 (pmf)：

>>> x = np.arange(betanbinom.ppf(0.01, n, a, b),
...               betanbinom.ppf(0.99, n, a, b))
>>> ax.plot(x, betanbinom.pmf(x, n, a, b), 'bo', ms=8, label='betanbinom pmf')
>>> ax.vlines(x, 0, betanbinom.pmf(x, n, a, b), colors='b', lw=5, alpha=0.5)

或者，可以调用分布对象（作为函数）以固定形状和位置。这会返回一个固定给定参数的“冻结”RV 对象。

冻结分布并显示冻结的 pmf：

>>> rv = betanbinom(n, a, b)
>>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1,
...         label='frozen pmf')
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()

../../_images/scipy-stats-betanbinom-1_00_00.png

检查 cdf 和 ppf 的准确性：

>>> prob = betanbinom.cdf(x, n, a, b)
>>> np.allclose(x, betanbinom.ppf(prob, n, a, b))
True

生成随机数：

>>> r = betanbinom.rvs(n, a, b, size=1000)

方法

rvs(n, a, b, loc=0, size=1, random_state=None)	随机变量。
pmf(k, n, a, b, loc=0)	概率质量函数。
logpmf(k, n, a, b, loc=0)	概率质量函数的对数。
cdf(k, n, a, b, loc=0)	累积分布函数。
logcdf(k, n, a, b, loc=0)	累积分布函数的对数。
sf(k, n, a, b, loc=0)	生存函数（也定义为 `1 - cdf`，但 sf 有时更精确）。
logsf(k, n, a, b, loc=0)	生存函数的对数。
ppf(q, n, a, b, loc=0)	百分位点函数（`cdf` 的反函数，即百分位数）。
isf(q, n, a, b, loc=0)	生存函数的反函数（`sf` 的反函数）。
stats(n, a, b, loc=0, moments=’mv’)	均值（‘m’）、方差（‘v’）、偏度（‘s’）和/或峰度（‘k’）。
entropy(n, a, b, loc=0)	随机变量的（微分）熵。
expect(func, args=(n, a, b), loc=0, lb=None, ub=None, conditional=False)	期望值，针对分布的一个参数的函数（的一个参数）。
median(n, a, b, loc=0)	分布的中位数。
mean(n, a, b, loc=0)	分布的均值。
var(n, a, b, loc=0)	分布的方差。
std(n, a, b, loc=0)	分布的标准差。
interval(confidence, n, a, b, loc=0)	置信区间，围绕中位数有相等的面积。

`scipy.stats.binom`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.binom.html#scipy.stats.binom

scipy.stats.binom = <scipy.stats._discrete_distns.binom_gen object>

一个二项离散随机变量。

作为rv_discrete类的一个实例，binom 对象从中继承了一组通用方法（完整列表见下文），并通过特定于该特定分布的详细信息来完成它们。

另请参阅

hypergeom, nbinom, nhypergeom

注意事项

binom 的概率质量函数为：

[f(k) = \binom{n}{k} p^k (1-p)^{n-k}]

对于 (k \in {0, 1, \dots, n}), (0 \leq p \leq 1)

binom 接受n和p作为形状参数，其中p是单次成功的概率，1-p是单次失败的概率。

上述概率质量函数以“标准化”形式定义。要移动分布，请使用loc参数。具体地说，binom.pmf(k, n, p, loc)与binom.pmf(k - loc, n, p)等价。

示例

>>> import numpy as np
>>> from scipy.stats import binom
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)

计算前四个矩：

>>> n, p = 5, 0.4
>>> mean, var, skew, kurt = binom.stats(n, p, moments='mvsk')

显示概率质量函数（pmf）：

>>> x = np.arange(binom.ppf(0.01, n, p),
...               binom.ppf(0.99, n, p))
>>> ax.plot(x, binom.pmf(x, n, p), 'bo', ms=8, label='binom pmf')
>>> ax.vlines(x, 0, binom.pmf(x, n, p), colors='b', lw=5, alpha=0.5)

或者，可以调用分布对象（作为函数）来固定形状和位置。这会返回一个保持给定参数固定的“冻结”随机变量对象。

冻结分布并显示冻结的pmf：

>>> rv = binom(n, p)
>>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1,
...         label='frozen pmf')
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()

../../_images/scipy-stats-binom-1_00_00.png

检查cdf和ppf的准确性：

>>> prob = binom.cdf(x, n, p)
>>> np.allclose(x, binom.ppf(prob, n, p))
True

生成随机数：

>>> r = binom.rvs(n, p, size=1000)

方法

rvs(n, p, loc=0, size=1, random_state=None)	随机变量。
pmf(k, n, p, loc=0)	概率质量函数。
logpmf(k, n, p, loc=0)	概率质量函数的对数。
cdf(k, n, p, loc=0)	累积分布函数。
logcdf(k, n, p, loc=0)	累积分布函数的对数。
sf(k, n, p, loc=0)	生存函数（也定义为`1 - cdf`，但sf有时更精确）。
logsf(k, n, p, loc=0)	生存函数的对数。
ppf(q, n, p, loc=0)	百分位点函数（`cdf`的逆 — 百分位数）。
isf(q, n, p, loc=0)	逆生存函数（`sf`的逆）。
stats(n, p, loc=0, moments=’mv’)	均值（‘m’）、方差（‘v’）、偏度（‘s’）和/或峰度（‘k’）。
entropy(n, p, loc=0)	随机变量的（微分）熵。
expect(func, args=(n, p), loc=0, lb=None, ub=None, conditional=False)	期望值函数（一个参数）相对于分布的期望值。
median(n, p, loc=0)	分布的中位数。
mean(n, p, loc=0)	分布的平均值。
var(n, p, loc=0)	分布的方差。
std(n, p, loc=0)	分布的标准差。
interval(confidence, n, p, loc=0)	置信区间，围绕中位数具有相等的区域。

`scipy.stats.boltzmann`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.boltzmann.html#scipy.stats.boltzmann

scipy.stats.boltzmann = <scipy.stats._discrete_distns.boltzmann_gen object>

一种 Boltzmann（截断离散指数）随机变量。

作为rv_discrete类的一个实例，boltzmann 对象继承了一组通用方法（下面详细列出），并补充了特定于此特定分布的细节。

注意事项

boltzmann 的概率质量函数为：

[f(k) = (1-\exp(-\lambda)) \exp(-\lambda k) / (1-\exp(-\lambda N))]

对于 (k = 0,..., N-1)。

boltzmann 接受 (\lambda > 0) 和 (N > 0) 作为形状参数。

上述概率质量函数以“标准化”形式定义。要移动分布，请使用loc参数。具体而言，boltzmann.pmf(k, lambda_, N, loc) 与 boltzmann.pmf(k - loc, lambda_, N) 完全等效。

示例

>>> import numpy as np
>>> from scipy.stats import boltzmann
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)

计算前四个时刻：

>>> lambda_, N = 1.4, 19
>>> mean, var, skew, kurt = boltzmann.stats(lambda_, N, moments='mvsk')

显示概率质量函数（pmf）：

>>> x = np.arange(boltzmann.ppf(0.01, lambda_, N),
...               boltzmann.ppf(0.99, lambda_, N))
>>> ax.plot(x, boltzmann.pmf(x, lambda_, N), 'bo', ms=8, label='boltzmann pmf')
>>> ax.vlines(x, 0, boltzmann.pmf(x, lambda_, N), colors='b', lw=5, alpha=0.5)

或者，可以调用分布对象（作为函数）以固定形状和位置。这将返回一个“冻结的”RV 对象，其中包含给定的固定参数。

冻结分布并显示冻结的pmf：

>>> rv = boltzmann(lambda_, N)
>>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1,
...         label='frozen pmf')
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()

../../_images/scipy-stats-boltzmann-1_00_00.png

检查cdf和ppf的准确性：

>>> prob = boltzmann.cdf(x, lambda_, N)
>>> np.allclose(x, boltzmann.ppf(prob, lambda_, N))
True

生成随机数：

>>> r = boltzmann.rvs(lambda_, N, size=1000)

方法

rvs(lambda_, N, loc=0, size=1, random_state=None)	随机变量。
pmf(k, lambda_, N, loc=0)	概率质量函数。
logpmf(k, lambda_, N, loc=0)	概率质量函数的对数。
cdf(k, lambda_, N, loc=0)	累积分布函数。
logcdf(k, lambda_, N, loc=0)	累积分布函数的对数。
sf(k, lambda_, N, loc=0)	生存函数（也被定义为`1 - cdf`，但sf有时更精确）。
logsf(k, lambda_, N, loc=0)	生存函数的对数。
ppf(q, lambda_, N, loc=0)	百分点函数（`cdf`的逆 — 百分位数）。
isf(q, lambda_, N, loc=0)	逆生存函数（`sf`的逆）。
stats(lambda_, N, loc=0, moments=’mv’)	平均值（‘m’）、方差（‘v’）、偏度（‘s’）和/或峰度（‘k’）。
entropy(lambda_, N, loc=0)	RV 的（微分）熵。
expect(func, args=(lambda_, N), loc=0, lb=None, ub=None, conditional=False)	函数期望值（一个参数的函数）。
median(lambda_, N, loc=0)	分布的中位数。
mean(lambda_, N, loc=0)	分布的均值。
var(lambda_, N, loc=0)	分布的方差。
std(lambda_, N, loc=0)	分布的标准差（lambda，N，位置=0）。
interval(confidence, lambda_, N, loc=0)	区间（置信度，lambda，N，位置=0），中位数周围具有相等面积的置信区间。

`scipy.stats.dlaplace`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.dlaplace.html#scipy.stats.dlaplace

scipy.stats.dlaplace = <scipy.stats._discrete_distns.dlaplace_gen object>

一个拉普拉斯离散随机变量。

作为 rv_discrete 类的一个实例，dlaplace 对象继承了一组通用方法（下面详细列出），并用特定于此特定分布的细节完善了它们。

注意事项

dlaplace 的概率质量函数为：

[f(k) = \tanh(a/2) \exp(-a |k|)]

对于整数 (k) 和 (a > 0)。

dlaplace 以参数 (a) 作为形状参数。

上述概率质量函数以“标准化”形式定义。使用 loc 参数来移动分布。具体地，dlaplace.pmf(k, a, loc) 与 dlaplace.pmf(k - loc, a) 完全等价。

示例

>>> import numpy as np
>>> from scipy.stats import dlaplace
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)

计算前四个矩：

>>> a = 0.8
>>> mean, var, skew, kurt = dlaplace.stats(a, moments='mvsk')

显示概率质量函数（pmf）：

>>> x = np.arange(dlaplace.ppf(0.01, a),
...               dlaplace.ppf(0.99, a))
>>> ax.plot(x, dlaplace.pmf(x, a), 'bo', ms=8, label='dlaplace pmf')
>>> ax.vlines(x, 0, dlaplace.pmf(x, a), colors='b', lw=5, alpha=0.5)

或者，可以调用分布对象（作为函数）以固定形状和位置。这将返回一个固定给定参数的“冻结”随机变量对象。

冻结分布并显示冻结的 pmf：

>>> rv = dlaplace(a)
>>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1,
...         label='frozen pmf')
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()

../../_images/scipy-stats-dlaplace-1_00_00.png

检查 cdf 和 ppf 的准确性：

>>> prob = dlaplace.cdf(x, a)
>>> np.allclose(x, dlaplace.ppf(prob, a))
True

生成随机数：

>>> r = dlaplace.rvs(a, size=1000)

方法

rvs(a, loc=0, size=1, random_state=None)	随机变量。
pmf(k, a, loc=0)	概率质量函数。
logpmf(k, a, loc=0)	概率质量函数的对数。
cdf(k, a, loc=0)	累积分布函数。
logcdf(k, a, loc=0)	累积分布函数的对数。
sf(k, a, loc=0)	生存函数（也定义为 `1 - cdf`，但 sf 有时更准确）。
logsf(k, a, loc=0)	生存函数的对数。
ppf(q, a, loc=0)	百分点函数（`cdf` 的反函数 — 百分位数）。
isf(q, a, loc=0)	生存函数的逆函数（`sf` 的逆函数）。
stats(a, loc=0, moments=’mv’)	均值（‘m’），方差（‘v’），偏度（‘s’），及/或峰度（‘k’）。
entropy(a, loc=0)	随机变量的（微分）熵。
expect(func, args=(a,), loc=0, lb=None, ub=None, conditional=False)	对分布的函数（一个参数的函数）的期望值。
median(a, loc=0)	分布的中位数。
mean(a, loc=0)	分布的均值。
var(a, loc=0)	分布的方差。
std(a, loc=0)	分布的标准偏差。
interval(confidence, a, loc=0)	中位数周围具有相等面积的置信区间。

`scipy.stats.geom`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.geom.html#scipy.stats.geom

scipy.stats.geom = <scipy.stats._discrete_distns.geom_gen object>

几何离散随机变量。

作为rv_discrete类的一个实例，geom对象从中继承了一系列通用方法（详见下文的完整列表），并补充了针对该特定分布的详细信息。

另请参阅

planck

注意事项

geom的概率质量函数为：

[f(k) = (1-p)^{k-1} p]

对于(k \ge 1), (0 < p \leq 1)

geom以(p)作为形状参数，其中(p)是单次成功的概率，(1-p)是单次失败的概率。

上述概率质量函数以“标准化”形式定义。使用loc参数来移动分布。具体而言，geom.pmf(k, p, loc)与geom.pmf(k - loc, p)完全等价。

示例

>>> import numpy as np
>>> from scipy.stats import geom
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)

计算前四个时刻：

>>> p = 0.5
>>> mean, var, skew, kurt = geom.stats(p, moments='mvsk')

显示概率质量函数（pmf）：

>>> x = np.arange(geom.ppf(0.01, p),
...               geom.ppf(0.99, p))
>>> ax.plot(x, geom.pmf(x, p), 'bo', ms=8, label='geom pmf')
>>> ax.vlines(x, 0, geom.pmf(x, p), colors='b', lw=5, alpha=0.5)

或者，可以调用分布对象（作为函数）以固定形状和位置。这将返回一个“冻结”的 RV 对象，其中包含给定的参数。

冻结分布并显示冻结的pmf：

>>> rv = geom(p)
>>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1,
...         label='frozen pmf')
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()

../../_images/scipy-stats-geom-1_00_00.png

检查cdf和ppf的准确性：

>>> prob = geom.cdf(x, p)
>>> np.allclose(x, geom.ppf(prob, p))
True

生成随机数：

>>> r = geom.rvs(p, size=1000)

方法

rvs(p, loc=0, size=1, random_state=None)	随机变量。
pmf(k, p, loc=0)	概率质量函数。
logpmf(k, p, loc=0)	概率质量函数的对数。
cdf(k, p, loc=0)	累积分布函数。
logcdf(k, p, loc=0)	累积分布函数的对数。
sf(k, p, loc=0)	生存函数（也定义为`1 - cdf`，但sf有时更精确）。
logsf(k, p, loc=0)	生存函数的对数。
ppf(q, p, loc=0)	百分位点函数（`cdf`的反函数——百分位数）。
isf(q, p, loc=0)	生存函数的反函数（`sf`的反函数）。
stats(p, loc=0, moments=’mv’)	均值（‘m’）、方差（‘v’）、偏度（‘s’）和/或峰度（‘k’）。
entropy(p, loc=0)	RV 的（微分）熵。
expect(func, args=(p,), loc=0, lb=None, ub=None, conditional=False)	对于分布的函数（一个参数）的期望值。
median(p, loc=0)	分布的中位数。
mean(p, loc=0)	分布的均值。
var(p, loc=0)	分布的方差。
std(p, loc=0)	分布的标准差。
interval(confidence, p, loc=0)	等面积置信区间围绕中位数。

`scipy.stats.hypergeom`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.hypergeom.html#scipy.stats.hypergeom

scipy.stats.hypergeom = <scipy.stats._discrete_distns.hypergeom_gen object>

一个超几何离散随机变量。

超几何分布模型是从一个箱子中抽取物体的一种模型。M 是总物体数，n 是类型 I 物体的总数。随机变量表示从总体中不放回地抽取 N 个物体时的类型 I 物体数量。

作为 rv_discrete 类的一个实例，hypergeom 对象从中继承了一组通用方法（下文列出），并用特定于这种分布的细节来补充它们。

另见

nhypergeom, binom, nbinom

注意

用来表示形状参数（M、n 和 N）的符号并非被普遍接受。查看示例以澄清此处使用的定义。

概率质量函数定义如下，

[p(k, M, n, N) = \frac{\binom{n}{k} \binom{M - n}{N - k}} {\binom{M}{N}}]

对于 (k \in [\max(0, N - M + n), \min(n, N)])，其中二项式系数定义为，

[\binom{n}{k} \equiv \frac{n!}{k! (n - k)!}.]

上述概率质量函数以“标准化”形式定义。要移动分布，请使用 loc 参数。具体而言，hypergeom.pmf(k, M, n, N, loc) 等同于 hypergeom.pmf(k - loc, M, n, N)。

示例

>>> import numpy as np
>>> from scipy.stats import hypergeom
>>> import matplotlib.pyplot as plt

假设我们有一组包含 20 只动物，其中有 7 只狗。如果我们想知道在我们随机选择这 20 只动物中的 12 只时找到指定数量的狗的概率，我们可以初始化一个冻结的分布并绘制概率质量函数：

>>> [M, n, N] = [20, 7, 12]
>>> rv = hypergeom(M, n, N)
>>> x = np.arange(0, n+1)
>>> pmf_dogs = rv.pmf(x)

>>> fig = plt.figure()
>>> ax = fig.add_subplot(111)
>>> ax.plot(x, pmf_dogs, 'bo')
>>> ax.vlines(x, 0, pmf_dogs, lw=2)
>>> ax.set_xlabel('# of dogs in our group of chosen animals')
>>> ax.set_ylabel('hypergeom PMF')
>>> plt.show()

../../_images/scipy-stats-hypergeom-1_00_00.png

不使用冻结分布，我们也可以直接使用 hypergeom 方法。例如，要获得累积分布函数，使用：

>>> prb = hypergeom.cdf(x, M, n, N)

并生成随机数：

>>> R = hypergeom.rvs(M, n, N, size=10)

方法

rvs(M, n, N, loc=0, size=1, random_state=None)	随机变量。
pmf(k, M, n, N, loc=0)	概率质量函数。
logpmf(k, M, n, N, loc=0)	概率质量函数的对数。
cdf(k, M, n, N, loc=0)	累积分布函数。
logcdf(k, M, n, N, loc=0)	累积分布函数的对数。
sf(k, M, n, N, loc=0)	生存函数（也定义为 `1 - cdf`，但 sf 有时更精确）。
logsf(k, M, n, N, loc=0)	生存函数的对数。
ppf(q, M, n, N, loc=0)	百分位点函数（`cdf`的逆函数——百分位数）。
isf(q, M, n, N, loc=0)	逆生存函数（`sf`的逆函数）。
stats(M, n, N, loc=0, moments=’mv’)	均值（‘m’）、方差（‘v’）、偏度（‘s’）和/或峰度（‘k’）。
entropy(M, n, N, loc=0)	(微分)随机变量的熵。
expect(func, args=(M, n, N), loc=0, lb=None, ub=None, conditional=False)	对于分布的一个参数的函数的期望值。
median(M, n, N, loc=0)	分布的中位数。
mean(M, n, N, loc=0)	分布的均值。
var(M, n, N, loc=0)	分布的方差。
std(M, n, N, loc=0)	分布的标准差。
interval(confidence, M, n, N, loc=0)	围绕中位数的等面积置信区间。

`scipy.stats.logser`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.logser.html#scipy.stats.logser

scipy.stats.logser = <scipy.stats._discrete_distns.logser_gen object>

一个对数（Log-Series, Series）离散随机变量。

作为rv_discrete类的一个实例，logser对象继承了一组通用方法（下面详细列出），并添加了特定于这个特定分布的细节。

注意

logser的概率质量函数为：

[f(k) = - \frac{p^k}{k \log(1-p)}]

对于 (k \ge 1), (0 < p < 1)

logser以参数 (p) 为形状参数，其中 (p) 是单次成功的概率，(1-p) 是单次失败的概率。

上述概率质量函数在“标准化”形式中定义。要移动分布，请使用 loc 参数。具体地说，logser.pmf(k, p, loc) 与 logser.pmf(k - loc, p) 完全相同。

示例

>>> import numpy as np
>>> from scipy.stats import logser
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)

计算前四个矩：

>>> p = 0.6
>>> mean, var, skew, kurt = logser.stats(p, moments='mvsk')

显示概率质量函数（pmf）：

>>> x = np.arange(logser.ppf(0.01, p),
...               logser.ppf(0.99, p))
>>> ax.plot(x, logser.pmf(x, p), 'bo', ms=8, label='logser pmf')
>>> ax.vlines(x, 0, logser.pmf(x, p), colors='b', lw=5, alpha=0.5)

或者，可以调用分布对象（作为函数），以固定形状和位置。这返回一个保持给定参数固定的“冻结”RV 对象。

冻结分布并显示冻结的 pmf：

>>> rv = logser(p)
>>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1,
...         label='frozen pmf')
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()

../../_images/scipy-stats-logser-1_00_00.png

检查 cdf 和 ppf 的准确性：

>>> prob = logser.cdf(x, p)
>>> np.allclose(x, logser.ppf(prob, p))
True

生成随机数：

>>> r = logser.rvs(p, size=1000)

方法

rvs(p, loc=0, size=1, random_state=None)	随机变量。
pmf(k, p, loc=0)	概率质量函数。
logpmf(k, p, loc=0)	概率质量函数的对数。
cdf(k, p, loc=0)	累积分布函数。
logcdf(k, p, loc=0)	累积分布函数的对数。
sf(k, p, loc=0)	生存函数（也定义为 `1 - cdf`，但有时 sf 更精确）。
logsf(k, p, loc=0)	生存函数的对数。
ppf(q, p, loc=0)	百分位点函数（`cdf` 的逆函数 — 百分位数）。
isf(q, p, loc=0)	逆生存函数（`sf` 的逆函数）。
stats(p, loc=0, moments=’mv’)	均值（‘m’），方差（‘v’），偏度（‘s’），以及/或峰度（‘k’）。
entropy(p, loc=0)	RV 的（微分）熵。
expect(func, args=(p,), loc=0, lb=None, ub=None, conditional=False)	期望值（对于一个参数的函数）关于分布。
median(p, loc=0)	分布的中位数。
mean(p, loc=0)	分布的均值。
var(p, loc=0)	分布的方差。
std(p, loc=0)	分布的标准偏差。
interval(confidence, p, loc=0)	置信区间，围绕中位数等面积。

SciPy-1-12-中文文档-五十八-

SciPy 1.12 中文文档（五十八）

scipy.stats.invwishart

scipy.stats.multinomial

scipy.stats.special_ortho_group

scipy.stats.ortho_group

scipy.stats.unitary_group

scipy.stats.random_correlation

scipy.stats.multivariate_t

scipy.stats.multivariate_hypergeom

scipy.stats.random_table

scipy.stats.uniform_direction

scipy.stats.vonmises_fisher

scipy.stats.Covariance

scipy.stats.bernoulli

scipy.stats.betabinom

scipy.stats.betanbinom

scipy.stats.binom

scipy.stats.boltzmann

scipy.stats.dlaplace

scipy.stats.geom

scipy.stats.hypergeom

scipy.stats.logser

`scipy.stats.invwishart`

`scipy.stats.multinomial`

`scipy.stats.special_ortho_group`

`scipy.stats.ortho_group`

`scipy.stats.unitary_group`

`scipy.stats.random_correlation`

`scipy.stats.multivariate_t`

`scipy.stats.multivariate_hypergeom`

`scipy.stats.random_table`

`scipy.stats.uniform_direction`

`scipy.stats.vonmises_fisher`

`scipy.stats.Covariance`

`scipy.stats.bernoulli`

`scipy.stats.betabinom`

`scipy.stats.betanbinom`

`scipy.stats.binom`

`scipy.stats.boltzmann`

`scipy.stats.dlaplace`

`scipy.stats.geom`

`scipy.stats.hypergeom`

`scipy.stats.logser`