统计#
SymPy统计模块
在SymPy语言中引入随机变量类型。
随机变量可以使用预先构建的函数来声明，如正态、指数、硬币、骰子等。。。或者用FiniteRV之类的函数构建。
可以使用函数对随机表达式进行查询
表情 |
意义 |
|
概率 |
|
期望值 |
|
熵 |
|
方差 |
|
概率密度函数 |
|
实现 |
|
条件是真的 |
实例#
>>> from sympy.stats import P, E, variance, Die, Normal
>>> from sympy import simplify
>>> X, Y = Die('X', 6), Die('Y', 6) # Define two six sided dice
>>> Z = Normal('Z', 0, 1) # Declare a Normal random variable with mean 0, std 1
>>> P(X>3) # Probability X is greater than 3
1/2
>>> E(X+Y) # Expectation of the sum of two dice
7
>>> variance(X+Y) # Variance of the sum of two dice
35/6
>>> simplify(P(Z>1)) # Probability of Z being greater than 1
1/2 - erf(sqrt(2)/2)/2
还可以创建自定义分布并定义自定义随机变量，如下所示：
如果要创建连续随机变量：
>>> from sympy.stats import ContinuousRV, P, E
>>> from sympy import exp, Symbol, Interval, oo
>>> x = Symbol('x')
>>> pdf = exp(-x) # pdf of the Continuous Distribution
>>> Z = ContinuousRV(x, pdf, set=Interval(0, oo))
>>> E(Z)
1
>>> P(Z > 5)
exp(-5)
1.1要创建连续分布的实例：
>>> from sympy.stats import ContinuousDistributionHandmade
>>> from sympy import Lambda
>>> dist = ContinuousDistributionHandmade(Lambda(x, pdf), set=Interval(0, oo))
>>> dist.pdf(x)
exp(-x)
如果要创建离散随机变量：
>>> from sympy.stats import DiscreteRV, P, E
>>> from sympy import Symbol, S
>>> p = S(1)/2
>>> x = Symbol('x', integer=True, positive=True)
>>> pdf = p*(1 - p)**(x - 1)
>>> D = DiscreteRV(x, pdf, set=S.Naturals)
>>> E(D)
2
>>> P(D > 3)
1/8
2.1要创建离散分布的实例：
>>> from sympy.stats import DiscreteDistributionHandmade
>>> from sympy import Lambda
>>> dist = DiscreteDistributionHandmade(Lambda(x, pdf), set=S.Naturals)
>>> dist.pdf(x)
2**(1 - x)/2
如果要创建有限随机变量：
>>> from sympy.stats import FiniteRV, P, E
>>> from sympy import Rational, Eq
>>> pmf = {1: Rational(1, 3), 2: Rational(1, 6), 3: Rational(1, 4), 4: Rational(1, 4)}
>>> X = FiniteRV('X', pmf)
>>> E(X)
29/12
>>> P(X > 3)
1/4
3.1要创建有限分布的实例：
>>> from sympy.stats import FiniteDistributionHandmade
>>> dist = FiniteDistributionHandmade(pmf)
>>> dist.pmf(x)
Lambda(x, Piecewise((1/3, Eq(x, 1)), (1/6, Eq(x, 2)), (1/4, Eq(x, 3) | Eq(x, 4)), (0, True)))
随机变量类型#
有限类型#
- sympy.stats.DiscreteUniform(name, items)[源代码]#
创建一个有限随机变量，表示输入集中的均匀分布。
- 参数:
items : list/tuple
要进行统一分配的项目
- 返回:
RandomSymbol
实例
>>> from sympy.stats import DiscreteUniform, density >>> from sympy import symbols
>>> X = DiscreteUniform('X', symbols('a b c')) # equally likely over a, b, c >>> density(X).dict {a: 1/3, b: 1/3, c: 1/3}
>>> Y = DiscreteUniform('Y', list(range(5))) # distribution over a range >>> density(Y).dict {0: 1/5, 1: 1/5, 2: 1/5, 3: 1/5, 4: 1/5}
工具书类
- sympy.stats.Die(name, sides=6)[源代码]#
创建一个表示公平骰子的有限随机变量。
- 参数:
sides : Integer
表示模具的边数，默认为6
- 返回:
RandomSymbol
实例
>>> from sympy.stats import Die, density >>> from sympy import Symbol
>>> D6 = Die('D6', 6) # Six sided Die >>> density(D6).dict {1: 1/6, 2: 1/6, 3: 1/6, 4: 1/6, 5: 1/6, 6: 1/6}
>>> D4 = Die('D4', 4) # Four sided Die >>> density(D4).dict {1: 1/4, 2: 1/4, 3: 1/4, 4: 1/4}
>>> n = Symbol('n', positive=True, integer=True) >>> Dn = Die('Dn', n) # n sided Die >>> density(Dn).dict Density(DieDistribution(n)) >>> density(Dn).dict.subs(n, 4).doit() {1: 1/4, 2: 1/4, 3: 1/4, 4: 1/4}
- sympy.stats.Bernoulli(name, p, succ=1, fail=0)[源代码]#
创建一个表示伯努利过程的有限随机变量。
- 参数:
p 有理数在0和1之间
表示成功的概率
succ ：整数/符号/字符串
代表成功事件
fail ：整数/符号/字符串
表示故障事件
- 返回:
RandomSymbol
实例
>>> from sympy.stats import Bernoulli, density >>> from sympy import S
>>> X = Bernoulli('X', S(3)/4) # 1-0 Bernoulli variable, probability = 3/4 >>> density(X).dict {0: 1/4, 1: 3/4}
>>> X = Bernoulli('X', S.Half, 'Heads', 'Tails') # A fair coin toss >>> density(X).dict {Heads: 1/2, Tails: 1/2}
工具书类
- sympy.stats.Coin(name, p=1 / 2)[源代码]#
创建一个表示抛硬币的有限随机变量。
- 参数:
p ：0到1之间的有理数
表示获得“头”的概率，默认为一半
- 返回:
RandomSymbol
实例
>>> from sympy.stats import Coin, density >>> from sympy import Rational
>>> C = Coin('C') # A fair coin toss >>> density(C).dict {H: 1/2, T: 1/2}
>>> C2 = Coin('C2', Rational(3, 5)) # An unfair coin >>> density(C2).dict {H: 3/5, T: 2/5}
工具书类
- sympy.stats.Binomial(name, n, p, succ=1, fail=0)[源代码]#
创建一个表示二项分布的有限随机变量。
- 参数:
n ：正整数
表示试验次数
p ：0到1之间的有理数
表示成功的概率
succ ：整数/符号/字符串
表示成功事件，默认为1
fail ：整数/符号/字符串
表示失败事件，默认为0
- 返回:
RandomSymbol
实例
>>> from sympy.stats import Binomial, density >>> from sympy import S, Symbol
>>> X = Binomial('X', 4, S.Half) # Four "coin flips" >>> density(X).dict {0: 1/16, 1: 1/4, 2: 3/8, 3: 1/4, 4: 1/16}
>>> n = Symbol('n', positive=True, integer=True) >>> p = Symbol('p', positive=True) >>> X = Binomial('X', n, S.Half) # n "coin flips" >>> density(X).dict Density(BinomialDistribution(n, 1/2, 1, 0)) >>> density(X).dict.subs(n, 4).doit() {0: 1/16, 1: 1/4, 2: 3/8, 3: 1/4, 4: 1/16}
工具书类
- sympy.stats.BetaBinomial(name, n, alpha, beta)[源代码]#
创建一个表示β二项分布的有限随机变量。
- 参数:
n ：正整数
表示试验次数
阿尔法 ：实正数
beta ：实正数
- 返回:
RandomSymbol
实例
>>> from sympy.stats import BetaBinomial, density
>>> X = BetaBinomial('X', 2, 1, 1) >>> density(X).dict {0: 1/3, 1: 2*beta(2, 2), 2: 1/3}
工具书类
- sympy.stats.Hypergeometric(name, N, m, n)[源代码]#
创建表示超几何分布的有限随机变量。
- 参数:
N ：正整数
表示大小为N的有限总体。
m ：正整数
表示具有所需功能的试用次数。
n ：正整数
表示绘制数。
- 返回:
RandomSymbol
实例
>>> from sympy.stats import Hypergeometric, density
>>> X = Hypergeometric('X', 10, 5, 3) # 10 marbles, 5 white (success), 3 draws >>> density(X).dict {0: 1/12, 1: 5/12, 2: 5/12, 3: 1/12}
工具书类
- sympy.stats.FiniteRV(name, density, **kwargs)[源代码]#
创建一个有限的随机变量给定一个代表密度的dict。
- 参数:
name ：符号
表示随机变量的名称。
density : dict
Dictionary containing the pdf of finite distribution
检查 布尔
如果为真，它将检查给定的密度是否在给定集上积分为1。如果为False，则不执行此检查。默认值为False。
- 返回:
RandomSymbol
实例
>>> from sympy.stats import FiniteRV, P, E
>>> density = {0: .1, 1: .2, 2: .3, 3: .4} >>> X = FiniteRV('X', density)
>>> E(X) 2.00000000000000 >>> P(X >= 2) 0.700000000000000
离散类型#
- sympy.stats.Geometric(name, p)[源代码]#
创建具有几何分布的离散随机变量。
- 参数:
p : A probability between 0 and 1
- 返回:
RandomSymbol
解释
几何分布密度由
\[f（k）：=p（1-p）^{k-1}\]实例
>>> from sympy.stats import Geometric, density, E, variance >>> from sympy import Symbol, S
>>> p = S.One / 5 >>> z = Symbol("z")
>>> X = Geometric("x", p)
>>> density(X)(z) (5/4)**(1 - z)/5
>>> E(X) 5
>>> variance(X) 20
工具书类
- sympy.stats.Hermite(name, a1, a2)[源代码]#
创建一个具有Hermite分布的离散随机变量。
- 参数:
a1 : A Positive number greater than equal to 0.
a2 : A Positive number greater than equal to 0.
- 返回:
RandomSymbol
解释
Hermite分布的密度由
\[f（x）：=e^{-a1-a2}\sum{j=0}^{\left\lfloor x/2\right\rfloor}\]实例
>>> from sympy.stats import Hermite, density, E, variance >>> from sympy import Symbol
>>> a1 = Symbol("a1", positive=True) >>> a2 = Symbol("a2", positive=True) >>> x = Symbol("x")
>>> H = Hermite("H", a1=5, a2=4)
>>> density(H)(2) 33*exp(-9)/2
>>> E(H) 13
>>> variance(H) 21
工具书类
- sympy.stats.Poisson(name, lamda)[源代码]#
创建一个具有泊松分布的离散随机变量。
- 参数:
lamda : Positive number, a rate
- 返回:
RandomSymbol
解释
泊松分布的密度由
\[f（k）：=\frac{\lambda^{k}e^{-\lambda}}{k！}\]实例
>>> from sympy.stats import Poisson, density, E, variance >>> from sympy import Symbol, simplify
>>> rate = Symbol("lambda", positive=True) >>> z = Symbol("z")
>>> X = Poisson("x", rate)
>>> density(X)(z) lambda**z*exp(-lambda)/factorial(z)
>>> E(X) lambda
>>> simplify(variance(X)) lambda
工具书类
- sympy.stats.Logarithmic(name, p)[源代码]#
创建一个对数分布的离散随机变量。
- 参数:
p : A value between 0 and 1
- 返回:
RandomSymbol
解释
对数分布的密度由
\[{\ln{p（k）{p（k）}\]实例
>>> from sympy.stats import Logarithmic, density, E, variance >>> from sympy import Symbol, S
>>> p = S.One / 5 >>> z = Symbol("z")
>>> X = Logarithmic("x", p)
>>> density(X)(z) -1/(5**z*z*log(4/5))
>>> E(X) -1/(-4*log(5) + 8*log(2))
>>> variance(X) -1/((-4*log(5) + 8*log(2))*(-2*log(5) + 4*log(2))) + 1/(-64*log(2)*log(5) + 64*log(2)**2 + 16*log(5)**2) - 10/(-32*log(5) + 64*log(2))
工具书类
- sympy.stats.NegativeBinomial(name, r, p)[源代码]#
创建一个负二项分布的离散随机变量。
- 参数:
r : A positive value
p : A value between 0 and 1
- 返回:
RandomSymbol
解释
负二项分布的密度由
\[f（k）：=\binom{k+r-1}{k}（1-p）^r p^k\]实例
>>> from sympy.stats import NegativeBinomial, density, E, variance >>> from sympy import Symbol, S
>>> r = 5 >>> p = S.One / 5 >>> z = Symbol("z")
>>> X = NegativeBinomial("x", r, p)
>>> density(X)(z) 1024*binomial(z + 4, z)/(3125*5**z)
>>> E(X) 5/4
>>> variance(X) 25/16
工具书类
- sympy.stats.Skellam(name, mu1, mu2)[源代码]#
创建一个具有Skellam分布的离散随机变量。
- 参数:
mu1 : A non-negative value
mu2 : A non-negative value
- 返回:
RandomSymbol
解释
Skellam是两个统计上独立的随机变量N1和N2的差值N1-N2的分布，每个Poisson分布有各自的期望值mu1和mu2。
Skellam分布的密度由下式给出
\[f（k）：=e^{-（\mu_1+\mu_2）}（\frac{\mu_1}{\mu_2}）^{k/2}I}（2\sqrt{\mu_1\mu_2}）\]实例
>>> from sympy.stats import Skellam, density, E, variance >>> from sympy import Symbol, pprint
>>> z = Symbol("z", integer=True) >>> mu1 = Symbol("mu1", positive=True) >>> mu2 = Symbol("mu2", positive=True) >>> X = Skellam("x", mu1, mu2)
>>> pprint(density(X)(z), use_unicode=False) z - 2 /mu1\ -mu1 - mu2 / _____ _____\ |---| *e *besseli\z, 2*\/ mu1 *\/ mu2 / \mu2/ >>> E(X) mu1 - mu2 >>> variance(X).expand() mu1 + mu2
工具书类
- sympy.stats.YuleSimon(name, rho)[源代码]#
用Yule-Simon分布创建一个离散随机变量。
- 参数:
rho : A positive value
- 返回:
RandomSymbol
解释
Yule-Simon分布的密度由下式给出
\[f（k）：=\rho B（k，rho+1）\]实例
>>> from sympy.stats import YuleSimon, density, E, variance >>> from sympy import Symbol, simplify
>>> p = 5 >>> z = Symbol("z")
>>> X = YuleSimon("x", p)
>>> density(X)(z) 5*beta(z, 6)
>>> simplify(E(X)) 5/4
>>> simplify(variance(X)) 25/48
工具书类
- sympy.stats.Zeta(name, s)[源代码]#
用Zeta分布创建一个离散随机变量。
- 参数:
s : A value greater than 1
- 返回:
RandomSymbol
解释
Zeta分布的密度由
\[f（k）：=\frac{1}{k^s\zeta{（s）}\]实例
>>> from sympy.stats import Zeta, density, E, variance >>> from sympy import Symbol
>>> s = 5 >>> z = Symbol("z")
>>> X = Zeta("x", s)
>>> density(X)(z) 1/(z**5*zeta(5))
>>> E(X) pi**4/(90*zeta(5))
>>> variance(X) -pi**8/(8100*zeta(5)**2) + zeta(3)/zeta(5)
工具书类
连续类型#
- sympy.stats.Arcsin(name, a=0, b=1)[源代码]#
创建一个连续的随机变量与一个弧形分布。
弧素分布的密度由下式给出
\[f（x）：=\frac{1}{\pi\sqrt{（x-a）（b-x）}}\]具有 \(x \in (a,b)\) . 它必须保持住 \(-\infty < a < b < \infty\) .
- 参数:
a ：实数，左边的间隔边界
b ：实数，右区间边界
- 返回:
RandomSymbol
实例
>>> from sympy.stats import Arcsin, density, cdf >>> from sympy import Symbol
>>> a = Symbol("a", real=True) >>> b = Symbol("b", real=True) >>> z = Symbol("z")
>>> X = Arcsin("x", a, b)
>>> density(X)(z) 1/(pi*sqrt((-a + z)*(b - z)))
>>> cdf(X)(z) Piecewise((0, a > z), (2*asin(sqrt((-a + z)/(-a + b)))/pi, b >= z), (1, True))
工具书类
- sympy.stats.Benini(name, alpha, beta, sigma)[源代码]#
创建一个具有Benini分布的连续随机变量。
贝尼尼分布的密度由
\[f(x) := e^{-\alpha\log{\frac{x}{\sigma}} -\beta\log^2\left[{\frac{x}{\sigma}}\right]} \left(\frac{\alpha}{x}+\frac{2\beta\log{\frac{x}{\sigma}}}{x}\right)\]这是一个重尾分布，也称为对数瑞利分布。
- 参数:
阿尔法 ：实数， \(\alpha > 0\) ，一个形状
beta ：实数， \(\beta > 0\) ，一个形状
西格玛 ：实数， \(\sigma > 0\) ，一个天平
- 返回:
RandomSymbol
实例
>>> from sympy.stats import Benini, density, cdf >>> from sympy import Symbol, pprint
>>> alpha = Symbol("alpha", positive=True) >>> beta = Symbol("beta", positive=True) >>> sigma = Symbol("sigma", positive=True) >>> z = Symbol("z")
>>> X = Benini("x", alpha, beta, sigma)
>>> D = density(X)(z) >>> pprint(D, use_unicode=False) / / z \\ / z \ 2/ z \ | 2*beta*log|-----|| - alpha*log|-----| - beta*log |-----| |alpha \sigma/| \sigma/ \sigma/ |----- + -----------------|*e \ z z /
>>> cdf(X)(z) Piecewise((1 - exp(-alpha*log(z/sigma) - beta*log(z/sigma)**2), sigma <= z), (0, True))
工具书类
- sympy.stats.Beta(name, alpha, beta)[源代码]#
创建一个具有β分布的连续随机变量。
β分布的密度由
\[f（x）：=\frac{x^{\alpha-1}（1-x）^{\beta-1}}{\mathrm{B}（\alpha，beta）}\]具有 \(x \in [0,1]\) .
- 参数:
阿尔法 ：实数， \(\alpha > 0\) ，一个形状
beta ：实数， \(\beta > 0\) ，一个形状
- 返回:
RandomSymbol
实例
>>> from sympy.stats import Beta, density, E, variance >>> from sympy import Symbol, simplify, pprint, factor
>>> alpha = Symbol("alpha", positive=True) >>> beta = Symbol("beta", positive=True) >>> z = Symbol("z")
>>> X = Beta("x", alpha, beta)
>>> D = density(X)(z) >>> pprint(D, use_unicode=False) alpha - 1 beta - 1 z *(1 - z) -------------------------- B(alpha, beta)
>>> simplify(E(X)) alpha/(alpha + beta)
>>> factor(simplify(variance(X))) alpha*beta/((alpha + beta)**2*(alpha + beta + 1))
工具书类
- sympy.stats.BetaNoncentral(name, alpha, beta, lamda)[源代码]#
创建一个具有I型非中心β分布的连续随机变量。
非中心β分布的密度由
\[f（x）：=\sum{k=0}^\infty e^-\lambda/2}\frac{（\lambda/2）^k}{k！}\]具有 \(x \in [0,1]\) .
- 参数:
阿尔法 ：实数， \(\alpha > 0\) ，一个形状
beta ：实数， \(\beta > 0\) ，一个形状
lamda : Real number, \(\lambda \geq 0\), noncentrality parameter
- 返回:
RandomSymbol
实例
>>> from sympy.stats import BetaNoncentral, density, cdf >>> from sympy import Symbol, pprint
>>> alpha = Symbol("alpha", positive=True) >>> beta = Symbol("beta", positive=True) >>> lamda = Symbol("lamda", nonnegative=True) >>> z = Symbol("z")
>>> X = BetaNoncentral("x", alpha, beta, lamda)
>>> D = density(X)(z) >>> pprint(D, use_unicode=False) oo _____ \ ` \ -lamda \ k ------- \ k + alpha - 1 /lamda\ beta - 1 2 ) z *|-----| *(1 - z) *e / \ 2 / / ------------------------------------------------ / B(k + alpha, beta)*k! /____, k = 0
Compute cdf with specific 'x', 'alpha', 'beta' and 'lamda' values as follows:
>>> cdf(BetaNoncentral("x", 1, 1, 1), evaluate=False)(2).doit() 2*exp(1/2)
参数evaluate=False防止在传递参数2之前尝试计算常规x的和。
工具书类
- sympy.stats.BetaPrime(name, alpha, beta)[源代码]#
创建一个连续的随机变量与贝塔质数分布。
贝塔素分布的密度由
\[f（x）：=\frac{x^{\alpha-1}（1+x）^{-\alpha-\beta}}}{B（\alpha，beta）}\]具有 \(x > 0\) .
- 参数:
阿尔法 ：实数， \(\alpha > 0\) ，一个形状
beta ：实数， \(\beta > 0\) ，一个形状
- 返回:
RandomSymbol
实例
>>> from sympy.stats import BetaPrime, density >>> from sympy import Symbol, pprint
>>> alpha = Symbol("alpha", positive=True) >>> beta = Symbol("beta", positive=True) >>> z = Symbol("z")
>>> X = BetaPrime("x", alpha, beta)
>>> D = density(X)(z) >>> pprint(D, use_unicode=False) alpha - 1 -alpha - beta z *(z + 1) ------------------------------- B(alpha, beta)
工具书类
- sympy.stats.BoundedPareto(name, alpha, left, right)[源代码]#
创建一个具有有界帕累托分布的连续随机变量。
有界Pareto分布的密度由
\[f（x）：=\frac{\alpha L^{\alpha}x^{-\alpha-1}{1-（\frac{L}{H}）^{\alpha}}\]- 参数:
alpha : Real Number, \(\alpha > 0\)
形状参数
left ：实数， \(left > 0\)
位置参数
正确的 ：实数， \(right > left\)
位置参数
- 返回:
RandomSymbol
实例
>>> from sympy.stats import BoundedPareto, density, cdf, E >>> from sympy import symbols >>> L, H = symbols('L, H', positive=True) >>> X = BoundedPareto('X', 2, L, H) >>> x = symbols('x') >>> density(X)(x) 2*L**2/(x**3*(1 - L**2/H**2)) >>> cdf(X)(x) Piecewise((-H**2*L**2/(x**2*(H**2 - L**2)) + H**2/(H**2 - L**2), L <= x), (0, True)) >>> E(X).simplify() 2*H*L/(H + L)
工具书类
[R929]https://en.wikipedia.org/wiki/Pareto_distribution有界帕累托分布
- sympy.stats.Cauchy(name, x0, gamma)[源代码]#
创建具有柯西分布的连续随机变量。
柯西分布的密度由
\[f(x) := \frac{1}{\pi \gamma [1 + {(\frac{x-x_0}{\gamma})}^2]}\]- 参数:
x0 ：实数，位置
伽马 ：实数， \(\gamma > 0\) ，一个天平
- 返回:
RandomSymbol
实例
>>> from sympy.stats import Cauchy, density >>> from sympy import Symbol
>>> x0 = Symbol("x0") >>> gamma = Symbol("gamma", positive=True) >>> z = Symbol("z")
>>> X = Cauchy("x", x0, gamma)
>>> density(X)(z) 1/(pi*gamma*(1 + (-x0 + z)**2/gamma**2))
工具书类
- sympy.stats.Chi(name, k)[源代码]#
创建一个具有Chi分布的连续随机变量。
Chi分布的密度由下式给出
\[f（x）：=\frac{2^{1-k/2}x^{k-1}e^{-x^2/2}{\Gamma（k/2）}\]具有 \(x \geq 0\) .
- 参数:
k ：正整数，自由度
- 返回:
RandomSymbol
实例
>>> from sympy.stats import Chi, density, E >>> from sympy import Symbol, simplify
>>> k = Symbol("k", integer=True) >>> z = Symbol("z")
>>> X = Chi("x", k)
>>> density(X)(z) 2**(1 - k/2)*z**(k - 1)*exp(-z**2/2)/gamma(k/2)
>>> simplify(E(X)) sqrt(2)*gamma(k/2 + 1/2)/gamma(k/2)
工具书类
- sympy.stats.ChiNoncentral(name, k, l)[源代码]#
创建一个非中心Chi分布的连续随机变量。
- 参数:
k : A positive Integer, \(k > 0\)
The number of degrees of freedom.
lambda : Real number, \(\lambda > 0\)
Shift parameter.
- 返回:
RandomSymbol
解释
非中心Chi分布的密度由下式给出
\[f（x）：=\frac{e^{-（x^2+\lambda^2）/2}x^k\lambda}\]具有 \(x \geq 0\) . 在这里， \(I_\nu (x)\) 是 modified Bessel function of the first kind .
实例
>>> from sympy.stats import ChiNoncentral, density >>> from sympy import Symbol
>>> k = Symbol("k", integer=True) >>> l = Symbol("l") >>> z = Symbol("z")
>>> X = ChiNoncentral("x", k, l)
>>> density(X)(z) l*z**k*exp(-l**2/2 - z**2/2)*besseli(k/2 - 1, l*z)/(l*z)**(k/2)
工具书类
- sympy.stats.ChiSquared(name, k)[源代码]#
创建一个具有卡平方分布的连续随机变量。
- 参数:
k ：正整数
The number of degrees of freedom.
- 返回:
RandomSymbol
解释
卡方分布的密度由
\[f（x）：=\frac{1}{2^{\frac{k}{2}}\Gamma\左（\frac{k}{2}\右）}\]具有 \(x \geq 0\) .
实例
>>> from sympy.stats import ChiSquared, density, E, variance, moment >>> from sympy import Symbol
>>> k = Symbol("k", integer=True, positive=True) >>> z = Symbol("z")
>>> X = ChiSquared("x", k)
>>> density(X)(z) z**(k/2 - 1)*exp(-z/2)/(2**(k/2)*gamma(k/2))
>>> E(X) k
>>> variance(X) 2*k
>>> moment(X, 3) k**3 + 6*k**2 + 8*k
工具书类
- sympy.stats.Dagum(name, p, a, b)[源代码]#
创建具有Dagum分布的连续随机变量。
- 参数:
p : Real number
\(p > 0\), a shape.
a ：实数
\(a > 0\), a shape.
b : Real number
\(b > 0\), a scale.
- 返回:
RandomSymbol
解释
达根分布的密度由
\[f（x）：=\frac{app}{x}\左（\frac{\left（\tfrac{x}{b}\right）^{apap}}\]具有 \(x > 0\) .
实例
>>> from sympy.stats import Dagum, density, cdf >>> from sympy import Symbol
>>> p = Symbol("p", positive=True) >>> a = Symbol("a", positive=True) >>> b = Symbol("b", positive=True) >>> z = Symbol("z")
>>> X = Dagum("x", p, a, b)
>>> density(X)(z) a*p*(z/b)**(a*p)*((z/b)**a + 1)**(-p - 1)/z
>>> cdf(X)(z) Piecewise(((1 + (z/b)**(-a))**(-p), z >= 0), (0, True))
工具书类
- sympy.stats.Davis(name, b, n, mu)[源代码]#
Create a continuous random variable with Davis distribution.
- 参数:
b : Real number
\(p > 0\), a scale.
n : Real number
\(n > 1\), a shape.
mu ：实数
\(mu > 0\), a location.
- 返回:
RandomSymbol
解释
The density of Davis distribution is given by
\[f(x; \mu; b, n) := \frac{b^{n}(x - \mu)^{1-n}}{ \left( e^{\frac{b}{x-\mu}} - 1 \right) \Gamma(n)\zeta(n)}\]具有 \(x \in [0,\infty]\) .
Davis distribution is a generalization of the Planck's law of radiation from statistical physics. It is used for modeling income distribution.
实例
>>> from sympy.stats import Davis, density >>> from sympy import Symbol >>> b = Symbol("b", positive=True) >>> n = Symbol("n", positive=True) >>> mu = Symbol("mu", positive=True) >>> z = Symbol("z") >>> X = Davis("x", b, n, mu) >>> density(X)(z) b**n*(-mu + z)**(-n - 1)/((exp(b/(-mu + z)) - 1)*gamma(n)*zeta(n))
工具书类
- sympy.stats.Erlang(name, k, l)[源代码]#
创建一个具有Erlang分布的连续随机变量。
- 参数:
k ：正整数
l ：实数， \(\lambda > 0\) ，费率
- 返回:
RandomSymbol
解释
Erlang分布的密度由
\[f（x）：=\frac{\lambda^k x^{k-1}e^-\lambda x}}{（k-1）！}\]具有 \(x \in [0,\infty]\) .
实例
>>> from sympy.stats import Erlang, density, cdf, E, variance >>> from sympy import Symbol, simplify, pprint
>>> k = Symbol("k", integer=True, positive=True) >>> l = Symbol("l", positive=True) >>> z = Symbol("z")
>>> X = Erlang("x", k, l)
>>> D = density(X)(z) >>> pprint(D, use_unicode=False) k k - 1 -l*z l *z *e --------------- Gamma(k)
>>> C = cdf(X)(z) >>> pprint(C, use_unicode=False) /lowergamma(k, l*z) |------------------ for z > 0 < Gamma(k) | \ 0 otherwise
>>> E(X) k/l
>>> simplify(variance(X)) k/l**2
工具书类
- sympy.stats.ExGaussian(name, mean, std, rate)[源代码]#
创建一个具有指数修正高斯（EMG）分布的连续随机变量。
- 参数:
name : A string giving a name for this distribution
mean : A Real number, the mean of Gaussian component
std : A positive Real number,
- 数学:
\(\sigma^2 > 0\) 高斯分量的方差
rate : A positive Real number,
- 数学:
\(\lambda > 0\) 指数分量比率
- 返回:
RandomSymbol
解释
指数修正高斯分布的密度由
\[f（x）：=\frac{\lambda}{2}e^{\frac{\lambda}{2}（2\mu+\lambda\sigma^2-2x）}\]with \(x > 0\). Note that the expected value is \(1/\lambda\).
实例
>>> from sympy.stats import ExGaussian, density, cdf, E >>> from sympy.stats import variance, skewness >>> from sympy import Symbol, pprint, simplify
>>> mean = Symbol("mu") >>> std = Symbol("sigma", positive=True) >>> rate = Symbol("lamda", positive=True) >>> z = Symbol("z") >>> X = ExGaussian("x", mean, std, rate)
>>> pprint(density(X)(z), use_unicode=False) / 2 \ lamda*\lamda*sigma + 2*mu - 2*z/ --------------------------------- / ___ / 2 \\ 2 |\/ 2 *\lamda*sigma + mu - z/| lamda*e *erfc|-----------------------------| \ 2*sigma / ---------------------------------------------------------------------------- 2
>>> cdf(X)(z) -(erf(sqrt(2)*(-lamda**2*sigma**2 + lamda*(-mu + z))/(2*lamda*sigma))/2 + 1/2)*exp(lamda**2*sigma**2/2 - lamda*(-mu + z)) + erf(sqrt(2)*(-mu + z)/(2*sigma))/2 + 1/2
>>> E(X) (lamda*mu + 1)/lamda
>>> simplify(variance(X)) sigma**2 + lamda**(-2)
>>> simplify(skewness(X)) 2/(lamda**2*sigma**2 + 1)**(3/2)
工具书类
- sympy.stats.Exponential(name, rate)[源代码]#
创建一个具有指数分布的连续随机变量。
- 参数:
rate ：一个正实数， \(\lambda > 0\) ，速率（或逆标度/逆平均值）
- 返回:
RandomSymbol
解释
指数分布的密度由
\[f（x）：=\lambda\exp（-\lambda x）\]with \(x > 0\). Note that the expected value is \(1/\lambda\).
实例
>>> from sympy.stats import Exponential, density, cdf, E >>> from sympy.stats import variance, std, skewness, quantile >>> from sympy import Symbol
>>> l = Symbol("lambda", positive=True) >>> z = Symbol("z") >>> p = Symbol("p") >>> X = Exponential("x", l)
>>> density(X)(z) lambda*exp(-lambda*z)
>>> cdf(X)(z) Piecewise((1 - exp(-lambda*z), z >= 0), (0, True))
>>> quantile(X)(p) -log(1 - p)/lambda
>>> E(X) 1/lambda
>>> variance(X) lambda**(-2)
>>> skewness(X) 2
>>> X = Exponential('x', 10)
>>> density(X)(z) 10*exp(-10*z)
>>> E(X) 1/10
>>> std(X) 1/10
工具书类
- sympy.stats.FDistribution(name, d1, d2)[源代码]#
创建一个具有F分布的连续随机变量。
- 参数:
d1 : \(d_1 > 0\), where \(d_1\) is the degrees of freedom (\(n_1 - 1\))
d2 : \(d_2 > 0\), where \(d_2\) is the degrees of freedom (\(n_2 - 1\))
- 返回:
RandomSymbol
解释
F分布的密度由
\[f（x）：=\frac{\sqrt{\frac{（d_1x）^{d_1}d_2^{d_2}\]具有 \(x > 0\) .
实例
>>> from sympy.stats import FDistribution, density >>> from sympy import Symbol, pprint
>>> d1 = Symbol("d1", positive=True) >>> d2 = Symbol("d2", positive=True) >>> z = Symbol("z")
>>> X = FDistribution("x", d1, d2)
>>> D = density(X)(z) >>> pprint(D, use_unicode=False) d2 -- ______________________________ 2 / d1 -d1 - d2 d2 *\/ (d1*z) *(d1*z + d2) -------------------------------------- /d1 d2\ z*B|--, --| \2 2 /
工具书类
- sympy.stats.FisherZ(name, d1, d2)[源代码]#
创建一个具有Fisher Z分布的连续随机变量。
- 参数:
d1 : \(d_1 > 0\)
Degree of freedom.
d2 : \(d_2 > 0\)
Degree of freedom.
- 返回:
RandomSymbol
解释
Fisher Z分布的密度由下式给出
\[f（x）：=\frac{2d_1^{d_1/2}d_2^{d_2/2}{\mathrm{B}（d_1/2，d_2/2）}\]实例
>>> from sympy.stats import FisherZ, density >>> from sympy import Symbol, pprint
>>> d1 = Symbol("d1", positive=True) >>> d2 = Symbol("d2", positive=True) >>> z = Symbol("z")
>>> X = FisherZ("x", d1, d2)
>>> D = density(X)(z) >>> pprint(D, use_unicode=False) d1 d2 d1 d2 - -- - -- -- -- 2 2 2 2 / 2*z \ d1*z 2*d1 *d2 *\d1*e + d2/ *e ----------------------------------------- /d1 d2\ B|--, --| \2 2 /
工具书类
- sympy.stats.Frechet(name, a, s=1, m=0)[源代码]#
创建一个具有Frechet分布的连续随机变量。
- 参数:
a : Real number, \(a \in \left(0, \infty\right)\) 形状
s : Real number, \(s \in \left(0, \infty\right)\) 比例
m : Real number, \(m \in \left(-\infty, \infty\right)\) 最小值
- 返回:
RandomSymbol
解释
Frechet分布的密度由
\[f（x）：=\frac{\alpha}{s}\左（\frac{x-m}{s}\right）^{-1-\alpha}\]具有 \(x \geq m\) .
实例
>>> from sympy.stats import Frechet, density, cdf >>> from sympy import Symbol
>>> a = Symbol("a", positive=True) >>> s = Symbol("s", positive=True) >>> m = Symbol("m", real=True) >>> z = Symbol("z")
>>> X = Frechet("x", a, s, m)
>>> density(X)(z) a*((-m + z)/s)**(-a - 1)*exp(-1/((-m + z)/s)**a)/s
>>> cdf(X)(z) Piecewise((exp(-1/((-m + z)/s)**a), m <= z), (0, True))
工具书类
- sympy.stats.Gamma(name, k, theta)[源代码]#
创建一个具有伽马分布的连续随机变量。
- 参数:
k ：实数， \(k > 0\) ，一个形状
θ ：实数， \(\theta > 0\) ，一个天平
- 返回:
RandomSymbol
解释
伽马分布密度由下式给出
\[f（x）：=\frac{1}{\Gamma（k）\theta^k}x^{k-1}e^-\frac{x}{\theta}}\]具有 \(x \in [0,1]\) .
实例
>>> from sympy.stats import Gamma, density, cdf, E, variance >>> from sympy import Symbol, pprint, simplify
>>> k = Symbol("k", positive=True) >>> theta = Symbol("theta", positive=True) >>> z = Symbol("z")
>>> X = Gamma("x", k, theta)
>>> D = density(X)(z) >>> pprint(D, use_unicode=False) -z ----- -k k - 1 theta theta *z *e --------------------- Gamma(k)
>>> C = cdf(X, meijerg=True)(z) >>> pprint(C, use_unicode=False) / / z \ |k*lowergamma|k, -----| | \ theta/ <---------------------- for z >= 0 | Gamma(k + 1) | \ 0 otherwise
>>> E(X) k*theta
>>> V = simplify(variance(X)) >>> pprint(V, use_unicode=False) 2 k*theta
工具书类
- sympy.stats.GammaInverse(name, a, b)[源代码]#
创建具有反γ分布的连续随机变量。
- 参数:
a ：实数， \(a > 0\) ，一个形状
b ：实数， \(b > 0\) ，一个天平
- 返回:
RandomSymbol
解释
反γ分布的密度由下式给出
\[f（x）：=\frac{\beta^\alpha}{\Gamma（\alpha）}x^-\alpha-1}\]具有 \(x > 0\) .
实例
>>> from sympy.stats import GammaInverse, density, cdf >>> from sympy import Symbol, pprint
>>> a = Symbol("a", positive=True) >>> b = Symbol("b", positive=True) >>> z = Symbol("z")
>>> X = GammaInverse("x", a, b)
>>> D = density(X)(z) >>> pprint(D, use_unicode=False) -b --- a -a - 1 z b *z *e --------------- Gamma(a)
>>> cdf(X)(z) Piecewise((uppergamma(a, b/z)/gamma(a), z > 0), (0, True))
工具书类
- sympy.stats.Gompertz(name, b, eta)[源代码]#
创建一个具有Gompertz分布的连续随机变量。
- 参数:
b ：实数， \(b > 0\) ，一个天平
eta : Real number, \(\eta > 0\), a shape
- 返回:
RandomSymbol
解释
密度由gomz给出
\[f（x）：=b\eta e^{bx}e^{\eta}\exp\左（-\eta e^{bx}\右）\]with \(x \in [0, \infty)\).
实例
>>> from sympy.stats import Gompertz, density >>> from sympy import Symbol
>>> b = Symbol("b", positive=True) >>> eta = Symbol("eta", positive=True) >>> z = Symbol("z")
>>> X = Gompertz("x", b, eta)
>>> density(X)(z) b*eta*exp(eta)*exp(b*z)*exp(-eta*exp(b*z))
工具书类
- sympy.stats.Gumbel(name, beta, mu, minimum=False)[源代码]#
用Gumbel分布创建一个连续的随机变量。
- 参数:
mu : Real number, \(\mu\), a location
beta : Real number, \(\beta > 0\), a scale
minimum : Boolean, by default
False, set toTruefor enabling minimum distribution- 返回:
RandomSymbol
解释
甘贝尔分布的密度由下式给出
最大限度地
\[f（x）：=\dfrac{1}{\beta}\exp\left（-\dfrac{x-\mu}{\beta}\]具有 \(x \in [ - \infty, \infty ]\) .
最小值
\[f（x）：=\frac{e^{-e^{\frac{-\mu+x}{\beta}}+\frac{-\mu+x}{\beta}}}{\beta}}{\beta}\]具有 \(x \in [ - \infty, \infty ]\) .
实例
>>> from sympy.stats import Gumbel, density, cdf >>> from sympy import Symbol >>> x = Symbol("x") >>> mu = Symbol("mu") >>> beta = Symbol("beta", positive=True) >>> X = Gumbel("x", beta, mu) >>> density(X)(x) exp(-exp(-(-mu + x)/beta) - (-mu + x)/beta)/beta >>> cdf(X)(x) exp(-exp(-(-mu + x)/beta))
工具书类
[R956]
- sympy.stats.Kumaraswamy(name, a, b)[源代码]#
用Kumaraswamy分布创建一个连续的随机变量。
- 参数:
a ：实数， \(a > 0\) ，一个形状
b : Real number, \(b > 0\), a shape
- 返回:
RandomSymbol
解释
Kumaraswamy分布的密度由
\[f（x）：=abx^{a-1}（1-x^a）^{b-1}\]具有 \(x \in [0,1]\) .
实例
>>> from sympy.stats import Kumaraswamy, density, cdf >>> from sympy import Symbol, pprint
>>> a = Symbol("a", positive=True) >>> b = Symbol("b", positive=True) >>> z = Symbol("z")
>>> X = Kumaraswamy("x", a, b)
>>> D = density(X)(z) >>> pprint(D, use_unicode=False) b - 1 a - 1 / a\ a*b*z *\1 - z /
>>> cdf(X)(z) Piecewise((0, z < 0), (1 - (1 - z**a)**b, z <= 1), (1, True))
工具书类
- sympy.stats.Laplace(name, mu, b)[源代码]#
创建一个具有拉普拉斯分布的连续随机变量。
- 参数:
mu ：实数或列表/矩阵、位置（平均值）或
位置矢量
b ：实数或正定矩阵，表示刻度
或者协方差矩阵。
- 返回:
RandomSymbol
解释
拉普拉斯分布的密度由
\[f（x）：=\frac{1}{2b}\exp\左（-\frac{x-\mu}b\右）\]实例
>>> from sympy.stats import Laplace, density, cdf >>> from sympy import Symbol, pprint
>>> mu = Symbol("mu") >>> b = Symbol("b", positive=True) >>> z = Symbol("z")
>>> X = Laplace("x", mu, b)
>>> density(X)(z) exp(-Abs(mu - z)/b)/(2*b)
>>> cdf(X)(z) Piecewise((exp((-mu + z)/b)/2, mu > z), (1 - exp((mu - z)/b)/2, True))
>>> L = Laplace('L', [1, 2], [[1, 0], [0, 1]]) >>> pprint(density(L)(1, 2), use_unicode=False) 5 / ____\ e *besselk\0, \/ 35 / --------------------- pi
工具书类
- sympy.stats.Levy(name, mu, c)[源代码]#
用Levy分布创建一个连续的随机变量。
Levy分布的密度由下式给出
\[f（x）：=\sqrt（\frac{c}{2\pi}）\frac{\exp-\frac{c}{2（x-\mu）}{（x-\mu）^{3/2}}\]- 参数:
mu ：实数
The location parameter.
c : Real number, \(c > 0\)
A scale parameter.
- 返回:
RandomSymbol
实例
>>> from sympy.stats import Levy, density, cdf >>> from sympy import Symbol
>>> mu = Symbol("mu", real=True) >>> c = Symbol("c", positive=True) >>> z = Symbol("z")
>>> X = Levy("x", mu, c)
>>> density(X)(z) sqrt(2)*sqrt(c)*exp(-c/(-2*mu + 2*z))/(2*sqrt(pi)*(-mu + z)**(3/2))
>>> cdf(X)(z) erfc(sqrt(c)*sqrt(1/(-2*mu + 2*z)))
工具书类
- sympy.stats.Logistic(name, mu, s)[源代码]#
创建一个具有逻辑分布的连续随机变量。
- 参数:
mu ：实数，位置（平均值）
s : Real number, \(s > 0\), a scale
- 返回:
RandomSymbol
解释
逻辑分布的密度由
\[f（x）：=\frac{e^{-（x-\mu）/s}{s\左（1+e^{-（x-\mu）/s}\右）^2}\]实例
>>> from sympy.stats import Logistic, density, cdf >>> from sympy import Symbol
>>> mu = Symbol("mu", real=True) >>> s = Symbol("s", positive=True) >>> z = Symbol("z")
>>> X = Logistic("x", mu, s)
>>> density(X)(z) exp((mu - z)/s)/(s*(exp((mu - z)/s) + 1)**2)
>>> cdf(X)(z) 1/(exp((mu - z)/s) + 1)
工具书类
- sympy.stats.LogLogistic(name, alpha, beta)[源代码]#
Create a continuous random variable with a log-logistic distribution. The distribution is unimodal when
beta > 1.- 参数:
阿尔法 ：实数， \(\alpha > 0\) 尺度参数和分布中值
beta : Real number, \(\beta > 0\), a shape parameter
- 返回:
RandomSymbol
解释
对数逻辑分布的密度由
\[f（x）：=\frac{（\frac{\beta}{\alpha}）（\frac{x}{\alpha}）^{\beta-1}}\]实例
>>> from sympy.stats import LogLogistic, density, cdf, quantile >>> from sympy import Symbol, pprint
>>> alpha = Symbol("alpha", positive=True) >>> beta = Symbol("beta", positive=True) >>> p = Symbol("p") >>> z = Symbol("z", positive=True)
>>> X = LogLogistic("x", alpha, beta)
>>> D = density(X)(z) >>> pprint(D, use_unicode=False) beta - 1 / z \ beta*|-----| \alpha/ ------------------------ 2 / beta \ |/ z \ | alpha*||-----| + 1| \\alpha/ /
>>> cdf(X)(z) 1/(1 + (z/alpha)**(-beta))
>>> quantile(X)(p) alpha*(p/(1 - p))**(1/beta)
工具书类
- sympy.stats.LogNormal(name, mean, std)[源代码]#
创建具有对数正态分布的连续随机变量。
- 参数:
mu ：实数
The log-scale.
sigma : Real number
A shape. (\(\sigma^2 > 0\))
- 返回:
RandomSymbol
解释
对数正态分布的密度由
\[f（x）：=\frac{1}{x\sqrt{2\pi\sigma^2}}\]具有 \(x \geq 0\) .
实例
>>> from sympy.stats import LogNormal, density >>> from sympy import Symbol, pprint
>>> mu = Symbol("mu", real=True) >>> sigma = Symbol("sigma", positive=True) >>> z = Symbol("z")
>>> X = LogNormal("x", mu, sigma)
>>> D = density(X)(z) >>> pprint(D, use_unicode=False) 2 -(-mu + log(z)) ----------------- 2 ___ 2*sigma \/ 2 *e ------------------------ ____ 2*\/ pi *sigma*z
>>> X = LogNormal('x', 0, 1) # Mean 0, standard deviation 1
>>> density(X)(z) sqrt(2)*exp(-log(z)**2/2)/(2*sqrt(pi)*z)
工具书类
- sympy.stats.Lomax(name, alpha, lamda)[源代码]#
创建一个具有Lomax分布的连续随机变量。
- 参数:
alpha : Real Number, \(\alpha > 0\)
形状参数
lamda : Real Number, \(\lambda > 0\)
比例参数
- 返回:
RandomSymbol
解释
Lomax分布的密度由下式给出
\[f(x) := \frac{\alpha}{\lambda}\left[1+\frac{x}{\lambda}\right]^{-(\alpha+1)}\]实例
>>> from sympy.stats import Lomax, density, cdf, E >>> from sympy import symbols >>> a, l = symbols('a, l', positive=True) >>> X = Lomax('X', a, l) >>> x = symbols('x') >>> density(X)(x) a*(1 + x/l)**(-a - 1)/l >>> cdf(X)(x) Piecewise((1 - 1/(1 + x/l)**a, x >= 0), (0, True)) >>> a = 2 >>> X = Lomax('X', a, l) >>> E(X) l
工具书类
- sympy.stats.Maxwell(name, a)[源代码]#
创建一个具有麦克斯韦分布的连续随机变量。
- 参数:
a ：实数， \(a > 0\)
- 返回:
RandomSymbol
解释
麦克斯韦分布的密度由
\[f（x）：=\sqrt{\frac{2}{\pi}\frac{x^2 e^{-x^2/（2a^2）}{a^3}\]具有 \(x \geq 0\) .
实例
>>> from sympy.stats import Maxwell, density, E, variance >>> from sympy import Symbol, simplify
>>> a = Symbol("a", positive=True) >>> z = Symbol("z")
>>> X = Maxwell("x", a)
>>> density(X)(z) sqrt(2)*z**2*exp(-z**2/(2*a**2))/(sqrt(pi)*a**3)
>>> E(X) 2*sqrt(2)*a/sqrt(pi)
>>> simplify(variance(X)) a**2*(-8 + 3*pi)/pi
工具书类
- sympy.stats.Moyal(name, mu, sigma)[源代码]#
Create a continuous random variable with a Moyal distribution.
- 参数:
mu ：实数
位置参数
西格玛 ：实正数
比例参数
- 返回:
RandomSymbol
解释
The density of the Moyal distribution is given by
\[f（x）：=\frac{\exp-\frac{1}{2}\exp-\frac{x-\mu}{\sigma}-\frac{x-\mu}{2\sigma}}{\sqrt{2\pi}\sigma}\]具有 \(x \in \mathbb{{R}}\) .
实例
>>> from sympy.stats import Moyal, density, cdf >>> from sympy import Symbol, simplify >>> mu = Symbol("mu", real=True) >>> sigma = Symbol("sigma", positive=True, real=True) >>> z = Symbol("z") >>> X = Moyal("x", mu, sigma) >>> density(X)(z) sqrt(2)*exp(-exp((mu - z)/sigma)/2 - (-mu + z)/(2*sigma))/(2*sqrt(pi)*sigma) >>> simplify(cdf(X)(z)) 1 - erf(sqrt(2)*exp((mu - z)/(2*sigma))/2)
工具书类
- sympy.stats.Nakagami(name, mu, omega)[源代码]#
用Nakagami分布创建一个连续的随机变量。
- 参数:
mu : Real number, \(\mu \geq \frac{1}{2}\), a shape
欧米茄 ：实数， \(\omega > 0\) ，蔓延
- 返回:
RandomSymbol
解释
Nakagami分布的密度由
\[f（x）：=\frac{2\mu^\mu}{\Gamma（\mu）\omega^\mu}x^{2\mu-1}\]具有 \(x > 0\) .
实例
>>> from sympy.stats import Nakagami, density, E, variance, cdf >>> from sympy import Symbol, simplify, pprint
>>> mu = Symbol("mu", positive=True) >>> omega = Symbol("omega", positive=True) >>> z = Symbol("z")
>>> X = Nakagami("x", mu, omega)
>>> D = density(X)(z) >>> pprint(D, use_unicode=False) 2 -mu*z ------- mu -mu 2*mu - 1 omega 2*mu *omega *z *e ---------------------------------- Gamma(mu)
>>> simplify(E(X)) sqrt(mu)*sqrt(omega)*gamma(mu + 1/2)/gamma(mu + 1)
>>> V = simplify(variance(X)) >>> pprint(V, use_unicode=False) 2 omega*Gamma (mu + 1/2) omega - ----------------------- Gamma(mu)*Gamma(mu + 1)
>>> cdf(X)(z) Piecewise((lowergamma(mu, mu*z**2/omega)/gamma(mu), z > 0), (0, True))
工具书类
- sympy.stats.Normal(name, mean, std)[源代码]#
创建一个正态分布的连续随机变量。
- 参数:
mu ：实数或表示平均值或平均向量的列表
西格玛 ：实数或正定方阵，
\(\sigma^2 > 0\), the variance
- 返回:
RandomSymbol
解释
正态分布的密度由
\[f（x）：=\frac{1}{\sigma\sqrt{2\pi}}e^-\frac{（x-\mu）^2}{2\sigma^2}}}\]实例
>>> from sympy.stats import Normal, density, E, std, cdf, skewness, quantile, marginal_distribution >>> from sympy import Symbol, simplify, pprint
>>> mu = Symbol("mu") >>> sigma = Symbol("sigma", positive=True) >>> z = Symbol("z") >>> y = Symbol("y") >>> p = Symbol("p") >>> X = Normal("x", mu, sigma)
>>> density(X)(z) sqrt(2)*exp(-(-mu + z)**2/(2*sigma**2))/(2*sqrt(pi)*sigma)
>>> C = simplify(cdf(X))(z) # it needs a little more help... >>> pprint(C, use_unicode=False) / ___ \ |\/ 2 *(-mu + z)| erf|---------------| \ 2*sigma / 1 -------------------- + - 2 2
>>> quantile(X)(p) mu + sqrt(2)*sigma*erfinv(2*p - 1)
>>> simplify(skewness(X)) 0
>>> X = Normal("x", 0, 1) # Mean 0, standard deviation 1 >>> density(X)(z) sqrt(2)*exp(-z**2/2)/(2*sqrt(pi))
>>> E(2*X + 1) 1
>>> simplify(std(2*X + 1)) 2
>>> m = Normal('X', [1, 2], [[2, 1], [1, 2]]) >>> pprint(density(m)(y, z), use_unicode=False) 2 2 y y*z z - -- + --- - -- + z - 1 ___ 3 3 3 \/ 3 *e ------------------------------ 6*pi
>>> marginal_distribution(m, m[0])(1) 1/(2*sqrt(pi))
工具书类
- sympy.stats.Pareto(name, xm, alpha)[源代码]#
创建一个具有帕累托分布的连续随机变量。
- 参数:
xm ：实数， \(x_m > 0\) ，一个天平
阿尔法 ：实数， \(\alpha > 0\) ，一个形状
- 返回:
RandomSymbol
解释
帕累托分布的密度由
\[f（x）：=\frac{\alpha\，x_m^\alpha}{x^{\alpha+1}}\]具有 \(x \in [x_m,\infty]\) .
实例
>>> from sympy.stats import Pareto, density >>> from sympy import Symbol
>>> xm = Symbol("xm", positive=True) >>> beta = Symbol("beta", positive=True) >>> z = Symbol("z")
>>> X = Pareto("x", xm, beta)
>>> density(X)(z) beta*xm**beta*z**(-beta - 1)
工具书类
- sympy.stats.PowerFunction(name, alpha, a, b)[源代码]#
Creates a continuous random variable with a Power Function Distribution.
- 参数:
alpha : Positive number, \(0 < \alpha\), the shape parameter
a : Real number, \(-\infty < a\), the left boundary
b : Real number, \(a < b < \infty\), the right boundary
- 返回:
RandomSymbol
解释
幂函数分布密度由
\[f（x）：=\frac{\alpha}（x-a）^{\alpha-1}}{（b-a）^{\alpha}}}\]具有 \(x \in [a,b]\) .
实例
>>> from sympy.stats import PowerFunction, density, cdf, E, variance >>> from sympy import Symbol >>> alpha = Symbol("alpha", positive=True) >>> a = Symbol("a", real=True) >>> b = Symbol("b", real=True) >>> z = Symbol("z")
>>> X = PowerFunction("X", 2, a, b)
>>> density(X)(z) (-2*a + 2*z)/(-a + b)**2
>>> cdf(X)(z) Piecewise((a**2/(a**2 - 2*a*b + b**2) - 2*a*z/(a**2 - 2*a*b + b**2) + z**2/(a**2 - 2*a*b + b**2), a <= z), (0, True))
>>> alpha = 2 >>> a = 0 >>> b = 1 >>> Y = PowerFunction("Y", alpha, a, b)
>>> E(Y) 2/3
>>> variance(Y) 1/18
工具书类
- sympy.stats.QuadraticU(name, a, b)[源代码]#
创建一个具有U-二次分布的连续随机变量。
- 参数:
a ：实数
b : Real number, \(a < b\)
- 返回:
RandomSymbol
解释
U-二次分布的密度由
\[f（x）：=\alpha（x-\beta）^2\]具有 \(x \in [a,b]\) .
实例
>>> from sympy.stats import QuadraticU, density >>> from sympy import Symbol, pprint
>>> a = Symbol("a", real=True) >>> b = Symbol("b", real=True) >>> z = Symbol("z")
>>> X = QuadraticU("x", a, b)
>>> D = density(X)(z) >>> pprint(D, use_unicode=False) / 2 | / a b \ |12*|- - - - + z| | \ 2 2 / <----------------- for And(b >= z, a <= z) | 3 | (-a + b) | \ 0 otherwise
工具书类
- sympy.stats.RaisedCosine(name, mu, s)[源代码]#
创建具有提升余弦分布的连续随机变量。
- 参数:
mu ：实数
s ：实数， \(s > 0\)
- 返回:
RandomSymbol
解释
升余弦分布的密度由下式给出
\[f（x）：=\frac{1}{2s}\左（1+\cos\left（\frac{x-\mu}{s}\pi\右）\right）\]具有 \(x \in [\mu-s,\mu+s]\) .
实例
>>> from sympy.stats import RaisedCosine, density >>> from sympy import Symbol, pprint
>>> mu = Symbol("mu", real=True) >>> s = Symbol("s", positive=True) >>> z = Symbol("z")
>>> X = RaisedCosine("x", mu, s)
>>> D = density(X)(z) >>> pprint(D, use_unicode=False) / /pi*(-mu + z)\ |cos|------------| + 1 | \ s / <--------------------- for And(z >= mu - s, z <= mu + s) | 2*s | \ 0 otherwise
工具书类
- sympy.stats.Rayleigh(name, sigma)[源代码]#
创建一个具有瑞利分布的连续随机变量。
- 参数:
西格玛 ：实数， \(\sigma > 0\)
- 返回:
RandomSymbol
解释
瑞利分布的密度由
\[f（x）：=\frac{x}{\sigma^2}e^{-x^2/2\sigma^2}\]具有 \(x > 0\) .
实例
>>> from sympy.stats import Rayleigh, density, E, variance >>> from sympy import Symbol
>>> sigma = Symbol("sigma", positive=True) >>> z = Symbol("z")
>>> X = Rayleigh("x", sigma)
>>> density(X)(z) z*exp(-z**2/(2*sigma**2))/sigma**2
>>> E(X) sqrt(2)*sqrt(pi)*sigma/2
>>> variance(X) -pi*sigma**2/2 + 2*sigma**2
工具书类
- sympy.stats.Reciprocal(name, a, b)[源代码]#
连续分布产生一个随机变量的倒数。
- 参数:
a : Real number, \(0 < a\)
b : Real number, \(a < b\)
- 返回:
RandomSymbol
实例
>>> from sympy.stats import Reciprocal, density, cdf >>> from sympy import symbols >>> a, b, x = symbols('a, b, x', positive=True) >>> R = Reciprocal('R', a, b)
>>> density(R)(x) 1/(x*(-log(a) + log(b))) >>> cdf(R)(x) Piecewise((log(a)/(log(a) - log(b)) - log(x)/(log(a) - log(b)), a <= x), (0, True))
参考文献
- sympy.stats.StudentT(name, nu)[源代码]#
用学生t分布创建一个连续的随机变量。
- 参数:
nu ：实数， \(\nu > 0\) ，自由度
- 返回:
RandomSymbol
解释
学生t分布的密度由
\[f（x）：=\frac{\Gamma\left（\frac{\nu+1}{2}\right）}\]实例
>>> from sympy.stats import StudentT, density, cdf >>> from sympy import Symbol, pprint
>>> nu = Symbol("nu", positive=True) >>> z = Symbol("z")
>>> X = StudentT("x", nu)
>>> D = density(X)(z) >>> pprint(D, use_unicode=False) nu 1 - -- - - 2 2 / 2\ | z | |1 + --| \ nu/ ----------------- ____ / nu\ \/ nu *B|1/2, --| \ 2 /
>>> cdf(X)(z) 1/2 + z*gamma(nu/2 + 1/2)*hyper((1/2, nu/2 + 1/2), (3/2,), -z**2/nu)/(sqrt(pi)*sqrt(nu)*gamma(nu/2))
工具书类
- sympy.stats.ShiftedGompertz(name, b, eta)[源代码]#
创建一个具有移位Gompertz分布的连续随机变量。
- 参数:
b ：实数， \(b > 0\) ，一个天平
eta : Real number, \(\eta > 0\), a shape
- 返回:
RandomSymbol
解释
位移Gompertz分布的密度由
\[f(x) := b e^{-b x} e^{-\eta \exp(-b x)} \left[1 + \eta(1 - e^(-bx)) \right]\]with \(x \in [0, \infty)\).
实例
>>> from sympy.stats import ShiftedGompertz, density >>> from sympy import Symbol
>>> b = Symbol("b", positive=True) >>> eta = Symbol("eta", positive=True) >>> x = Symbol("x")
>>> X = ShiftedGompertz("x", b, eta)
>>> density(X)(x) b*(eta*(1 - exp(-b*x)) + 1)*exp(-b*x)*exp(-eta*exp(-b*x))
工具书类
- sympy.stats.Trapezoidal(name, a, b, c, d)[源代码]#
创建一个梯形分布的连续随机变量。
- 参数:
a : Real number, \(a < d\)
b : Real number, \(a \le b < c\)
c : Real number, \(b < c \le d\)
d ：实数
- 返回:
RandomSymbol
解释
梯形分布的密度由
\[f（x）：=\begin{cases}\]实例
>>> from sympy.stats import Trapezoidal, density >>> from sympy import Symbol, pprint
>>> a = Symbol("a") >>> b = Symbol("b") >>> c = Symbol("c") >>> d = Symbol("d") >>> z = Symbol("z")
>>> X = Trapezoidal("x", a,b,c,d)
>>> pprint(density(X)(z), use_unicode=False) / -2*a + 2*z |------------------------- for And(a <= z, b > z) |(-a + b)*(-a - b + c + d) | | 2 | -------------- for And(b <= z, c > z) < -a - b + c + d | | 2*d - 2*z |------------------------- for And(d >= z, c <= z) |(-c + d)*(-a - b + c + d) | \ 0 otherwise
工具书类
- sympy.stats.Triangular(name, a, b, c)[源代码]#
创建一个三角形分布的连续随机变量。
- 参数:
a : Real number, \(a \in \left(-\infty, \infty\right)\)
b : Real number, \(a < b\)
c : Real number, \(a \leq c \leq b\)
- 返回:
RandomSymbol
解释
三角形分布的密度由
\[f（x）：=\begin{cases}\]实例
>>> from sympy.stats import Triangular, density >>> from sympy import Symbol, pprint
>>> a = Symbol("a") >>> b = Symbol("b") >>> c = Symbol("c") >>> z = Symbol("z")
>>> X = Triangular("x", a,b,c)
>>> pprint(density(X)(z), use_unicode=False) / -2*a + 2*z |----------------- for And(a <= z, c > z) |(-a + b)*(-a + c) | | 2 | ------ for c = z < -a + b | | 2*b - 2*z |---------------- for And(b >= z, c < z) |(-a + b)*(b - c) | \ 0 otherwise
工具书类
- sympy.stats.Uniform(name, left, right)[源代码]#
创建一个均匀分布的连续随机变量。
- 参数:
a : Real number, \(-\infty < a\), the left boundary
b : Real number, \(a < b < \infty\), the right boundary
- 返回:
RandomSymbol
解释
均匀分布的密度由
\[\begin{split}f（x）：=\begin{cases} [a,b] \\\end{split}\]具有 \(x \in [a,b]\) .
实例
>>> from sympy.stats import Uniform, density, cdf, E, variance >>> from sympy import Symbol, simplify
>>> a = Symbol("a", negative=True) >>> b = Symbol("b", positive=True) >>> z = Symbol("z")
>>> X = Uniform("x", a, b)
>>> density(X)(z) Piecewise((1/(-a + b), (b >= z) & (a <= z)), (0, True))
>>> cdf(X)(z) Piecewise((0, a > z), ((-a + z)/(-a + b), b >= z), (1, True))
>>> E(X) a/2 + b/2
>>> simplify(variance(X)) a**2/12 - a*b/6 + b**2/12
工具书类
- sympy.stats.UniformSum(name, n)[源代码]#
创建一个具有欧文霍尔分布的连续随机变量。
- 参数:
n : A positive integer, \(n > 0\)
- 返回:
RandomSymbol
解释
The probability distribution function depends on a single parameter \(n\) which is an integer.
欧文霍尔分布的密度由
\[f（x）：=\frac{1}{（n-1）！}\和{k=0}^{\left\lfloor x\ right\rfloor}（-1）^k\]实例
>>> from sympy.stats import UniformSum, density, cdf >>> from sympy import Symbol, pprint
>>> n = Symbol("n", integer=True) >>> z = Symbol("z")
>>> X = UniformSum("x", n)
>>> D = density(X)(z) >>> pprint(D, use_unicode=False) floor(z) ___ \ ` \ k n - 1 /n\ ) (-1) *(-k + z) *| | / \k/ /__, k = 0 -------------------------------- (n - 1)!
>>> cdf(X)(z) Piecewise((0, z < 0), (Sum((-1)**_k*(-_k + z)**n*binomial(n, _k), (_k, 0, floor(z)))/factorial(n), n >= z), (1, True))
使用特定的“x”和“n”值计算cdf，如下所示：>>>cdf（UniformSum（“x”，5），evaluate=False）（2）.doit（）9/40
参数evaluate=False防止在传递参数2之前尝试计算常规n的和。
工具书类
- sympy.stats.VonMises(name, mu, k)[源代码]#
创建一个具有von Mises分布的连续随机变量。
- 参数:
mu ：实数
Measure of location.
k : Real number
Measure of concentration.
- 返回:
RandomSymbol
解释
von Mises分布的密度由
\[f（x）：=\frac{e^{\kappa\cos（x-\mu）}{2\pi I_0（\kappa）}\]具有 \(x \in [0,2\pi]\) .
实例
>>> from sympy.stats import VonMises, density >>> from sympy import Symbol, pprint
>>> mu = Symbol("mu") >>> k = Symbol("k", positive=True) >>> z = Symbol("z")
>>> X = VonMises("x", mu, k)
>>> D = density(X)(z) >>> pprint(D, use_unicode=False) k*cos(mu - z) e ------------------ 2*pi*besseli(0, k)
工具书类
- sympy.stats.Wald(name, mean, shape)[源代码]#
创建一个具有逆高斯分布的连续随机变量。逆高斯分布也称为Wald分布。
- 参数:
mu :
Positive number representing the mean.
lambda :
Positive number representing the shape parameter.
- 返回:
RandomSymbol
解释
逆高斯分布的密度由
\[f（x）：=\sqrt{\frac{\lambda}{2\pix^3}}e^-\frac{\lambda（x-\mu）^2}{2x\mu^2}\]实例
>>> from sympy.stats import GaussianInverse, density, E, std, skewness >>> from sympy import Symbol, pprint
>>> mu = Symbol("mu", positive=True) >>> lamda = Symbol("lambda", positive=True) >>> z = Symbol("z", positive=True) >>> X = GaussianInverse("x", mu, lamda)
>>> D = density(X)(z) >>> pprint(D, use_unicode=False) 2 -lambda*(-mu + z) ------------------- 2 ___ ________ 2*mu *z \/ 2 *\/ lambda *e ------------------------------------- ____ 3/2 2*\/ pi *z
>>> E(X) mu
>>> std(X).expand() mu**(3/2)/sqrt(lambda)
>>> skewness(X).expand() 3*sqrt(mu)/sqrt(lambda)
工具书类
- sympy.stats.Weibull(name, alpha, beta)[源代码]#
创建一个具有威布尔分布的连续随机变量。
- 参数:
lambda : Real number, \(\lambda > 0\), a scale
k : Real number, \(k > 0\), a shape
- 返回:
RandomSymbol
解释
威布尔分布的密度由
\[f（x）：=\begin{cases}\]实例
>>> from sympy.stats import Weibull, density, E, variance >>> from sympy import Symbol, simplify
>>> l = Symbol("lambda", positive=True) >>> k = Symbol("k", positive=True) >>> z = Symbol("z")
>>> X = Weibull("x", l, k)
>>> density(X)(z) k*(z/lambda)**(k - 1)*exp(-(z/lambda)**k)/lambda
>>> simplify(E(X)) lambda*gamma(1 + 1/k)
>>> simplify(variance(X)) lambda**2*(-gamma(1 + 1/k)**2 + gamma(1 + 2/k))
工具书类
- sympy.stats.WignerSemicircle(name, R)[源代码]#
创建一个具有Wigner半圆分布的连续随机变量。
- 参数:
R ：实数， \(R > 0\) ，半径
- 返回:
A RandomSymbol.
解释
维格纳半圆分布的密度由
\[f（x）：=\frac2{\pi R^2}\，\sqrt{R^2-x^2}\]具有 \(x \in [-R,R]\) .
实例
>>> from sympy.stats import WignerSemicircle, density, E >>> from sympy import Symbol
>>> R = Symbol("R", positive=True) >>> z = Symbol("z")
>>> X = WignerSemicircle("x", R)
>>> density(X)(z) 2*sqrt(R**2 - z**2)/(pi*R**2)
>>> E(X) 0
工具书类
- sympy.stats.ContinuousRV(symbol, density, set=Interval(-oo, oo), **kwargs)[源代码]#
根据以下条件创建一个连续随机变量：
- 参数:
符号 ：符号
表示随机变量的名称。
密度 ：包含符号的表达式
表示概率密度函数。
set ：设置/间隔
表示pdf有效的区域，默认为实线。
检查 布尔
如果为真，它将检查给定的密度是否在给定集上积分为1。如果为False，则不执行此检查。默认值为False。
- 返回:
RandomSymbol
已经实现了许多常见的连续随机变量类型。
这种功能应该是非常必要的。
实例
>>> from sympy import Symbol, sqrt, exp, pi >>> from sympy.stats import ContinuousRV, P, E
>>> x = Symbol("x")
>>> pdf = sqrt(2)*exp(-x**2/2)/(2*sqrt(pi)) # Normal distribution >>> X = ContinuousRV(x, pdf)
>>> E(X) 0 >>> P(X>0) 1/2
接头类型#
- sympy.stats.JointRV(symbol, pdf, _set=None)[源代码]#
Create a Joint Random Variable where each of its component is continuous, given the following:
- 参数:
符号 ：符号
表示随机变量的名称。
pdf : A PDF in terms of indexed symbols of the symbol given
as the first argument
- 返回:
RandomSymbol
注意
As of now, the set for each component for a
JointRVis equal to the set of all integers, which cannot be changed.实例
>>> from sympy import exp, pi, Indexed, S >>> from sympy.stats import density, JointRV >>> x1, x2 = (Indexed('x', i) for i in (1, 2)) >>> pdf = exp(-x1**2/2 + x1 - x2**2/2 - S(1)/2)/(2*pi) >>> N1 = JointRV('x', pdf) #Multivariate Normal distribution >>> density(N1)(1, 2) exp(-2)/(2*pi)
- sympy.stats.marginal_distribution(rv, *indices)[源代码]#
联合随机变量的边际分布函数。
- 参数:
rv : A random variable with a joint probability distribution.
indices : Component indices or the indexed random symbol
for which the joint distribution is to be calculated
- 返回:
中的Lambda表达式 \(sym\) .
实例
>>> from sympy.stats import MultivariateNormal, marginal_distribution >>> m = MultivariateNormal('X', [1, 2], [[2, 1], [1, 2]]) >>> marginal_distribution(m, m[0])(1) 1/(2*sqrt(pi))
- sympy.stats.MultivariateNormal(name, mu, sigma)[源代码]#
创建具有多元正态分布的连续随机变量。
多元正态分布的密度可以在 [1] .
- 参数:
mu ：表示平均值或平均值向量的列表
sigma : Positive semidefinite square matrix
Represents covariance Matrix. If \(\sigma\) is noninvertible then only sampling is supported currently
- 返回:
RandomSymbol
实例
>>> from sympy.stats import MultivariateNormal, density, marginal_distribution >>> from sympy import symbols, MatrixSymbol >>> X = MultivariateNormal('X', [3, 4], [[2, 1], [1, 2]]) >>> y, z = symbols('y z') >>> density(X)(y, z) sqrt(3)*exp(-y**2/3 + y*z/3 + 2*y/3 - z**2/3 + 5*z/3 - 13/3)/(6*pi) >>> density(X)(1, 2) sqrt(3)*exp(-4/3)/(6*pi) >>> marginal_distribution(X, X[1])(y) exp(-(y - 4)**2/4)/(2*sqrt(pi)) >>> marginal_distribution(X, X[0])(y) exp(-(y - 3)**2/4)/(2*sqrt(pi))
The example below shows that it is also possible to use symbolic parameters to define the MultivariateNormal class.
>>> n = symbols('n', integer=True, positive=True) >>> Sg = MatrixSymbol('Sg', n, n) >>> mu = MatrixSymbol('mu', n, 1) >>> obs = MatrixSymbol('obs', n, 1) >>> X = MultivariateNormal('X', mu, Sg)
The density of a multivariate normal can be calculated using a matrix argument, as shown below.
>>> density(X)(obs) (exp(((1/2)*mu.T - (1/2)*obs.T)*Sg**(-1)*(-mu + obs))/sqrt((2*pi)**n*Determinant(Sg)))[0, 0]
工具书类
- sympy.stats.MultivariateLaplace(name, mu, sigma)[源代码]#
创建具有多元拉普拉斯分布的连续随机变量。
多元拉普拉斯分布的密度可以在 [1] .
- 参数:
mu ：表示平均值或平均值向量的列表
西格玛 ：正定方阵
表示协方差矩阵
- 返回:
RandomSymbol
实例
>>> from sympy.stats import MultivariateLaplace, density >>> from sympy import symbols >>> y, z = symbols('y z') >>> X = MultivariateLaplace('X', [2, 4], [[3, 1], [1, 3]]) >>> density(X)(y, z) sqrt(2)*exp(y/4 + 5*z/4)*besselk(0, sqrt(15*y*(3*y/8 - z/8)/2 + 15*z*(-y/8 + 3*z/8)/2))/(4*pi) >>> density(X)(1, 2) sqrt(2)*exp(11/4)*besselk(0, sqrt(165)/4)/(4*pi)
工具书类
- sympy.stats.GeneralizedMultivariateLogGamma(syms, delta, v, lamda, mu)[源代码]#
创建具有广义多元对数伽马分布的联合随机变量。
联合pdf可在 [1] .
- 参数:
syms : list/tuple/set of symbols for identifying each component
delta : A constant in range \([0, 1]\)
v : Positive real number
lamda : List of positive real numbers
mu : List of positive real numbers
- 返回:
RandomSymbol
实例
>>> from sympy.stats import density >>> from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGamma >>> from sympy import symbols, S >>> v = 1 >>> l, mu = [1, 1, 1], [1, 1, 1] >>> d = S.Half >>> y = symbols('y_1:4', positive=True) >>> Gd = GeneralizedMultivariateLogGamma('G', d, v, l, mu) >>> density(Gd)(y[0], y[1], y[2]) Sum(exp((n + 1)*(y_1 + y_2 + y_3) - exp(y_1) - exp(y_2) - exp(y_3))/(2**n*gamma(n + 1)**3), (n, 0, oo))/2
注意
If the GeneralizedMultivariateLogGamma is too long to type use,
>>> from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGamma as GMVLG >>> Gd = GMVLG('G', d, v, l, mu)
If you want to pass the matrix omega instead of the constant delta, then use
GeneralizedMultivariateLogGammaOmega.工具书类
- sympy.stats.GeneralizedMultivariateLogGammaOmega(syms, omega, v, lamda, mu)[源代码]#
扩展了GeneralizedMultivariateLogGamma。
- 参数:
syms : list/tuple/set of symbols
用于识别每个组件
omega : A square matrix
方阵的每个元素都必须是相关系数平方根的绝对值
v : Positive real number
lamda : List of positive real numbers
mu : List of positive real numbers
- 返回:
RandomSymbol
实例
>>> from sympy.stats import density >>> from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGammaOmega >>> from sympy import Matrix, symbols, S >>> omega = Matrix([[1, S.Half, S.Half], [S.Half, 1, S.Half], [S.Half, S.Half, 1]]) >>> v = 1 >>> l, mu = [1, 1, 1], [1, 1, 1] >>> G = GeneralizedMultivariateLogGammaOmega('G', omega, v, l, mu) >>> y = symbols('y_1:4', positive=True) >>> density(G)(y[0], y[1], y[2]) sqrt(2)*Sum((1 - sqrt(2)/2)**n*exp((n + 1)*(y_1 + y_2 + y_3) - exp(y_1) - exp(y_2) - exp(y_3))/gamma(n + 1)**3, (n, 0, oo))/2
笔记
If the GeneralizedMultivariateLogGammaOmega is too long to type use,
>>> from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGammaOmega as GMVLGO >>> G = GMVLGO('G', omega, v, l, mu)
工具书类
- sympy.stats.Multinomial(syms, n, *p)[源代码]#
创建具有多项式分布的离散随机变量。
上述分布的密度可在 [1] .
- 参数:
n : Positive integer
表示试验次数
p : List of event probabilities
Must be in the range of \([0, 1]\).
- 返回:
RandomSymbol
实例
>>> from sympy.stats import density, Multinomial, marginal_distribution >>> from sympy import symbols >>> x1, x2, x3 = symbols('x1, x2, x3', nonnegative=True, integer=True) >>> p1, p2, p3 = symbols('p1, p2, p3', positive=True) >>> M = Multinomial('M', 3, p1, p2, p3) >>> density(M)(x1, x2, x3) Piecewise((6*p1**x1*p2**x2*p3**x3/(factorial(x1)*factorial(x2)*factorial(x3)), Eq(x1 + x2 + x3, 3)), (0, True)) >>> marginal_distribution(M, M[0])(x1).subs(x1, 1) 3*p1*p2**2 + 6*p1*p2*p3 + 3*p1*p3**2
工具书类
- sympy.stats.MultivariateBeta(syms, *alpha)[源代码]#
创建具有Dirichlet/多元Beta分布的连续随机变量。
The density of the Dirichlet distribution can be found at [1].
- 参数:
alpha : Positive real numbers
表示浓度值。
- 返回:
RandomSymbol
实例
>>> from sympy.stats import density, MultivariateBeta, marginal_distribution >>> from sympy import Symbol >>> a1 = Symbol('a1', positive=True) >>> a2 = Symbol('a2', positive=True) >>> B = MultivariateBeta('B', [a1, a2]) >>> C = MultivariateBeta('C', a1, a2) >>> x = Symbol('x') >>> y = Symbol('y') >>> density(B)(x, y) x**(a1 - 1)*y**(a2 - 1)*gamma(a1 + a2)/(gamma(a1)*gamma(a2)) >>> marginal_distribution(C, C[0])(x) x**(a1 - 1)*gamma(a1 + a2)/(a2*gamma(a1)*gamma(a2))
工具书类
- sympy.stats.MultivariateEwens(syms, n, theta)[源代码]#
创建具有多元Ewens分布的离散随机变量。
上述分布的密度可在 [1] .
- 参数:
n : Positive integer
考虑其分区的样本或整数的大小
theta : Positive real number
表示突变率
- 返回:
RandomSymbol
实例
>>> from sympy.stats import density, marginal_distribution, MultivariateEwens >>> from sympy import Symbol >>> a1 = Symbol('a1', positive=True) >>> a2 = Symbol('a2', positive=True) >>> ed = MultivariateEwens('E', 2, 1) >>> density(ed)(a1, a2) Piecewise((1/(2**a2*factorial(a1)*factorial(a2)), Eq(a1 + 2*a2, 2)), (0, True)) >>> marginal_distribution(ed, ed[0])(a1) Piecewise((1/factorial(a1), Eq(a1, 2)), (0, True))
工具书类
- sympy.stats.MultivariateT(syms, mu, sigma, v)[源代码]#
创建具有多元T分布的联合随机变量。
- 参数:
syms : A symbol/str
用于识别随机变量。
mu : A list/matrix
表示位置向量
sigma : The shape matrix for the distribution
- 返回:
RandomSymbol
实例
>>> from sympy.stats import density, MultivariateT >>> from sympy import Symbol
>>> x = Symbol("x") >>> X = MultivariateT("x", [1, 1], [[1, 0], [0, 1]], 2)
>>> density(X)(1, 2) 2/(9*pi)
- sympy.stats.NegativeMultinomial(syms, k0, *p)[源代码]#
创建具有负多项式分布的离散随机变量。
上述分布的密度可在 [1] .
- 参数:
k0 : positive integer
表示实验停止前的失败次数
p : List of event probabilities
Must be in the range of \([0, 1]\)
- 返回:
RandomSymbol
实例
>>> from sympy.stats import density, NegativeMultinomial, marginal_distribution >>> from sympy import symbols >>> x1, x2, x3 = symbols('x1, x2, x3', nonnegative=True, integer=True) >>> p1, p2, p3 = symbols('p1, p2, p3', positive=True) >>> N = NegativeMultinomial('M', 3, p1, p2, p3) >>> N_c = NegativeMultinomial('M', 3, 0.1, 0.1, 0.1) >>> density(N)(x1, x2, x3) p1**x1*p2**x2*p3**x3*(-p1 - p2 - p3 + 1)**3*gamma(x1 + x2 + x3 + 3)/(2*factorial(x1)*factorial(x2)*factorial(x3)) >>> marginal_distribution(N_c, N_c[0])(1).evalf().round(2) 0.25
工具书类
- sympy.stats.NormalGamma(sym, mu, lamda, alpha, beta)[源代码]#
创建具有多元正态伽马分布的二元联合随机变量。
- 参数:
sym : A symbol/str
用于识别随机变量。
mu : A real number
正态分布的平均值
lamda : A positive integer
联合分布参数
alpha : A positive integer
联合分布参数
beta : A positive integer
联合分布参数
- 返回:
RandomSymbol
实例
>>> from sympy.stats import density, NormalGamma >>> from sympy import symbols
>>> X = NormalGamma('x', 0, 1, 2, 3) >>> y, z = symbols('y z')
>>> density(X)(y, z) 9*sqrt(2)*z**(3/2)*exp(-3*z)*exp(-y**2*z/2)/(2*sqrt(pi))
工具书类
随机过程#
- class sympy.stats.DiscreteMarkovChain(sym, state_space=None, trans_probs=None)[源代码]#
表示有限离散时间齐次马尔可夫链。
这种Markov链可以用它的（有序）状态空间和一步转移概率矩阵唯一地刻画出来。
- 参数:
sym:
马尔可夫链的名字
state_space:
可选，默认情况下，范围（n）
trans_probs:
可选，默认情况下，矩阵符号（''u T'，n，n）
实例
>>> from sympy.stats import DiscreteMarkovChain, TransitionMatrixOf, P, E >>> from sympy import Matrix, MatrixSymbol, Eq, symbols >>> T = Matrix([[0.5, 0.2, 0.3],[0.2, 0.5, 0.3],[0.2, 0.3, 0.5]]) >>> Y = DiscreteMarkovChain("Y", [0, 1, 2], T) >>> YS = DiscreteMarkovChain("Y")
>>> Y.state_space {0, 1, 2} >>> Y.transition_probabilities Matrix([ [0.5, 0.2, 0.3], [0.2, 0.5, 0.3], [0.2, 0.3, 0.5]]) >>> TS = MatrixSymbol('T', 3, 3) >>> P(Eq(YS[3], 2), Eq(YS[1], 1) & TransitionMatrixOf(YS, TS)) T[0, 2]*T[1, 0] + T[1, 1]*T[1, 2] + T[1, 2]*T[2, 2] >>> P(Eq(Y[3], 2), Eq(Y[1], 1)).round(2) 0.36
概率将根据索引而不是状态名来计算。例如，对于具有字符串状态名称的Sunny Cloudy-le雨模型：
>>> from sympy.core.symbol import Str >>> Y = DiscreteMarkovChain("Y", [Str('Sunny'), Str('Cloudy'), Str('Rainy')], T) >>> P(Eq(Y[3], 2), Eq(Y[1], 1)).round(2) 0.36
这与
[0, 1, 2]状态空间。目前，概率和期望语句中不支持状态名。这里有一个关于使用Str：>>> P(Eq(Str('Rainy'), Y[3]), Eq(Y[1], Str('Cloudy'))).round(2) 0.36
还可以使用符号状态名称：
>>> sunny, cloudy, rainy = symbols('Sunny, Cloudy, Rainy') >>> Y = DiscreteMarkovChain("Y", [sunny, cloudy, rainy], T) >>> P(Eq(Y[3], rainy), Eq(Y[1], cloudy)).round(2) 0.36
期望值计算如下：
>>> E(Y[3], Eq(Y[1], cloudy)) 0.38*Cloudy + 0.36*Rainy + 0.26*Sunny
Probability of expressions with multiple RandomIndexedSymbols can also be calculated provided there is only 1 RandomIndexedSymbol in the given condition. It is always better to use Rational instead of floating point numbers for the probabilities in the transition matrix to avoid errors.
>>> from sympy import Gt, Le, Rational >>> T = Matrix([[Rational(5, 10), Rational(3, 10), Rational(2, 10)], [Rational(2, 10), Rational(7, 10), Rational(1, 10)], [Rational(3, 10), Rational(3, 10), Rational(4, 10)]]) >>> Y = DiscreteMarkovChain("Y", [0, 1, 2], T) >>> P(Eq(Y[3], Y[1]), Eq(Y[0], 0)).round(3) 0.409 >>> P(Gt(Y[3], Y[1]), Eq(Y[0], 0)).round(2) 0.36 >>> P(Le(Y[15], Y[10]), Eq(Y[8], 2)).round(7) 0.6963328
Symbolic probability queries are also supported
>>> a, b, c, d = symbols('a b c d') >>> T = Matrix([[Rational(1, 10), Rational(4, 10), Rational(5, 10)], [Rational(3, 10), Rational(4, 10), Rational(3, 10)], [Rational(7, 10), Rational(2, 10), Rational(1, 10)]]) >>> Y = DiscreteMarkovChain("Y", [0, 1, 2], T) >>> query = P(Eq(Y[a], b), Eq(Y[c], d)) >>> query.subs({a:10, b:2, c:5, d:1}).round(4) 0.3096 >>> P(Eq(Y[10], 2), Eq(Y[5], 1)).evalf().round(4) 0.3096 >>> query_gt = P(Gt(Y[a], b), Eq(Y[c], d)) >>> query_gt.subs({a:21, b:0, c:5, d:0}).evalf().round(5) 0.64705 >>> P(Gt(Y[21], 0), Eq(Y[5], 0)).round(5) 0.64705
对任意大小的州的支持有限：
>>> n = symbols('n', nonnegative=True, integer=True) >>> T = MatrixSymbol('T', n, n) >>> Y = DiscreteMarkovChain("Y", trans_probs=T) >>> Y.state_space Range(0, n, 1) >>> query = P(Eq(Y[a], b), Eq(Y[c], d)) >>> query.subs({a:10, b:2, c:5, d:1}) (T**5)[1, 2]
工具书类
[R1017]https://en.wikipedia.org/wiki/Markov_chain#离散-时间-马尔可夫链
- absorbing_probabilities()[源代码]#
Computes the absorbing probabilities, i.e. the ij-th entry of the matrix denotes the probability of Markov chain being absorbed in state j starting from state i.
- canonical_form() Tuple[List[Basic], ImmutableDenseMatrix][源代码]#
Reorders the one-step transition matrix so that recurrent states appear first and transient states appear last. Other representations include inserting transient states first and recurrent states last.
- 返回:
states, P_new
statesis the list that describes the order of the new states in the matrix so that the ith element instatesis the state of the ith row of A.P_newis the new transition matrix in canonical form.
实例
>>> from sympy.stats import DiscreteMarkovChain >>> from sympy import Matrix, S
You can convert your chain into canonical form:
>>> T = Matrix([[S(1)/2, S(1)/2, 0, 0, 0], ... [S(2)/5, S(1)/5, S(2)/5, 0, 0], ... [0, 0, 1, 0, 0], ... [0, 0, S(1)/2, S(1)/2, 0], ... [S(1)/2, 0, 0, 0, S(1)/2]]) >>> X = DiscreteMarkovChain('X', list(range(1, 6)), trans_probs=T) >>> states, new_matrix = X.canonical_form() >>> states [3, 1, 2, 4, 5]
>>> new_matrix Matrix([ [ 1, 0, 0, 0, 0], [ 0, 1/2, 1/2, 0, 0], [2/5, 2/5, 1/5, 0, 0], [1/2, 0, 0, 1/2, 0], [ 0, 1/2, 0, 0, 1/2]])
The new states are [3, 1, 2, 4, 5] and you can create a new chain with this and its canonical form will remain the same (since it is already in canonical form).
>>> X = DiscreteMarkovChain('X', states, new_matrix) >>> states, new_matrix = X.canonical_form() >>> states [3, 1, 2, 4, 5]
>>> new_matrix Matrix([ [ 1, 0, 0, 0, 0], [ 0, 1/2, 1/2, 0, 0], [2/5, 2/5, 1/5, 0, 0], [1/2, 0, 0, 1/2, 0], [ 0, 1/2, 0, 0, 1/2]])
This is not limited to absorbing chains:
>>> T = Matrix([[0, 5, 5, 0, 0], ... [0, 0, 0, 10, 0], ... [5, 0, 5, 0, 0], ... [0, 10, 0, 0, 0], ... [0, 3, 0, 3, 4]])/10 >>> X = DiscreteMarkovChain('X', trans_probs=T) >>> states, new_matrix = X.canonical_form() >>> states [1, 3, 0, 2, 4]
>>> new_matrix Matrix([ [ 0, 1, 0, 0, 0], [ 1, 0, 0, 0, 0], [ 1/2, 0, 0, 1/2, 0], [ 0, 0, 1/2, 1/2, 0], [3/10, 3/10, 0, 0, 2/5]])
工具书类
- communication_classes() List[Tuple[List[Basic], Boolean, Integer]][源代码]#
Returns the list of communication classes that partition the states of the markov chain.
A communication class is defined to be a set of states such that every state in that set is reachable from every other state in that set. Due to its properties this forms a class in the mathematical sense. Communication classes are also known as recurrence classes.
- 返回:
classes
The
classesare a list of tuples. Each tuple represents a single communication class with its properties. The first element in the tuple is the list of states in the class, the second element is whether the class is recurrent and the third element is the period of the communication class.
实例
>>> from sympy.stats import DiscreteMarkovChain >>> from sympy import Matrix >>> T = Matrix([[0, 1, 0], ... [1, 0, 0], ... [1, 0, 0]]) >>> X = DiscreteMarkovChain('X', [1, 2, 3], T) >>> classes = X.communication_classes() >>> for states, is_recurrent, period in classes: ... states, is_recurrent, period ([1, 2], True, 2) ([3], False, 1)
From this we can see that states
1and2communicate, are recurrent and have a period of 2. We can also see state3is transient with a period of 1.笔记
The algorithm used is of order
O(n**2)wherenis the number of states in the markov chain. It uses Tarjan's algorithm to find the classes themselves and then it uses a breadth-first search algorithm to find each class's periodicity. Most of the algorithm's components approachO(n)as the matrix becomes more and more sparse.工具书类
- decompose() Tuple[List[Basic], ImmutableDenseMatrix, ImmutableDenseMatrix, ImmutableDenseMatrix][源代码]#
Decomposes the transition matrix into submatrices with special properties.
The transition matrix can be decomposed into 4 submatrices: - A - the submatrix from recurrent states to recurrent states. - B - the submatrix from transient to recurrent states. - C - the submatrix from transient to transient states. - O - the submatrix of zeros for recurrent to transient states.
- 返回:
states, A, B, C
states- a list of state names with the first being the recurrent states and the last being the transient states in the order of the row names of A and then the row names of C.A- the submatrix from recurrent states to recurrent states.B- the submatrix from transient to recurrent states.C- the submatrix from transient to transient states.
实例
>>> from sympy.stats import DiscreteMarkovChain >>> from sympy import Matrix, S
One can decompose this chain for example:
>>> T = Matrix([[S(1)/2, S(1)/2, 0, 0, 0], ... [S(2)/5, S(1)/5, S(2)/5, 0, 0], ... [0, 0, 1, 0, 0], ... [0, 0, S(1)/2, S(1)/2, 0], ... [S(1)/2, 0, 0, 0, S(1)/2]]) >>> X = DiscreteMarkovChain('X', trans_probs=T) >>> states, A, B, C = X.decompose() >>> states [2, 0, 1, 3, 4]
>>> A # recurrent to recurrent Matrix([[1]])
>>> B # transient to recurrent Matrix([ [ 0], [2/5], [1/2], [ 0]])
>>> C # transient to transient Matrix([ [1/2, 1/2, 0, 0], [2/5, 1/5, 0, 0], [ 0, 0, 1/2, 0], [1/2, 0, 0, 1/2]])
This means that state 2 is the only absorbing state (since A is a 1x1 matrix). B is a 4x1 matrix since the 4 remaining transient states all merge into reccurent state 2. And C is the 4x4 matrix that shows how the transient states 0, 1, 3, 4 all interact.
参见
sympy.stats.DiscreteMarkovChain.communication_classes,sympy.stats.DiscreteMarkovChain.canonical_form工具书类
- fundamental_matrix()[源代码]#
Each entry fundamental matrix can be interpreted as the expected number of times the chains is in state j if it started in state i.
工具书类
- property limiting_distribution#
The fixed row vector is the limiting distribution of a discrete Markov chain.
- stationary_distribution(condition_set=False) ImmutableDenseMatrix | ConditionSet | Lambda[源代码]#
The stationary distribution is any row vector, p, that solves p = pP, is row stochastic and each element in p must be nonnegative. That means in matrix form: \((P-I)^T p^T = 0\) and \((1, \dots, 1) p = 1\) where
Pis the one-step transition matrix.All time-homogeneous Markov Chains with a finite state space have at least one stationary distribution. In addition, if a finite time-homogeneous Markov Chain is irreducible, the stationary distribution is unique.
- 参数:
condition_set : bool
If the chain has a symbolic size or transition matrix, it will return a
LambdaifFalseand return aConditionSetifTrue.
实例
>>> from sympy.stats import DiscreteMarkovChain >>> from sympy import Matrix, S
An irreducible Markov Chain
>>> T = Matrix([[S(1)/2, S(1)/2, 0], ... [S(4)/5, S(1)/5, 0], ... [1, 0, 0]]) >>> X = DiscreteMarkovChain('X', trans_probs=T) >>> X.stationary_distribution() Matrix([[8/13, 5/13, 0]])
A reducible Markov Chain
>>> T = Matrix([[S(1)/2, S(1)/2, 0], ... [S(4)/5, S(1)/5, 0], ... [0, 0, 1]]) >>> X = DiscreteMarkovChain('X', trans_probs=T) >>> X.stationary_distribution() Matrix([[8/13 - 8*tau0/13, 5/13 - 5*tau0/13, tau0]])
>>> Y = DiscreteMarkovChain('Y') >>> Y.stationary_distribution() Lambda((wm, _T), Eq(wm*_T, wm))
>>> Y.stationary_distribution(condition_set=True) ConditionSet(wm, Eq(wm*_T, wm))
工具书类
- property transition_probabilities#
Transition probabilities of discrete Markov chain, either an instance of Matrix or MatrixSymbol.
- class sympy.stats.ContinuousMarkovChain(sym, state_space=None, gen_mat=None)[源代码]#
表示连续时间马尔可夫链。
- 参数:
sym : Symbol/str
state_space : Set
可选，默认为S.Reals
gen_mat : Matrix/ImmutableMatrix/MatrixSymbol
可选，默认情况下，无
实例
>>> from sympy.stats import ContinuousMarkovChain, P >>> from sympy import Matrix, S, Eq, Gt >>> G = Matrix([[-S(1), S(1)], [S(1), -S(1)]]) >>> C = ContinuousMarkovChain('C', state_space=[0, 1], gen_mat=G) >>> C.limiting_distribution() Matrix([[1/2, 1/2]]) >>> C.state_space {0, 1} >>> C.generator_matrix Matrix([ [-1, 1], [ 1, -1]])
Probability queries are supported
>>> P(Eq(C(1.96), 0), Eq(C(0.78), 1)).round(5) 0.45279 >>> P(Gt(C(1.7), 0), Eq(C(0.82), 1)).round(5) 0.58602
Probability of expressions with multiple RandomIndexedSymbols can also be calculated provided there is only 1 RandomIndexedSymbol in the given condition. It is always better to use Rational instead of floating point numbers for the probabilities in the generator matrix to avoid errors.
>>> from sympy import Gt, Le, Rational >>> G = Matrix([[-S(1), Rational(1, 10), Rational(9, 10)], [Rational(2, 5), -S(1), Rational(3, 5)], [Rational(1, 2), Rational(1, 2), -S(1)]]) >>> C = ContinuousMarkovChain('C', state_space=[0, 1, 2], gen_mat=G) >>> P(Eq(C(3.92), C(1.75)), Eq(C(0.46), 0)).round(5) 0.37933 >>> P(Gt(C(3.92), C(1.75)), Eq(C(0.46), 0)).round(5) 0.34211 >>> P(Le(C(1.57), C(3.14)), Eq(C(1.22), 1)).round(4) 0.7143
Symbolic probability queries are also supported
>>> from sympy import symbols >>> a,b,c,d = symbols('a b c d') >>> G = Matrix([[-S(1), Rational(1, 10), Rational(9, 10)], [Rational(2, 5), -S(1), Rational(3, 5)], [Rational(1, 2), Rational(1, 2), -S(1)]]) >>> C = ContinuousMarkovChain('C', state_space=[0, 1, 2], gen_mat=G) >>> query = P(Eq(C(a), b), Eq(C(c), d)) >>> query.subs({a:3.65, b:2, c:1.78, d:1}).evalf().round(10) 0.4002723175 >>> P(Eq(C(3.65), 2), Eq(C(1.78), 1)).round(10) 0.4002723175 >>> query_gt = P(Gt(C(a), b), Eq(C(c), d)) >>> query_gt.subs({a:43.2, b:0, c:3.29, d:2}).evalf().round(10) 0.6832579186 >>> P(Gt(C(43.2), 0), Eq(C(3.29), 2)).round(10) 0.6832579186
工具书类
[R1030]https://en.wikipedia.org/wiki/Markov_-chain连续-时间-马尔可夫链
- class sympy.stats.BernoulliProcess(sym, p, success=1, failure=0)[源代码]#
The Bernoulli process consists of repeated independent Bernoulli process trials with the same parameter \(p\). It's assumed that the probability \(p\) applies to every trial and that the outcomes of each trial are independent of all the rest. Therefore Bernoulli Process is Discrete State and Discrete Time Stochastic Process.
- 参数:
sym : Symbol/str
success : Integer/str
The event which is considered to be success. Default: 1.
failure: Integer/str
The event which is considered to be failure. Default: 0.
p : Real Number between 0 and 1
表示获得成功的概率。
实例
>>> from sympy.stats import BernoulliProcess, P, E >>> from sympy import Eq, Gt >>> B = BernoulliProcess("B", p=0.7, success=1, failure=0) >>> B.state_space {0, 1} >>> B.p.round(2) 0.70 >>> B.success 1 >>> B.failure 0 >>> X = B[1] + B[2] + B[3] >>> P(Eq(X, 0)).round(2) 0.03 >>> P(Eq(X, 2)).round(2) 0.44 >>> P(Eq(X, 4)).round(2) 0 >>> P(Gt(X, 1)).round(2) 0.78 >>> P(Eq(B[1], 0) & Eq(B[2], 1) & Eq(B[3], 0) & Eq(B[4], 1)).round(2) 0.04 >>> B.joint_distribution(B[1], B[2]) JointDistributionHandmade(Lambda((B[1], B[2]), Piecewise((0.7, Eq(B[1], 1)), (0.3, Eq(B[1], 0)), (0, True))*Piecewise((0.7, Eq(B[2], 1)), (0.3, Eq(B[2], 0)), (0, True)))) >>> E(2*B[1] + B[2]).round(2) 2.10 >>> P(B[1] < 1).round(2) 0.30
工具书类
- expectation(expr, condition=None, evaluate=True, **kwargs)[源代码]#
Computes expectation.
- 参数:
expr : RandomIndexedSymbol, Relational, Logic
Condition for which expectation has to be computed. Must contain a RandomIndexedSymbol of the process.
condition : Relational, Logic
The given conditions under which computations should be done.
- 返回:
Expectation of the RandomIndexedSymbol.
- probability(condition, given_condition=None, evaluate=True, **kwargs)[源代码]#
Computes probability.
- 参数:
condition : Relational
Condition for which probability has to be computed. Must contain a RandomIndexedSymbol of the process.
given_condition : Relational, Logic
The given conditions under which computations should be done.
- 返回:
Probability of the condition.
- class sympy.stats.PoissonProcess(sym, lamda)[源代码]#
泊松过程是一个计数过程。它通常用于这样的场景中：我们正在统计某些事件的发生，这些事件似乎以某种速率发生，但完全是随机发生的。
- 参数:
sym : Symbol/str
lamda : Positive number
Rate of the process,
lambda > 0
实例
>>> from sympy.stats import PoissonProcess, P, E >>> from sympy import symbols, Eq, Ne, Contains, Interval >>> X = PoissonProcess("X", lamda=3) >>> X.state_space Naturals0 >>> X.lamda 3 >>> t1, t2 = symbols('t1 t2', positive=True) >>> P(X(t1) < 4) (9*t1**3/2 + 9*t1**2/2 + 3*t1 + 1)*exp(-3*t1) >>> P(Eq(X(t1), 2) | Ne(X(t1), 4), Contains(t1, Interval.Ropen(2, 4))) 1 - 36*exp(-6) >>> P(Eq(X(t1), 2) & Eq(X(t2), 3), Contains(t1, Interval.Lopen(0, 2)) ... & Contains(t2, Interval.Lopen(2, 4))) 648*exp(-12) >>> E(X(t1)) 3*t1 >>> E(X(t1)**2 + 2*X(t2), Contains(t1, Interval.Lopen(0, 1)) ... & Contains(t2, Interval.Lopen(1, 2))) 18 >>> P(X(3) < 1, Eq(X(1), 0)) exp(-6) >>> P(Eq(X(4), 3), Eq(X(2), 3)) exp(-6) >>> P(X(2) <= 3, X(1) > 1) 5*exp(-3)
合并两个泊松过程
>>> Y = PoissonProcess("Y", lamda=4) >>> Z = X + Y >>> Z.lamda 7
将Poisson过程分解为两个独立的Poisson过程
>>> N, M = Z.split(l1=2, l2=5) >>> N.lamda, M.lamda (2, 5)
工具书类
- class sympy.stats.WienerProcess(sym)[源代码]#
The Wiener process is a real valued continuous-time stochastic process. In physics it is used to study Brownian motion and it is often also called Brownian motion due to its historical connection with physical process of the same name originally observed by Scottish botanist Robert Brown.
- 参数:
sym : Symbol/str
实例
>>> from sympy.stats import WienerProcess, P, E >>> from sympy import symbols, Contains, Interval >>> X = WienerProcess("X") >>> X.state_space Reals >>> t1, t2 = symbols('t1 t2', positive=True) >>> P(X(t1) < 7).simplify() erf(7*sqrt(2)/(2*sqrt(t1)))/2 + 1/2 >>> P((X(t1) > 2) | (X(t1) < 4), Contains(t1, Interval.Ropen(2, 4))).simplify() -erf(1)/2 + erf(2)/2 + 1 >>> E(X(t1)) 0 >>> E(X(t1) + 2*X(t2), Contains(t1, Interval.Lopen(0, 1)) ... & Contains(t2, Interval.Lopen(1, 2))) 0
工具书类
- class sympy.stats.GammaProcess(sym, lamda, gamma)[源代码]#
A Gamma process is a random process with independent gamma distributed increments. It is a pure-jump increasing Levy process.
- 参数:
sym : Symbol/str
lamda : Positive number
过程的跳跃大小，
lamda > 0gamma : Positive number
Rate of jump arrivals, \(\gamma > 0\)
实例
>>> from sympy.stats import GammaProcess, E, P, variance >>> from sympy import symbols, Contains, Interval, Not >>> t, d, x, l, g = symbols('t d x l g', positive=True) >>> X = GammaProcess("X", l, g) >>> E(X(t)) g*t/l >>> variance(X(t)).simplify() g*t/l**2 >>> X = GammaProcess('X', 1, 2) >>> P(X(t) < 1).simplify() lowergamma(2*t, 1)/gamma(2*t) >>> P(Not((X(t) < 5) & (X(d) > 3)), Contains(t, Interval.Ropen(2, 4)) & ... Contains(d, Interval.Lopen(7, 8))).simplify() -4*exp(-3) + 472*exp(-8)/3 + 1 >>> E(X(2) + x*E(X(5))) 10*x + 4
工具书类
矩阵分布#
- sympy.stats.MatrixGamma(symbol, alpha, beta, scale_matrix)[源代码]#
创建具有矩阵伽马分布的随机变量。
上述分布的密度可在 [1] .
- 参数:
α：正实数
形状参数
β：正实数
比例参数
scale_matrix: Positive definite real square matrix
比例矩阵
- 返回:
RandomSymbol
实例
>>> from sympy.stats import density, MatrixGamma >>> from sympy import MatrixSymbol, symbols >>> a, b = symbols('a b', positive=True) >>> M = MatrixGamma('M', a, b, [[2, 1], [1, 2]]) >>> X = MatrixSymbol('X', 2, 2) >>> density(M)(X).doit() exp(Trace(Matrix([ [-2/3, 1/3], [ 1/3, -2/3]])*X)/b)*Determinant(X)**(a - 3/2)/(3**a*sqrt(pi)*b**(2*a)*gamma(a)*gamma(a - 1/2)) >>> density(M)([[1, 0], [0, 1]]).doit() exp(-4/(3*b))/(3**a*sqrt(pi)*b**(2*a)*gamma(a)*gamma(a - 1/2))
工具书类
- sympy.stats.Wishart(symbol, n, scale_matrix)[源代码]#
创建具有Wishart分布的随机变量。
上述分布的密度可在 [1] .
- 参数:
n： 正实数
表示自由度
scale_matrix: Positive definite real square matrix
比例矩阵
- 返回:
RandomSymbol
实例
>>> from sympy.stats import density, Wishart >>> from sympy import MatrixSymbol, symbols >>> n = symbols('n', positive=True) >>> W = Wishart('W', n, [[2, 1], [1, 2]]) >>> X = MatrixSymbol('X', 2, 2) >>> density(W)(X).doit() exp(Trace(Matrix([ [-1/3, 1/6], [ 1/6, -1/3]])*X))*Determinant(X)**(n/2 - 3/2)/(2**n*3**(n/2)*sqrt(pi)*gamma(n/2)*gamma(n/2 - 1/2)) >>> density(W)([[1, 0], [0, 1]]).doit() exp(-2/3)/(2**n*3**(n/2)*sqrt(pi)*gamma(n/2)*gamma(n/2 - 1/2))
工具书类
- sympy.stats.MatrixNormal(symbol, location_matrix, scale_matrix_1, scale_matrix_2)[源代码]#
创建矩阵正态分布的随机变量。
上述分布的密度可在 [1] .
- 参数:
location_matrix: Real ``n x p`` matrix
表示自由度
scale_matrix_1: Positive definite matrix
形状比例矩阵
n x nscale_matrix_2: Positive definite matrix
形状比例矩阵
p x p- 返回:
RandomSymbol
实例
>>> from sympy import MatrixSymbol >>> from sympy.stats import density, MatrixNormal >>> M = MatrixNormal('M', [[1, 2]], [1], [[1, 0], [0, 1]]) >>> X = MatrixSymbol('X', 1, 2) >>> density(M)(X).doit() exp(-Trace((Matrix([ [-1], [-2]]) + X.T)*(Matrix([[-1, -2]]) + X))/2)/(2*pi) >>> density(M)([[3, 4]]).doit() exp(-4)/(2*pi)
工具书类
复合分布#
- class sympy.stats.compound_rv.CompoundDistribution(dist)[源代码]#
用于复合分布的类。
- 参数:
dist ：分布
分布必须包含随机参数
实例
>>> from sympy.stats.compound_rv import CompoundDistribution >>> from sympy.stats.crv_types import NormalDistribution >>> from sympy.stats import Normal >>> from sympy.abc import x >>> X = Normal('X', 2, 4) >>> N = NormalDistribution(X, 4) >>> C = CompoundDistribution(N) >>> C.set Interval(-oo, oo) >>> C.pdf(x, evaluate=True).simplify() exp(-x**2/64 + x/16 - 1/16)/(8*sqrt(pi))
工具书类
界面#
- sympy.stats.P(condition, given_condition=None, numsamples=None, evaluate=True, **kwargs)[源代码]#
Probability that a condition is true, optionally given a second condition.
- 参数:
条件 ：包含随机符号的关系的组合
计算概率的条件
given_condition ：包含随机符号的关系的组合
条件表达式。P（X>1，X>0）是给定X>0的X>1的期望值
个样本 ：内景
启用采样，并使用此多个采样来近似概率
评价 ：Bool（默认为True）
在连续系统返回未赋值积分的情况下
实例
>>> from sympy.stats import P, Die >>> from sympy import Eq >>> X, Y = Die('X', 6), Die('Y', 6) >>> P(X > 3) 1/2 >>> P(Eq(X, 5), X > 2) # Probability that X == 5 given that X > 2 1/4 >>> P(X > Y) 5/12
- class sympy.stats.Probability(prob, condition=None, **kwargs)[源代码]#
概率的符号表达式。
实例
>>> from sympy.stats import Probability, Normal >>> from sympy import Integral >>> X = Normal("X", 0, 1) >>> prob = Probability(X > 1) >>> prob Probability(X > 1)
积分表示：
>>> prob.rewrite(Integral) Integral(sqrt(2)*exp(-_z**2/2)/(2*sqrt(pi)), (_z, 1, oo))
积分评估：
>>> prob.evaluate_integral() sqrt(2)*(-sqrt(2)*sqrt(pi)*erf(sqrt(2)/2) + sqrt(2)*sqrt(pi))/(4*sqrt(pi))
- sympy.stats.E(expr, condition=None, numsamples=None, evaluate=True, **kwargs)[源代码]#
Returns the expected value of a random expression.
- 参数:
expr ：Expr包含随机符号
要计算其期望值的表达式
鉴于 ：Expr包含随机符号
条件表达式。E（X，X>0）是给定X>0的X的期望值
个样本 ：内景
启用采样，并使用此多个采样近似期望值
埃瓦尔 ：Bool（默认为True）
如果采样返回的是数字而不是复杂表达式
评价 ：Bool（默认为True）
在连续系统返回未赋值积分的情况下
实例
>>> from sympy.stats import E, Die >>> X = Die('X', 6) >>> E(X) 7/2 >>> E(2*X + 1) 8
>>> E(X, X > 3) # Expectation of X given that it is above 3 5
- class sympy.stats.Expectation(expr, condition=None, **kwargs)[源代码]#
期望的象征性表达。
实例
>>> from sympy.stats import Expectation, Normal, Probability, Poisson >>> from sympy import symbols, Integral, Sum >>> mu = symbols("mu") >>> sigma = symbols("sigma", positive=True) >>> X = Normal("X", mu, sigma) >>> Expectation(X) Expectation(X) >>> Expectation(X).evaluate_integral().simplify() mu
要得到期望值的积分表达式：
>>> Expectation(X).rewrite(Integral) Integral(sqrt(2)*X*exp(-(X - mu)**2/(2*sigma**2))/(2*sqrt(pi)*sigma), (X, -oo, oo))
同样的积分表达式，用更抽象的术语来说：
>>> Expectation(X).rewrite(Probability) Integral(x*Probability(Eq(X, x)), (x, -oo, oo))
要得到离散随机变量期望的求和表达式：
>>> lamda = symbols('lamda', positive=True) >>> Z = Poisson('Z', lamda) >>> Expectation(Z).rewrite(Sum) Sum(Z*lamda**Z*exp(-lamda)/factorial(Z), (Z, 0, oo))
该类了解期望的一些属性：
>>> from sympy.abc import a >>> Expectation(a*X) Expectation(a*X) >>> Y = Normal("Y", 1, 2) >>> Expectation(X + Y) Expectation(X + Y)
扩展
Expectation在它的表达中，使用expand()：>>> Expectation(X + Y).expand() Expectation(X) + Expectation(Y) >>> Expectation(a*X + Y).expand() a*Expectation(X) + Expectation(Y) >>> Expectation(a*X + Y) Expectation(a*X + Y) >>> Expectation((X + Y)*(X - Y)).expand() Expectation(X**2) - Expectation(Y**2)
评估
Expectation使用doit()：>>> Expectation(X + Y).doit() mu + 1 >>> Expectation(X + Expectation(Y + Expectation(2*X))).doit() 3*mu + 1
防止计算嵌套
Expectation使用doit(deep=False)>>> Expectation(X + Expectation(Y)).doit(deep=False) mu + Expectation(Expectation(Y)) >>> Expectation(X + Expectation(Y + Expectation(2*X))).doit(deep=False) mu + Expectation(Expectation(Expectation(2*X) + Y))
- sympy.stats.density(expr, condition=None, evaluate=True, numsamples=None, **kwargs)[源代码]#
随机表达式的概率密度，可选地给定第二个条件。
- 参数:
expr ：Expr包含随机符号
要计算其密度值的表达式
条件 ：包含随机符号的关系型
条件表达式。密度（X>1，X>0）是给定X>0的X>1的密度
个样本 ：内景
启用采样并使用此多个采样近似密度
解释
对于不同类型的概率空间，这种密度将呈现不同的形式。离散变量产生指令。连续变量产生Lambdas。
实例
>>> from sympy.stats import density, Die, Normal >>> from sympy import Symbol
>>> x = Symbol('x') >>> D = Die('D', 6) >>> X = Normal(x, 0, 1)
>>> density(D).dict {1: 1/6, 2: 1/6, 3: 1/6, 4: 1/6, 5: 1/6, 6: 1/6} >>> density(2*D).dict {2: 1/6, 4: 1/6, 6: 1/6, 8: 1/6, 10: 1/6, 12: 1/6} >>> density(X)(x) sqrt(2)*exp(-x**2/2)/(2*sqrt(pi))
- sympy.stats.entropy(expr, condition=None, **kwargs)[源代码]#
Calculuates entropy of a probability distribution.
- 参数:
表达 ：要计算其熵的随机表达式
条件 ：可选，指定随机表达式的条件
b： 对数的底，可选
默认情况下，它将作为Euler的编号
- 返回:
结果 ：表达式的熵，一个常数
实例
>>> from sympy.stats import Normal, Die, entropy >>> X = Normal('X', 0, 1) >>> entropy(X) log(2)/2 + 1/2 + log(pi)/2
>>> D = Die('D', 4) >>> entropy(D) log(4)
工具书类
- sympy.stats.given(expr, condition=None, **kwargs)[源代码]#
Conditional Random Expression.
解释
From a random expression and a condition on that expression creates a new probability space from the condition and returns the same expression on that conditional probability space.
实例
>>> from sympy.stats import given, density, Die >>> X = Die('X', 6) >>> Y = given(X, X > 3) >>> density(Y).dict {4: 1/3, 5: 1/3, 6: 1/3}
按照惯例，如果条件是随机符号，则认为该符号是固定的。
>>> from sympy.stats import Normal >>> from sympy import pprint >>> from sympy.abc import z
>>> X = Normal('X', 0, 1) >>> Y = Normal('Y', 0, 1) >>> pprint(density(X + Y, Y)(z), use_unicode=False) 2 -(-Y + z) ----------- ___ 2 \/ 2 *e ------------------ ____ 2*\/ pi
- sympy.stats.where(condition, given_condition=None, **kwargs)[源代码]#
返回条件为真的域。
实例
>>> from sympy.stats import where, Die, Normal >>> from sympy import And
>>> D1, D2 = Die('a', 6), Die('b', 6) >>> a, b = D1.symbol, D2.symbol >>> X = Normal('x', 0, 1)
>>> where(X**2<1) Domain: (-1 < x) & (x < 1)
>>> where(X**2<1).set Interval.open(-1, 1)
>>> where(And(D1<=D2, D2<3)) Domain: (Eq(a, 1) & Eq(b, 1)) | (Eq(a, 1) & Eq(b, 2)) | (Eq(a, 2) & Eq(b, 2))
- sympy.stats.variance(X, condition=None, **kwargs)[源代码]#
Variance of a random expression.
\[方差（X）=E（（X-E（X））^{2}）\]实例
>>> from sympy.stats import Die, Bernoulli, variance >>> from sympy import simplify, Symbol
>>> X = Die('X', 6) >>> p = Symbol('p') >>> B = Bernoulli('B', p, 1, 0)
>>> variance(2*X) 35/3
>>> simplify(variance(B)) p*(1 - p)
- class sympy.stats.Variance(arg, condition=None, **kwargs)[源代码]#
方差的符号表达式。
实例
>>> from sympy import symbols, Integral >>> from sympy.stats import Normal, Expectation, Variance, Probability >>> mu = symbols("mu", positive=True) >>> sigma = symbols("sigma", positive=True) >>> X = Normal("X", mu, sigma) >>> Variance(X) Variance(X) >>> Variance(X).evaluate_integral() sigma**2
基本计算的积分表示：
>>> Variance(X).rewrite(Integral) Integral(sqrt(2)*(X - Integral(sqrt(2)*X*exp(-(X - mu)**2/(2*sigma**2))/(2*sqrt(pi)*sigma), (X, -oo, oo)))**2*exp(-(X - mu)**2/(2*sigma**2))/(2*sqrt(pi)*sigma), (X, -oo, oo))
积分表示，无需展开PDF：
>>> Variance(X).rewrite(Probability) -Integral(x*Probability(Eq(X, x)), (x, -oo, oo))**2 + Integral(x**2*Probability(Eq(X, x)), (x, -oo, oo))
根据期望重写方差
>>> Variance(X).rewrite(Expectation) -Expectation(X)**2 + Expectation(X**2)
可能会发生基于方差性质的一些转换：
>>> from sympy.abc import a >>> Y = Normal("Y", 0, 1) >>> Variance(a*X) Variance(a*X)
要扩展表达式中的方差，请使用
expand()：>>> Variance(a*X).expand() a**2*Variance(X) >>> Variance(X + Y) Variance(X + Y) >>> Variance(X + Y).expand() 2*Covariance(X, Y) + Variance(X) + Variance(Y)
- sympy.stats.covariance(X, Y, condition=None, **kwargs)[源代码]#
Covariance of two random expressions.
解释
对这两个变量同时上升和下降的预期
\[协方差（X，Y）=E（（X-E（X））（Y-E（Y）））\]实例
>>> from sympy.stats import Exponential, covariance >>> from sympy import Symbol
>>> rate = Symbol('lambda', positive=True, real=True) >>> X = Exponential('X', rate) >>> Y = Exponential('Y', rate)
>>> covariance(X, X) lambda**(-2) >>> covariance(X, Y) 0 >>> covariance(X, Y + rate*X) 1/lambda
- class sympy.stats.Covariance(arg1, arg2, condition=None, **kwargs)[源代码]#
协方差的符号表达式。
实例
>>> from sympy.stats import Covariance >>> from sympy.stats import Normal >>> X = Normal("X", 3, 2) >>> Y = Normal("Y", 0, 1) >>> Z = Normal("Z", 0, 1) >>> W = Normal("W", 0, 1) >>> cexpr = Covariance(X, Y) >>> cexpr Covariance(X, Y)
评估协方差， \(X\) 和 \(Y\) 是独立的，因此结果为零：
>>> cexpr.evaluate_integral() 0
根据期望重写协方差表达式：
>>> from sympy.stats import Expectation >>> cexpr.rewrite(Expectation) Expectation(X*Y) - Expectation(X)*Expectation(Y)
为了扩展参数，使用
expand()：>>> from sympy.abc import a, b, c, d >>> Covariance(a*X + b*Y, c*Z + d*W) Covariance(a*X + b*Y, c*Z + d*W) >>> Covariance(a*X + b*Y, c*Z + d*W).expand() a*c*Covariance(X, Z) + a*d*Covariance(W, X) + b*c*Covariance(Y, Z) + b*d*Covariance(W, Y)
此类知道协方差的一些属性：
>>> Covariance(X, X).expand() Variance(X) >>> Covariance(a*X, b*Y).expand() a*b*Covariance(X, Y)
- sympy.stats.coskewness(X, Y, Z, condition=None, **kwargs)[源代码]#
Calculates the co-skewness of three random variables.
- 参数:
X ：随机符号
用于计算随机变量
Y ：随机符号
用于计算随机变量
Z ：随机符号
用于计算随机变量
条件 ：Expr包含随机符号
条件表达式
- 返回:
协偏度 ：三个随机变量的相似性
解释
Mathematically Coskewness is defined as
\[coskewness(X,Y,Z)=\frac{E[(X-E[X]) * (Y-E[Y]) * (Z-E[Z])]} {\sigma_{X}\sigma_{Y}\sigma_{Z}}\]实例
>>> from sympy.stats import coskewness, Exponential, skewness >>> from sympy import symbols >>> p = symbols('p', positive=True) >>> X = Exponential('X', p) >>> Y = Exponential('Y', 2*p) >>> coskewness(X, Y, Y) 0 >>> coskewness(X, Y + X, Y + 2*X) 16*sqrt(85)/85 >>> coskewness(X + 2*Y, Y + X, Y + 2*X, X > 3) 9*sqrt(170)/85 >>> coskewness(Y, Y, Y) == skewness(Y) True >>> coskewness(X, Y + p*X, Y + 2*p*X) 4/(sqrt(1 + 1/(4*p**2))*sqrt(4 + 1/(4*p**2)))
工具书类
- sympy.stats.median(X, evaluate=True, **kwargs)[源代码]#
Calculuates the median of the probability distribution.
- 参数:
十： 要计算其中值的随机表达式。
- 返回:
包含中间值的有限集或区间
随机表达式。
解释
Mathematically, median of Probability distribution is defined as all those values of \(m\) for which the following condition is satisfied
\[P（X\leq m）\geq\frac{1}{2}\text{and}\text{P（X\geq m）\geq\frac{1}{2}\]实例
>>> from sympy.stats import Normal, Die, median >>> N = Normal('N', 3, 1) >>> median(N) {3} >>> D = Die('D') >>> median(D) {3, 4}
工具书类
[R1047]https://en.wikipedia.org/wiki/Median#概率分布
- sympy.stats.std(X, condition=None, **kwargs)[源代码]#
随机表达式的标准差
\[标准（X）=\sqrt（E（（X-E（X））^{2}））\]实例
>>> from sympy.stats import Bernoulli, std >>> from sympy import Symbol, simplify
>>> p = Symbol('p') >>> B = Bernoulli('B', p, 1, 0)
>>> simplify(std(B)) sqrt(p*(1 - p))
- sympy.stats.quantile(expr, evaluate=True, **kwargs)[源代码]#
Return the \(p^{th}\) order quantile of a probability distribution.
解释
Quantile is defined as the value at which the probability of the random variable is less than or equal to the given probability.
\[Q(p) = \inf\{x \in (-\infty, \infty) : p \le F(x)\}\]实例
>>> from sympy.stats import quantile, Die, Exponential >>> from sympy import Symbol, pprint >>> p = Symbol("p")
>>> l = Symbol("lambda", positive=True) >>> X = Exponential("x", l) >>> quantile(X)(p) -log(1 - p)/lambda
>>> D = Die("d", 6) >>> pprint(quantile(D)(p), use_unicode=False) /nan for Or(p > 1, p < 0) | | 1 for p <= 1/6 | | 2 for p <= 1/3 | < 3 for p <= 1/2 | | 4 for p <= 2/3 | | 5 for p <= 5/6 | \ 6 for p <= 1
- sympy.stats.sample(expr, condition=None, size=(), library='scipy', numsamples=1, seed=None, **kwargs)[源代码]#
A realization of the random expression.
- 参数:
expr ：随机变量表达式
从中提取样本的表达式
条件 ：Expr包含随机符号
条件表达式
size ：int，元组
以numsamples表示每个样本的大小
类库 ：结构
“scipy”：使用scipy的示例
“numpy”：使用numpy的示例
'pymc' : Sample using PyMC
选择任何可用选项作为字符串进行采样，默认为“scipy”
个样本 ：内景
Number of samples, each with size as
size.自 1.9 版本弃用.
The
numsamplesparameter is deprecated and is only provided for compatibility with v1.8. Use a list comprehension or an additional dimension insizeinstead. See sympy.stats.sample(numsamples=n) for details.seed :
An object to be used as seed by the given external library for sampling \(expr\). Following is the list of possible types of object for the supported libraries,
'scipy': int, numpy.random.RandomState, numpy.random.Generator
'numpy': int, numpy.random.RandomState, numpy.random.Generator
'pymc': int
Optional, by default None, in which case seed settings related to the given library will be used. No modifications to environment's global seed settings are done by this argument.
- 返回:
sample: float/list/numpy.ndarray
one sample or a collection of samples of the random expression.
sample(X) returns float/numpy.float64/numpy.int64 object.
sample(X, size=int/tuple) returns numpy.ndarray object.
实例
>>> from sympy.stats import Die, sample, Normal, Geometric >>> X, Y, Z = Die('X', 6), Die('Y', 6), Die('Z', 6) # Finite Random Variable >>> die_roll = sample(X + Y + Z) >>> die_roll 3 >>> N = Normal('N', 3, 4) # Continuous Random Variable >>> samp = sample(N) >>> samp in N.pspace.domain.set True >>> samp = sample(N, N>0) >>> samp > 0 True >>> samp_list = sample(N, size=4) >>> [sam in N.pspace.domain.set for sam in samp_list] [True, True, True, True] >>> sample(N, size = (2,3)) array([[5.42519758, 6.40207856, 4.94991743], [1.85819627, 6.83403519, 1.9412172 ]]) >>> G = Geometric('G', 0.5) # Discrete Random Variable >>> samp_list = sample(G, size=3) >>> samp_list [1, 3, 2] >>> [sam in G.pspace.domain.set for sam in samp_list] [True, True, True] >>> MN = Normal("MN", [3, 4], [[2, 1], [1, 2]]) # Joint Random Variable >>> samp_list = sample(MN, size=4) >>> samp_list [array([2.85768055, 3.38954165]), array([4.11163337, 4.3176591 ]), array([0.79115232, 1.63232916]), array([4.01747268, 3.96716083])] >>> [tuple(sam) in MN.pspace.domain.set for sam in samp_list] [True, True, True, True]
在 1.7.0 版本发生变更: sample used to return an iterator containing the samples instead of value.
在 1.9.0 版本发生变更: sample returns values or array of values instead of an iterator and numsamples is deprecated.
- sympy.stats.sample_iter(expr, condition=None, size=(), library='scipy', numsamples=oo, seed=None, **kwargs)[源代码]#
Returns an iterator of realizations from the expression given a condition.
- 参数:
表达式：表达式
要实现的随机表达式
条件：Expr，可选
条件表达式
size ：int，元组
以numsamples表示每个样本的大小
numsamples：整数，可选
迭代器的长度（默认为无穷大）
seed :
An object to be used as seed by the given external library for sampling \(expr\). Following is the list of possible types of object for the supported libraries,
'scipy': int, numpy.random.RandomState, numpy.random.Generator
'numpy': int, numpy.random.RandomState, numpy.random.Generator
'pymc': int
Optional, by default None, in which case seed settings related to the given library will be used. No modifications to environment's global seed settings are done by this argument.
- 返回:
示例：迭代器对象
包含给定表达式的sample/samples的iterator对象
实例
>>> from sympy.stats import Normal, sample_iter >>> X = Normal('X', 0, 1) >>> expr = X*X + 3 >>> iterator = sample_iter(expr, numsamples=3) >>> list(iterator) [12, 4, 7]
参见
- sympy.stats.factorial_moment(X, n, condition=None, **kwargs)[源代码]#
阶乘矩是一个数学量，定义为随机变量下降阶乘的期望值或平均值。
\[阶乘矩（X，n）=E（X（X-1）（X-2）…（X-n+1））\]- 参数:
n: A natural number, n-th factorial moment.
条件 ：Expr包含随机符号
条件表达式。
实例
>>> from sympy.stats import factorial_moment, Poisson, Binomial >>> from sympy import Symbol, S >>> lamda = Symbol('lamda') >>> X = Poisson('X', lamda) >>> factorial_moment(X, 2) lamda**2 >>> Y = Binomial('Y', 2, S.Half) >>> factorial_moment(Y, 2) 1/2 >>> factorial_moment(Y, 2, Y > 1) # find factorial moment for Y > 1 2
工具书类
- sympy.stats.kurtosis(X, condition=None, **kwargs)[源代码]#
描述概率分布的尾部/离群值。
- 参数:
条件 ：Expr包含随机符号
条件表达式。给定峰度X>X
解释
任何一元正态分布的峰度都是3。峰度小于3意味着分布比正态分布产生的异常值越来越少。
\[峰度（X）=E（（（X-E（X））/\sigma_X）^{4}）\]实例
>>> from sympy.stats import kurtosis, Exponential, Normal >>> from sympy import Symbol >>> X = Normal('X', 0, 1) >>> kurtosis(X) 3 >>> kurtosis(X, X > 0) # find kurtosis given X > 0 (-4/pi - 12/pi**2 + 3)/(1 - 2/pi)**2
>>> rate = Symbol('lamda', positive=True, real=True) >>> Y = Exponential('Y', rate) >>> kurtosis(Y) 9
工具书类
- sympy.stats.skewness(X, condition=None, **kwargs)[源代码]#
概率分布不对称性的度量。
- 参数:
条件 ：Expr包含随机符号
条件表达式。偏度（X，X>0）是给定X>0的X的偏度
解释
正偏差表示大多数值位于平均值的右侧。
\[偏度（X）=E（（（X-E（X））/\sigma_X）^{3}）\]实例
>>> from sympy.stats import skewness, Exponential, Normal >>> from sympy import Symbol >>> X = Normal('X', 0, 1) >>> skewness(X) 0 >>> skewness(X, X > 0) # find skewness given X > 0 (-sqrt(2)/sqrt(pi) + 4*sqrt(2)/pi**(3/2))/(1 - 2/pi)**(3/2)
>>> rate = Symbol('lambda', positive=True, real=True) >>> Y = Exponential('Y', rate) >>> skewness(Y) 2
- sympy.stats.correlation(X, Y, condition=None, **kwargs)[源代码]#
Correlation of two random expressions, also known as correlation coefficient or Pearson's correlation.
解释
两个变量同时上升和下降的标准化期望
\[相关性（X，Y）=E（（X-E（X））（Y-E（Y））/（\sigma_X\sigma_Y））\]实例
>>> from sympy.stats import Exponential, correlation >>> from sympy import Symbol
>>> rate = Symbol('lambda', positive=True, real=True) >>> X = Exponential('X', rate) >>> Y = Exponential('Y', rate)
>>> correlation(X, X) 1 >>> correlation(X, Y) 0 >>> correlation(X, Y + rate*X) 1/sqrt(1 + lambda**(-2))
- sympy.stats.rv.sampling_density(expr, given_condition=None, library='scipy', numsamples=1, seed=None, **kwargs)[源代码]#
Sampling version of density.
参见
- sympy.stats.rv.sampling_P(condition, given_condition=None, library='scipy', numsamples=1, evalf=True, seed=None, **kwargs)[源代码]#
Sampling version of P.
参见
- sympy.stats.rv.sampling_E(expr, given_condition=None, library='scipy', numsamples=1, evalf=True, seed=None, **kwargs)[源代码]#
Sampling version of E.
参见
- class sympy.stats.Moment(X, n, c=0, condition=None, **kwargs)[源代码]#
符号类
实例
>>> from sympy import Symbol, Integral >>> from sympy.stats import Normal, Expectation, Probability, Moment >>> mu = Symbol('mu', real=True) >>> sigma = Symbol('sigma', positive=True) >>> X = Normal('X', mu, sigma) >>> M = Moment(X, 3, 1)
评估力矩使用的结果 \(doit\) ：
>>> M.doit() mu**3 - 3*mu**2 + 3*mu*sigma**2 + 3*mu - 3*sigma**2 - 1
根据期望重写力矩表达式：
>>> M.rewrite(Expectation) Expectation((X - 1)**3)
根据概率改写力矩表达式：
>>> M.rewrite(Probability) Integral((x - 1)**3*Probability(Eq(X, x)), (x, -oo, oo))
用积分重写力矩表达式：
>>> M.rewrite(Integral) Integral(sqrt(2)*(X - 1)**3*exp(-(X - mu)**2/(2*sigma**2))/(2*sqrt(pi)*sigma), (X, -oo, oo))
- sympy.stats.moment(X, n, c=0, condition=None, *, evaluate=True, **kwargs)[源代码]#
返回关于c的随机表达式的第n个矩。
\[力矩（X，c，n）=E（（X-c）^{n}）\]c的默认值是0。
实例
>>> from sympy.stats import Die, moment, E >>> X = Die('X', 6) >>> moment(X, 1, 6) -5/2 >>> moment(X, 2) 91/6 >>> moment(X, 1) == E(X) True
- class sympy.stats.CentralMoment(X, n, condition=None, **kwargs)[源代码]#
符号类中心矩
实例
>>> from sympy import Symbol, Integral >>> from sympy.stats import Normal, Expectation, Probability, CentralMoment >>> mu = Symbol('mu', real=True) >>> sigma = Symbol('sigma', positive=True) >>> X = Normal('X', mu, sigma) >>> CM = CentralMoment(X, 4)
评估使用中心力矩的结果 \(doit\) ：
>>> CM.doit().simplify() 3*sigma**4
根据期望重写CentralMoment表达式：
>>> CM.rewrite(Expectation) Expectation((-Expectation(X) + X)**4)
根据概率重写CentralMoment表达式：
>>> CM.rewrite(Probability) Integral((x - Integral(x*Probability(True), (x, -oo, oo)))**4*Probability(Eq(X, x)), (x, -oo, oo))
用积分重写CentralMoment表达式：
>>> CM.rewrite(Integral) Integral(sqrt(2)*(X - Integral(sqrt(2)*X*exp(-(X - mu)**2/(2*sigma**2))/(2*sqrt(pi)*sigma), (X, -oo, oo)))**4*exp(-(X - mu)**2/(2*sigma**2))/(2*sqrt(pi)*sigma), (X, -oo, oo))
- sympy.stats.cmoment(X, n, condition=None, *, evaluate=True, **kwargs)[源代码]#
返回随机表达式关于其平均值的第n个中心矩。
\[cmoment（X，n）=E（（X-E（X））^{n}）\]实例
>>> from sympy.stats import Die, cmoment, variance >>> X = Die('X', 6) >>> cmoment(X, 3) 0 >>> cmoment(X, 2) 35/12 >>> cmoment(X, 2) == variance(X) True
- class sympy.stats.ExpectationMatrix(expr, condition=None)[源代码]#
随机矩阵表达式的期望。
实例
>>> from sympy.stats import ExpectationMatrix, Normal >>> from sympy.stats.rv import RandomMatrixSymbol >>> from sympy import symbols, MatrixSymbol, Matrix >>> k = symbols("k") >>> A, B = MatrixSymbol("A", k, k), MatrixSymbol("B", k, k) >>> X, Y = RandomMatrixSymbol("X", k, 1), RandomMatrixSymbol("Y", k, 1) >>> ExpectationMatrix(X) ExpectationMatrix(X) >>> ExpectationMatrix(A*X).shape (k, 1)
要扩展表达式中的期望值，请使用
expand()：>>> ExpectationMatrix(A*X + B*Y).expand() A*ExpectationMatrix(X) + B*ExpectationMatrix(Y) >>> ExpectationMatrix((X + Y)*(X - Y).T).expand() ExpectationMatrix(X*X.T) - ExpectationMatrix(X*Y.T) + ExpectationMatrix(Y*X.T) - ExpectationMatrix(Y*Y.T)
评估
ExpectationMatrix使用doit()：>>> N11, N12 = Normal('N11', 11, 1), Normal('N12', 12, 1) >>> N21, N22 = Normal('N21', 21, 1), Normal('N22', 22, 1) >>> M11, M12 = Normal('M11', 1, 1), Normal('M12', 2, 1) >>> M21, M22 = Normal('M21', 3, 1), Normal('M22', 4, 1) >>> x1 = Matrix([[N11, N12], [N21, N22]]) >>> x2 = Matrix([[M11, M12], [M21, M22]]) >>> ExpectationMatrix(x1 + x2).doit() Matrix([ [12, 14], [24, 26]])
- class sympy.stats.VarianceMatrix(arg, condition=None)[源代码]#
Variance of a random matrix probability expression. Also known as Covariance matrix, auto-covariance matrix, dispersion matrix, or variance-covariance matrix.
实例
>>> from sympy.stats import VarianceMatrix >>> from sympy.stats.rv import RandomMatrixSymbol >>> from sympy import symbols, MatrixSymbol >>> k = symbols("k") >>> A, B = MatrixSymbol("A", k, k), MatrixSymbol("B", k, k) >>> X, Y = RandomMatrixSymbol("X", k, 1), RandomMatrixSymbol("Y", k, 1) >>> VarianceMatrix(X) VarianceMatrix(X) >>> VarianceMatrix(X).shape (k, k)
要扩展表达式中的方差，请使用
expand()：>>> VarianceMatrix(A*X).expand() A*VarianceMatrix(X)*A.T >>> VarianceMatrix(A*X + B*Y).expand() 2*A*CrossCovarianceMatrix(X, Y)*B.T + A*VarianceMatrix(X)*A.T + B*VarianceMatrix(Y)*B.T
- class sympy.stats.CrossCovarianceMatrix(arg1, arg2, condition=None)[源代码]#
随机矩阵概率表达式的协方差。
实例
>>> from sympy.stats import CrossCovarianceMatrix >>> from sympy.stats.rv import RandomMatrixSymbol >>> from sympy import symbols, MatrixSymbol >>> k = symbols("k") >>> A, B = MatrixSymbol("A", k, k), MatrixSymbol("B", k, k) >>> C, D = MatrixSymbol("C", k, k), MatrixSymbol("D", k, k) >>> X, Y = RandomMatrixSymbol("X", k, 1), RandomMatrixSymbol("Y", k, 1) >>> Z, W = RandomMatrixSymbol("Z", k, 1), RandomMatrixSymbol("W", k, 1) >>> CrossCovarianceMatrix(X, Y) CrossCovarianceMatrix(X, Y) >>> CrossCovarianceMatrix(X, Y).shape (k, k)
若要在其表达式中展开协方差，请使用
expand()：>>> CrossCovarianceMatrix(X + Y, Z).expand() CrossCovarianceMatrix(X, Z) + CrossCovarianceMatrix(Y, Z) >>> CrossCovarianceMatrix(A*X, Y).expand() A*CrossCovarianceMatrix(X, Y) >>> CrossCovarianceMatrix(A*X, B.T*Y).expand() A*CrossCovarianceMatrix(X, Y)*B >>> CrossCovarianceMatrix(A*X + B*Y, C.T*Z + D.T*W).expand() A*CrossCovarianceMatrix(X, W)*D + A*CrossCovarianceMatrix(X, Z)*C + B*CrossCovarianceMatrix(Y, W)*D + B*CrossCovarianceMatrix(Y, Z)*C
机械#
SymPy Stats使用相对复杂的类层次结构。
RandomDomain s是变量到可能值的映射。例如，我们可以说 Symbol('x') 可以接受价值观 \(\{{1,2,3,4,5,6\}}\) .
A PSpace ，或概率空间，将 RandomDomain 提供概率信息的密度。例如，上述区域可以通过有限密度增强 {{1:1/6, 2:1/6, 3:1/6, 4:1/6, 5:1/6, 6:1/6}} 完全定义一个名为 x .
随机符号表示PSpace在SymPy表达式中的符号“x”。
RandomDomain和PSpace类几乎从不直接实例化。相反，它们是针对各种情况的子类。
随机域和pspace必须足够一般，以表示具有任意复密度的多个变量的域和空间。这种概括性通常是不必要的。相反，我们通常构建单域和单空间来表示单个、单变量的事件和过程，例如单个die或单个正态变量。
另一个常见的情况是收集一组这样的单变量随机变量。一组独立的singlepspace或singledomain可以组合在一起形成ProductDomain或ProductPSpace。例如，这些对象在表示三个掷在一起的骰子时很有用。
条件形容词是在我们向随机域或PSpace添加全局条件时添加的。一个常见的例子是三个独立的骰子，我们知道它们的和大于12。
我们进一步专门研究这些类的有限和连续版本，以表示有限（如骰子）和连续（如法线）随机变量。
此外，还有一些专门的类实现某些常见的随机变量类型。例如，有一个实现SingleFinitePSpace的DiePSpace和一个实现SingleContinuousPSpace的NormalPSpace。
- class sympy.stats.frv_types.DiePSpace#
- class sympy.stats.crv_types.NormalPSpace#
可以使用PSpace.值方法。
正如前面提到的，SymPy Stats使用了一个相对复杂的类结构。继承广泛应用于端级类的实现中。选择这种策略是为了在允许SymPy表示任意定义的随机变量和优化常见情况之间取得平衡。这使代码复杂化，但其结构仅对那些致力于将SymPy Stats扩展到其他随机变量类型的人很重要。
用户不会使用这个类结构。相反，这些机制是通过变量创建函数Die、Coin、FiniteRV、Normal、Exponential等暴露出来的。。。。它们构建适当的singlepspace并返回相应的随机变量。条件空间和乘积空间是在辛表达式的自然构造和界面函数E，给定，密度等的使用中形成的。。。。
- sympy.stats.Die()#
- sympy.stats.Normal()#
有些附加功能可能会有用。它们主要在内部使用。