统计数据¶
SymPy 统计模块
在 SymPy 语言中引入一个随机变量类型。
随机变量可以使用预构建的函数如 Normal、Exponential、Coin、Die 等… 或者使用 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)[源代码][源代码]¶
创建一个表示输入集上均匀分布的有限随机变量。
- 参数:
- 项目列表/元组
要进行均匀分布的物品
- 返回:
- 随机符号
参考文献
示例
>>> 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)[源代码][源代码]¶
创建一个表示公平骰子的有限随机变量。
- 参数:
- 侧面整数
表示骰子的面数，默认是6
- 返回:
- 随机符号
示例
>>> 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)[源代码][源代码]¶
创建一个表示伯努利过程的有限随机变量。
- 参数:
- p0 和 1 之间的有理数
表示成功的概率
- succ整数/符号/字符串
表示成功的事件
- 失败整数/符号/字符串
表示失败的事件
- 返回:
- 随机符号
参考文献
示例
>>> 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)[源代码][源代码]¶
创建一个表示抛硬币的有限随机变量。
这是一个伯努利随机变量的等价物，其中“H”和“T”分别作为成功和失败事件。
- 参数:
- p0 和 1 之间的有理数
表示得到“正面”的概率，默认是二分之一
- 返回:
- 随机符号
参考文献
示例
>>> 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正整数
表示试验次数
- p0 和 1 之间的有理数
表示成功的概率
- succ整数/符号/字符串
表示成功的事件，默认值为 1
- 失败整数/符号/字符串
表示失败的事件，默认值为 0
- 返回:
- 随机符号
参考文献
示例
>>> 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)[源代码][源代码]¶
创建一个表示 Beta-二项分布 的有限随机变量。
- 参数:
- n正整数
表示试验次数
- alpha实正数
- beta实正数
- 返回:
- 随机符号
参考文献
示例
>>> 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正整数
表示抽取的次数。
- 返回:
- 随机符号
参考文献
示例
>>> 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
包含有限分布概率密度函数的字典
- 检查布尔
如果为 True，它将检查给定的密度是否在给定集合上积分为 1。如果为 False，则不会执行此检查。默认为 False。
- 返回:
- 随机符号
示例
>>> 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)[源代码][源代码]¶
创建一个具有几何分布的离散随机变量。
- 参数:
- p0 到 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) (4/5)**(z - 1)/5
>>> E(X) 5
>>> variance(X) 20
- sympy.stats.Hermite(name, a1, a2)[源代码][源代码]¶
创建一个具有 Hermite 分布的离散随机变量。
- 参数:
- a1一个大于等于0的正数。
- a2一个大于等于0的正数。
- 返回:
- 随机符号
参考文献
[1]示例
>>> 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正数，一个比率
- 返回:
- 随机符号
参考文献
示例
>>> 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一个介于 0 和 1 之间的值
- 返回:
- 随机符号
参考文献
[1]示例
>>> 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正值
- p一个介于 0 和 1 之间的值
- 返回:
- 随机符号
参考文献
[1][2]https://mathworld.wolfram.com/负二项分布.html
示例
>>> 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非负值
- mu2非负值
- 返回:
- 随机符号
参考文献
示例
>>> 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正值
- 返回:
- 随机符号
参考文献
示例
>>> 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大于1的值
- 返回:
- 随机符号
参考文献
[1]示例
>>> 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实数，右区间边界
- 返回:
- 随机符号
参考文献
示例
>>> 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 分布的连续随机变量。
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 : 实数, \(\alpha > 0\), 形状参数实数,
- beta : 实数, \(\beta > 0\), 形状参数实数,
- sigma : 实数, \(\sigma > 0\), 一个尺度实数,
- 返回:
- 随机符号
参考文献
示例
>>> 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)[源代码][源代码]¶
创建一个具有 Beta 分布的连续随机变量。
Beta 分布的密度由以下公式给出
\[f(x) := \frac{x^{\alpha-1}(1-x)^{\beta-1}} {\mathrm{B}(\alpha,\beta)}\]其中 \(x \in [0,1]\)。
- 参数:
- alpha : 实数, \(\alpha > 0\), 形状参数实数,
- beta : 实数, \(\beta > 0\), 形状参数实数,
- 返回:
- 随机符号
参考文献
示例
>>> 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)[源代码][源代码]¶
创建一个具有第一类非中心贝塔分布的连续随机变量。
非中心Beta分布的密度由以下公式给出
\[f(x) := \sum_{k=0}^\infty e^{-\lambda/2}\frac{(\lambda/2)^k}{k!} \frac{x^{\alpha+k-1}(1-x)^{\beta-1}}{\mathrm{B}(\alpha+k,\beta)}\]其中 \(x \in [0,1]\)。
- 参数:
- alpha : 实数, \(\alpha > 0\), 形状参数实数,
- beta : 实数, \(\beta > 0\), 形状参数实数,
- lamda : 实数, \(\lambda \geq 0\), 非中心性参数实数,
- 返回:
- 随机符号
参考文献
[1]https://en.wikipedia.org/wiki/非中心贝塔分布
示例
>>> 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
使用特定的 ‘x’, ‘alpha’, ‘beta’ 和 ‘lamda’ 值计算 cdf，如下所示：
>>> cdf(BetaNoncentral("x", 1, 1, 1), evaluate=False)(2).doit() 2*exp(1/2)
参数 evaluate=False 防止在传递参数 2 之前对一般 x 的和进行求值尝试。
- sympy.stats.BetaPrime(name, alpha, beta)[源代码][源代码]¶
创建一个具有 Beta 素分布的连续随机变量。
Beta prime 分布的密度由以下公式给出
\[f(x) := \frac{x^{\alpha-1} (1+x)^{-\alpha -\beta}}{B(\alpha,\beta)}\]在 \(x > 0\) 的情况下。
- 参数:
- alpha : 实数, \(\alpha > 0\), 形状参数实数,
- beta : 实数, \(\beta > 0\), 形状参数实数,
- 返回:
- 随机符号
参考文献
示例
>>> 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)[源代码][源代码]¶
创建一个具有Bounded Pareto分布的连续随机变量。
Bounded Pareto 分布的密度由以下公式给出
\[f(x) := \frac{\alpha L^{\alpha}x^{-\alpha-1}}{1-(\frac{L}{H})^{\alpha}}\]- 参数:
- alpha : 实数, \(\alpha > 0\)实数,
形状参数
- left : 实数, \(left > 0\)实数,
位置参数
- right : 实数, \(right > left\)实数,
位置参数
- 返回:
- 随机符号
参考文献
示例
>>> 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)
- sympy.stats.Cauchy(name, x0, gamma)[源代码][源代码]¶
创建一个具有柯西分布的连续随机变量。
柯西分布的密度由以下公式给出
\[f(x) := \frac{1}{\pi \gamma [1 + {(\frac{x-x_0}{\gamma})}^2]}\]- 参数:
- x0实数，位置
- gamma : 实数, \(\gamma > 0\), 一个尺度实数,
- 返回:
- 随机符号
参考文献
示例
>>> 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 分布的密度由以下公式给出
\[f(x) := \frac{2^{1-k/2}x^{k-1}e^{-x^2/2}}{\Gamma(k/2)}\]其中 \(x \geq 0\)。
- 参数:
- k正整数，自由度的数量
- 返回:
- 随机符号
参考文献
示例
>>> 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)[源代码][源代码]¶
创建一个具有非中心卡方分布的连续随机变量。
- 参数:
- k一个正整数，\(k > 0\)
自由度的数量。
- lambda : 实数, \(\lambda > 0\)实数,
Shift 参数。
- 返回:
- 随机符号
参考文献
示例
>>> 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正整数
自由度的数量。
- 返回:
- 随机符号
参考文献
示例
>>> 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实数
\(p > 0\), 一个形状。
- a实数
\(a > 0\), 一个形状。
- b实数
\(b > 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)[源代码][源代码]¶
创建一个具有 Davis 分布的连续随机变量。
- 参数:
- b实数
\(p > 0\), 一个尺度。
- n实数
\(n > 1\), 一个形状。
- mu实数
\(mu > 0\), 一个位置。
- 返回:
- 随机符号
参考文献
示例
>>> 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\), 速率实数,
- 返回:
- 随机符号
参考文献
示例
>>> 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）分布的连续随机变量。
- 参数:
- 名称一个字符串，用于为此分布指定名称
- 平均实数，高斯分量的均值
- 标准一个正实数，
- 数学:
\(\sigma^2 > 0\) 高斯分量的方差
- 速率一个正实数，
- 数学:
\(\lambda > 0\) 指数分量的速率
- 返回:
- 随机符号
参考文献
示例
>>> 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\), 表示速率（或逆尺度/逆均值）一个正实数，
- 返回:
- 随机符号
参考文献
[2]https://mathworld.wolfram.com/指数分布.html
示例
>>> 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\)，其中 \(d_1\) 是自由度 (\(n_1 - 1\))d_1 > 0，其中 d_1 是自由度 (n_1 - 1)
- d2 : \(d_2 > 0\), 其中 \(d_2\) 是自由度 (\(n_2 - 1\))d_2 > 0，其中 d_2 是自由度 (n_2 - 1)
- 返回:
- 随机符号
参考文献
示例
>>> 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’s Z 分布的连续随机变量。
- 参数:
- d1\(d_1 > 0\)
自由度。
- d2\(d_2 > 0\)
自由度。
- 返回:
- 随机符号
参考文献
示例
>>> 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 : 实数, \(a \in \left(0, \infty\right)\) 形状实数,
- s : 实数, \(s \in \left(0, \infty\right)\) 尺度实数,
- m : 实数, \(m \in \left(-\infty, \infty\right)\) 最小值实数,
- 返回:
- 随机符号
参考文献
示例
>>> 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 : 实数, \(\theta > 0\), 一个尺度实数,
- 返回:
- 随机符号
参考文献
示例
>>> 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)[源代码][源代码]¶
创建一个具有逆Gamma分布的连续随机变量。
- 参数:
- a : 实数, \(a > 0\), 形状实数,
- b : 实数, \(b > 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 : 实数, \(\eta > 0\), 形状实数,
- 返回:
- 随机符号
参考文献
示例
>>> 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 : 实数, \(\mu\), 一个位置实数,
- beta : 实数, \(\beta > 0\), 一个尺度实数,
- minimum : 布尔值, 默认为
False, 设置为True以启用最小化分发布尔值，默认情况下
- 返回:
- 随机符号
参考文献
示例
>>> 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))
- sympy.stats.Kumaraswamy(name, a, b)[源代码][源代码]¶
创建一个具有Kumaraswamy分布的连续随机变量。
- 参数:
- a : 实数, \(a > 0\), 形状实数,
- b : 实数, \(b > 0\), 形状实数,
- 返回:
- 随机符号
参考文献
示例
>>> 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实数或正定矩阵，表示一个尺度
或协方差矩阵。
- 返回:
- 随机符号
参考文献
[2]https://mathworld.wolfram.com/拉普拉斯分布.html
示例
>>> 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实数
位置参数。
- c : 实数, \(c > 0\)实数,
一个尺度参数。
- 返回:
- 随机符号
参考文献
示例
>>> 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 : 实数, \(s > 0\), 一个尺度实数,
- 返回:
- 随机符号
参考文献
示例
>>> 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)[源代码][源代码]¶
创建一个具有对数逻辑分布的连续随机变量。当
beta > 1时，分布是单峰的。- 参数:
- alpha : 实数, \(\alpha > 0\), 尺度参数和分布的中位数实数,
- beta : 实数, \(\beta > 0\), 形状参数实数,
- 返回:
- 随机符号
参考文献
示例
>>> 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实数
对数刻度
- sigma实数
一个形状。（\(\sigma^2 > 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 : 实数, \(\alpha > 0\)实数,
形状参数
- lamda : 实数, \(\lambda > 0\)实数,
缩放参数
- 返回:
- 随机符号
参考文献
示例
>>> 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\)实数,
- 返回:
- 随机符号
参考文献
示例
>>> 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)[源代码][源代码]¶
创建一个具有 Moyal 分布的连续随机变量。
- 参数:
- mu实数
位置参数
- sigma实正数
缩放参数
- 返回:
- 随机符号
参考文献
示例
>>> 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 : 实数, \(\mu \geq \frac{1}{2}\), 形状实数,
- omega : 实数, \(\omega > 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实数或正定方阵，
\(\sigma^2 > 0\), 方差
- 返回:
- 随机符号
参考文献
示例
>>> 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 : 实数, \(\alpha > 0\), 形状参数实数,
- 返回:
- 随机符号
参考文献
示例
>>> 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)[源代码][源代码]¶
创建一个具有幂函数分布的连续随机变量。
- 参数:
- alpha : 正数, \(0 < \alpha\), 形状参数正数,
- a : 实数, \(-\infty < a\), 左边界实数,
- b : 实数，\(a < b < \infty\)，右边界实数,
- 返回:
- 随机符号
参考文献
示例
>>> 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-quadratic 分布的连续随机变量。
- 参数:
- a实数
- b : 实数, \(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\)实数,
- 返回:
- 随机符号
参考文献
示例
>>> 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 : 实数, \(\sigma > 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 : 实数, \(0 < a\)实数,
- b : 实数, \(a < b\)实数,
- 返回:
- 随机符号
示例
>>> 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\), 自由度实数,
- 返回:
- 随机符号
参考文献
示例
>>> 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 : 实数, \(\eta > 0\), 形状实数,
- 返回:
- 随机符号
参考文献
[1]https://en.wikipedia.org/wiki/Shifted_Gompertz_分布
示例
>>> 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 : 实数, \(a < d\)实数,
- b : 实数, \(a \le b < c\)实数,
- c : 实数, \(b < c \le d\)实数,
- d实数
- 返回:
- 随机符号
参考文献
示例
>>> 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 : 实数, \(a \in \left(-\infty, \infty\right)\)实数,
- b : 实数, \(a < b\)实数,
- c : 实数, \(a \leq c \leq b\)实数,
- 返回:
- 随机符号
参考文献
示例
>>> 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 : 实数, \(-\infty < a\), 左边界实数,
- b : 实数，\(a < b < \infty\)，右边界实数,
- 返回:
- 随机符号
参考文献
示例
>>> 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)[源代码][源代码]¶
创建一个具有 Irwin-Hall 分布的连续随机变量。
- 参数:
- n : 一个正整数, \(n > 0\)一个正整数，
- 返回:
- 随机符号
参考文献
示例
>>> 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实数
位置的度量。
- k实数
浓度测量。
- 返回:
- 随机符号
参考文献
[1]https://en.wikipedia.org/wiki/Von_Mises_分布
示例
>>> 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
表示均值的正数。
- lambda
表示形状参数的正数。
- 返回:
- 随机符号
参考文献
示例
>>> 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 : 实数, \(\lambda > 0\), 一个尺度实数，\(\lambda > 0\)，一个尺度
- k实数，\(k > 0\)，一个形状
- 返回:
- 随机符号
参考文献
示例
>>> 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\)，半径实数,
- 返回:
- 一个随机符号。
参考文献
[1]https://en.wikipedia.org/wiki/Wigner_半圆分布
示例
>>> 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/Interval
表示pdf有效的区域，默认是实线。
- 检查布尔
如果为 True，它将检查给定的密度是否在给定集合上积分为 1。如果为 False，则不会执行此检查。默认为 False。
- 返回:
- 随机符号
- 许多常见的连续随机变量类型已经实现。
- 这个函数应该只在极少数情况下是必要的。
示例
>>> 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)[源代码][源代码]¶
创建一个联合随机变量，其中每个分量都是连续的，给定以下内容：
- 参数:
- 符号符号
表示随机变量的名称。
- pdf在给定符号的索引符号意义上的PDF
作为第一个参数
- 返回:
- 随机符号
示例
>>> 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具有联合概率分布的随机变量。
- 索引组件索引或索引随机符号
计算其联合分布
- 返回:
- \(sym\) 中的 Lambda 表达式
示例
>>> 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正半定方阵
表示协方差矩阵。如果 \(\sigma\) 不可逆，则目前仅支持采样。
- 返回:
- 随机符号
参考文献
示例
>>> 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))
下面的示例展示了也可以使用符号参数来定义 MultivariateNormal 类。
>>> 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)
多元正态分布的密度可以通过矩阵参数计算，如下所示。
>>> 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表示均值或均值向量的列表
- sigma正定方阵
表示协方差矩阵
- 返回:
- 随机符号
参考文献
示例
>>> 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用于标识每个组件的符号列表/元组/集合
- delta范围 \([0, 1]\) 内的一个常数
- v正实数
- lamda正实数列表
- mu正实数列表
- 返回:
- 随机符号
参考文献
[1]https://en.wikipedia.org/wiki/广义多元对数伽玛分布
[2]https://www.researchgate.net/publication/234137346_关于多元对数伽马分布及其在贝叶斯分析中的应用
示例
>>> 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
- sympy.stats.GeneralizedMultivariateLogGammaOmega(
- syms,
- omega,
- v,
- lamda,
- mu,
扩展 GeneralizedMultivariateLogGamma。
- 参数:
- syms符号的列表/元组/集合
用于识别每个组件
- omega方阵
方阵的每个元素必须是相关系数的平方根的绝对值
- v正实数
- lamda正实数列表
- mu正实数列表
- 返回:
- 随机符号
注释
如果 GeneralizedMultivariateLogGammaOmega 太长难以输入，
>>> from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGammaOmega as GMVLGO >>> G = GMVLGO('G', omega, v, l, mu)
参考文献
[1]https://en.wikipedia.org/wiki/广义多元对数伽玛分布
[2]https://www.researchgate.net/publication/234137346_关于多元对数伽马分布及其在贝叶斯分析中的应用
示例
>>> 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
- sympy.stats.Multinomial(syms, n, *p)[源代码][源代码]¶
创建一个具有多项分布的离散随机变量。
所述分布的密度可以在 [1] 中找到。
- 参数:
- n正整数
表示试验次数
- p事件概率列表
必须在 \([0, 1]\) 范围内。
- 返回:
- 随机符号
参考文献
示例
>>> 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 分布的连续随机变量。
Dirichlet 分布的密度可以在 [1] 中找到。
- 参数:
- alpha正实数
表示浓度数值。
- 返回:
- 随机符号
参考文献
[1]示例
>>> 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正整数
样本的大小或考虑其分区的整数
- theta正实数
表示突变率
- 返回:
- 随机符号
参考文献
示例
>>> 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一个符号/字符串
用于识别随机变量。
- mu列表/矩阵
表示位置向量
- sigma分布的形状矩阵
- 返回:
- 随机符号
示例
>>> 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正整数
表示在实验停止之前的失败次数
- p事件概率列表
必须在 \([0, 1]\) 范围内
- 返回:
- 随机符号
参考文献
[2]https://mathworld.wolfram.com/负二项分布.html
示例
>>> 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一个符号/字符串
用于识别随机变量。
- mu实数
正态分布的均值
- lamda一个正整数
联合分布的参数
- alpha一个正整数
联合分布的参数
- beta一个正整数
联合分布的参数
- 返回:
- 随机符号
参考文献
示例
>>> 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,
表示一个有限离散时间齐次马尔可夫链。
这种类型的马尔可夫链可以通过其（有序的）状态空间和一步转移概率矩阵唯一地表征。
- 参数:
- sym:
马尔可夫链的名称
- 状态空间:
可选，默认情况下，Range(n)
- trans_probs:
可选的，默认情况下，MatrixSymbol(‘_T’, n, n)
- 属性:
args返回 ‘self’ 的参数元组。
assumptions0返回对象 \(type\) 假设。
canonical_variables返回一个字典，将
self.bound_symbols中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。- expr_free_symbols
free_symbols从自身的原子中返回那些自由符号。
func表达式中的顶级函数。
- is_algebraic
- is_antihermitian
- is_commutative
is_comparable如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
- is_complex
- is_composite
- is_even
- is_extended_negative
- is_extended_nonnegative
- is_extended_nonpositive
- is_extended_nonzero
- is_extended_positive
- is_extended_real
- is_finite
- is_hermitian
- is_imaginary
- is_infinite
- is_integer
- is_irrational
- is_negative
- is_noninteger
- is_nonnegative
- is_nonpositive
- is_nonzero
- is_odd
- is_polar
- is_positive
- is_prime
- is_rational
- is_real
- is_transcendental
- is_zero
limiting_distribution固定行向量是离散马尔可夫链的极限分布。
number_of_states马尔可夫链中的状态数。
- 状态空间
- 符号
transition_probabilities离散马尔可夫链的转移概率，可以是 Matrix 或 MatrixSymbol 的实例。
方法
__call__(time)在 ContinuousTimeStochasticProcess 中被重写。
计算吸收概率，即矩阵的第 ij 项表示从状态 i 开始，马尔可夫链被吸收到状态 j 的概率。
as_content_primitive([radical, clear])一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
as_dummy()返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
atoms(*types)返回构成当前对象的原子。
重新排列一步转移矩阵，使得递归状态首先出现，瞬态状态最后出现。
class_key()类的好顺序。
返回划分马尔可夫链状态的通信类列表。
compare(other)如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
count(query)计算匹配的子表达式的数量。
count_ops([visual])用于返回操作计数的 count_ops 的包装器。
将转移矩阵分解为具有特殊性质的子矩阵。
doit(**hints)评估默认情况下不评估的对象，如极限、积分、求和和乘积。
dummy_eq(other[, symbol])比较两个表达式并处理哑符号。
expectation(expr[, condition, evaluate])处理马尔可夫过程的期望查询。
find(query[, group])查找所有匹配查询的子表达式。
stationary_distribution()的封装。fromiter(args, **assumptions)从可迭代对象创建一个新对象。
每个基本矩阵的条目可以解释为如果链从状态 i 开始，它在状态 j 中的预期次数。
has(*patterns)测试是否有任何子表达式匹配任何模式。
has_free(*patterns)如果 self 包含对象
x作为自由表达式，则返回 True，否则返回 False。has_xfree(s)如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
is_same(b[, approx])如果 a 和 b 结构相同则返回 True，否则返回 False。
joint_distribution(*args)计算随机索引变量的联合分布。
match(pattern[, old])模式匹配。
matches(expr[, repl_dict, old])用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
probability(condition[, given_condition, ...])处理马尔可夫过程的概率查询。
rcall(*args)通过表达式树递归应用于参数。
refine([assumption])请参阅 sympy.assumptions 中的 refine 函数。
replace(query, value[, map, simultaneous, exact])将
self中匹配的子表达式替换为value。rewrite(*args[, deep])使用定义的规则重写 self。
sample()simplify(**kwargs)请参阅 sympy.simplify 中的 simplify 函数。
sort_key([order])返回一个排序键。
stationary_distribution([condition_set])平稳分布是任何行向量 p，它满足 p = pP，是行随机且 p 中的每个元素必须是非负的。
subs(*args, **kwargs)在简化参数后，在表达式中用新内容替换旧内容。
xreplace(rule)替换表达式中对象的出现。
absorbing_probabilites
复制
could_extract_minus_sign
密度
分布
is_absorbing_chain
is_absorbing_state
is_ergodic
is_hypergeometric
is_regular
replace_with_index
参考文献
示例
>>> 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-Rainy 模型：
>>> 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
如果给定的条件中只有一个 RandomIndexedSymbol，则可以计算包含多个 RandomIndexedSymbol 的表达式的概率。为了防止错误，最好在转移矩阵中使用 Rational 而不是浮点数来表示概率。
>>> 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
也支持符号概率查询
>>> 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]
- canonical_form() Tuple[List[Basic], ImmutableDenseMatrix][源代码][源代码]¶
重新排列一步转移矩阵，使得递归状态首先出现，瞬态状态最后出现。其他表示方法包括首先插入瞬态状态，然后是递归状态。
- 返回:
- 状态, P_new
states是描述矩阵中新状态顺序的列表，使得states中的第 i 个元素是 A 的第 i 行的状态。P_new是规范形式中的新转移矩阵。
参考文献
示例
>>> from sympy.stats import DiscreteMarkovChain >>> from sympy import Matrix, S
你可以将你的链转换为规范形式：
>>> 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]])
新状态是 [3, 1, 2, 4, 5]，你可以用这个创建一个新的链，它的规范形式将保持不变（因为它已经是规范形式）。
>>> 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]])
这不仅限于吸收链条：
>>> 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]][源代码][源代码]¶
返回划分马尔可夫链状态的通信类列表。
通信类被定义为一组状态，使得该组中的每个状态都可以从该组中的其他每个状态到达。由于其特性，这在数学意义上形成了一个类。通信类也被称为循环类。
- 返回:
- 类
classes是一个元组列表。每个元组代表一个具有其属性的单一通信类。元组中的第一个元素是类中的状态列表，第二个元素是该类是否是循环的，第三个元素是通信类的周期。
注释
所使用的算法是
O(n**2)阶的，其中n是马尔可夫链中的状态数。它使用 Tarjan 算法来找到这些类本身，然后使用广度优先搜索算法来找到每个类的周期性。随着矩阵变得越来越稀疏，算法的多数组件接近O(n)。参考文献
示例
>>> 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)
由此我们可以看出，状态
1和2是互通的、递归的，并且周期为 2。我们还可以看到状态3是暂时的，周期为 1。
- decompose() Tuple[List[Basic], ImmutableDenseMatrix, ImmutableDenseMatrix, ImmutableDenseMatrix][源代码][源代码]¶
将转移矩阵分解为具有特殊性质的子矩阵。
转移矩阵可以分解为4个子矩阵：- A - 从循环状态到循环状态的子矩阵。- B - 从瞬态到循环状态的子矩阵。- C - 从瞬态到瞬态状态的子矩阵。- O - 循环状态到瞬态状态的零子矩阵。
- 返回:
- 状态, A, B, C
states- 一个状态名称列表，第一个是循环状态，最后一个是瞬态状态，顺序与A的行名称和C的行名称相同。A- 从循环状态到循环状态的子矩阵。B- 从瞬态到循环状态的子矩阵。C- 从瞬态到瞬态状态的子矩阵。
参见
参考文献
示例
>>> from sympy.stats import DiscreteMarkovChain >>> from sympy import Matrix, S
可以分解这个链，例如：
>>> 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]])
这意味着状态2是唯一的吸收状态（因为A是一个1x1矩阵）。B是一个4x1矩阵，因为剩下的4个瞬态状态都合并到循环状态2中。C是4x4矩阵，显示了瞬态状态0、1、3、4之间的相互作用。
- property limiting_distribution¶
固定行向量是离散马尔可夫链的极限分布。
- stationary_distribution(
- condition_set=False,
平稳分布是任意行向量 ( p )，满足 ( p = pP )，且 ( p ) 是行随机矩阵，并且 ( p ) 中的每个元素必须为非负。这意味着在矩阵形式中： \((P-I)^T p^T = 0\) 和 \((1, \dots, 1) p = 1\)，其中
P是单步转移矩阵。所有具有有限状态空间的时间齐次马尔可夫链至少有一个平稳分布。此外，如果一个有限时间齐次马尔可夫链是不可约的，那么平稳分布是唯一的。
- 参数:
- condition_set布尔
如果链具有符号大小或转移矩阵，则如果为
False则返回Lambda，如果为True则返回ConditionSet。
参考文献
示例
>>> from sympy.stats import DiscreteMarkovChain >>> from sympy import Matrix, S
不可约马尔可夫链
>>> 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]])
一个可约马尔可夫链
>>> 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¶
离散马尔可夫链的转移概率，可以是 Matrix 或 MatrixSymbol 的实例。
- class sympy.stats.ContinuousMarkovChain(
- sym,
- state_space=None,
- gen_mat=None,
表示连续时间马尔可夫链。
- 参数:
- sym符号/字符串
- 状态空间设置
可选，默认情况下，S.Reals
- gen_mat矩阵/不可变矩阵/矩阵符号
可选，默认情况下，无
- 属性:
args返回 ‘self’ 的参数元组。
assumptions0返回对象 \(type\) 假设。
canonical_variables返回一个字典，将
self.bound_symbols中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。- expr_free_symbols
free_symbols从自身的原子中返回那些自由符号。
func表达式中的顶级函数。
- 生成矩阵
- is_algebraic
- is_antihermitian
- is_commutative
is_comparable如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
- is_complex
- is_composite
- is_even
- is_extended_negative
- is_extended_nonnegative
- is_extended_nonpositive
- is_extended_nonzero
- is_extended_positive
- is_extended_real
- is_finite
- is_hermitian
- is_imaginary
- is_infinite
- is_integer
- is_irrational
- is_negative
- is_noninteger
- is_nonnegative
- is_nonpositive
- is_nonzero
- is_odd
- is_polar
- is_positive
- is_prime
- is_rational
- is_real
- is_transcendental
- is_zero
number_of_states马尔可夫链中的状态数。
- 状态空间
- 符号
方法
__call__(time)用于索引连续时间随机过程。
as_content_primitive([radical, clear])一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
as_dummy()返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
atoms(*types)返回构成当前对象的原子。
class_key()类的好顺序。
compare(other)如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
count(query)计算匹配的子表达式的数量。
count_ops([visual])用于返回操作计数的 count_ops 的包装器。
doit(**hints)评估默认情况下不评估的对象，如极限、积分、求和和乘积。
dummy_eq(other[, symbol])比较两个表达式并处理哑符号。
expectation(expr[, condition, evaluate])处理马尔可夫过程的期望查询。
find(query[, group])查找所有匹配查询的子表达式。
fromiter(args, **assumptions)从可迭代对象创建一个新对象。
has(*patterns)测试是否有任何子表达式匹配任何模式。
has_free(*patterns)如果 self 包含对象
x作为自由表达式，则返回 True，否则返回 False。has_xfree(s)如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
is_same(b[, approx])如果 a 和 b 结构相同则返回 True，否则返回 False。
joint_distribution(*args)计算随机索引变量的联合分布。
match(pattern[, old])模式匹配。
matches(expr[, repl_dict, old])用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
probability(condition[, given_condition, ...])处理马尔可夫过程的概率查询。
rcall(*args)通过表达式树递归应用于参数。
refine([assumption])请参阅 sympy.assumptions 中的 refine 函数。
replace(query, value[, map, simultaneous, exact])将
self中匹配的子表达式替换为value。rewrite(*args[, deep])使用定义的规则重写 self。
simplify(**kwargs)请参阅 sympy.simplify 中的 simplify 函数。
sort_key([order])返回一个排序键。
subs(*args, **kwargs)在简化参数后，在表达式中用新内容替换旧内容。
xreplace(rule)替换表达式中对象的出现。
复制
could_extract_minus_sign
密度
分布
is_hypergeometric
limiting_distribution
replace_with_index
示例
transition_probabilities
参考文献
示例
>>> 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]])
支持概率查询
>>> 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
在给定条件中只有一个 RandomIndexedSymbol 的情况下，也可以计算包含多个 RandomIndexedSymbol 的表达式的概率。在生成矩阵中使用 Rational 而不是浮点数来表示概率总是更好的，以避免错误。
>>> 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
也支持符号概率查询
>>> 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
- class sympy.stats.BernoulliProcess(sym, p, success=1, failure=0)[源代码][源代码]¶
伯努利过程由具有相同参数 \(p\) 的重复独立伯努利试验组成。假设概率 \(p\) 适用于每一次试验，并且每次试验的结果与所有其他试验的结果无关。因此，伯努利过程是离散状态和离散时间的随机过程。
- 参数:
- sym符号/字符串
- 成功整数/字符串
被视为成功的事件。默认值：1。
- 失败: 整数/字符串
被视为失败的event。默认值：0。
- p介于 0 和 1 之间的实数
表示获得成功的概率。
- 属性:
args返回 ‘self’ 的参数元组。
assumptions0返回对象 \(type\) 假设。
canonical_variables返回一个字典，将
self.bound_symbols中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。- expr_free_symbols
- 失败
free_symbols从自身的原子中返回那些自由符号。
func表达式中的顶级函数。
- is_algebraic
- is_antihermitian
- is_commutative
is_comparable如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
- is_complex
- is_composite
- is_even
- is_extended_negative
- is_extended_nonnegative
- is_extended_nonpositive
- is_extended_nonzero
- is_extended_positive
- is_extended_real
- is_finite
- is_hermitian
- is_imaginary
- is_infinite
- is_integer
- is_irrational
- is_negative
- is_noninteger
- is_nonnegative
- is_nonpositive
- is_nonzero
- is_odd
- is_polar
- is_positive
- is_prime
- is_rational
- is_real
- is_transcendental
- is_zero
- p
- 状态空间
- 成功
- 符号
方法
__call__(time)在 ContinuousTimeStochasticProcess 中被重写。
as_content_primitive([radical, clear])一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
as_dummy()返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
atoms(*types)返回构成当前对象的原子。
class_key()类的好顺序。
compare(other)如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
count(query)计算匹配的子表达式的数量。
count_ops([visual])用于返回操作计数的 count_ops 的包装器。
doit(**hints)评估默认情况下不评估的对象，如极限、积分、求和和乘积。
dummy_eq(other[, symbol])比较两个表达式并处理哑符号。
expectation(expr[, condition, evaluate])计算期望值。
find(query[, group])查找所有匹配查询的子表达式。
fromiter(args, **assumptions)从可迭代对象创建一个新对象。
has(*patterns)测试是否有任何子表达式匹配任何模式。
has_free(*patterns)如果 self 包含对象
x作为自由表达式，则返回 True，否则返回 False。has_xfree(s)如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
is_same(b[, approx])如果 a 和 b 结构相同则返回 True，否则返回 False。
joint_distribution(*args)计算随机索引变量的联合分布。
match(pattern[, old])模式匹配。
matches(expr[, repl_dict, old])用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
probability(condition[, given_condition, ...])计算概率。
rcall(*args)通过表达式树递归应用于参数。
refine([assumption])请参阅 sympy.assumptions 中的 refine 函数。
replace(query, value[, map, simultaneous, exact])将
self中匹配的子表达式替换为value。rewrite(*args[, deep])使用定义的规则重写 self。
simplify(**kwargs)请参阅 sympy.simplify 中的 simplify 函数。
sort_key([order])返回一个排序键。
subs(*args, **kwargs)在简化参数后，在表达式中用新内容替换旧内容。
xreplace(rule)替换表达式中对象的出现。
复制
could_extract_minus_sign
密度
分布
is_hypergeometric
示例
simple_rv
参考文献
示例
>>> 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
- class sympy.stats.PoissonProcess(sym, lamda)[源代码][源代码]¶
泊松过程是一个计数过程。它通常用于我们以一定速率计数某些事件发生的场景，但这些事件是完全随机发生的。
- 参数:
- sym符号/字符串
- lamda正数
过程的速率，
lambda > 0
- 属性:
args返回 ‘self’ 的参数元组。
assumptions0返回对象 \(type\) 假设。
canonical_variables返回一个字典，将
self.bound_symbols中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。- expr_free_symbols
free_symbols从自身的原子中返回那些自由符号。
func表达式中的顶级函数。
- is_algebraic
- is_antihermitian
- is_commutative
is_comparable如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
- is_complex
- is_composite
- is_even
- is_extended_negative
- is_extended_nonnegative
- is_extended_nonpositive
- is_extended_nonzero
- is_extended_positive
- is_extended_real
- is_finite
- is_hermitian
- is_imaginary
- is_infinite
- is_integer
- is_irrational
- is_negative
- is_noninteger
- is_nonnegative
- is_nonpositive
- is_nonzero
- is_odd
- is_polar
- is_positive
- is_prime
- is_rational
- is_real
- is_transcendental
- is_zero
- lamda
- 状态空间
- 符号
方法
__call__(time)用于索引连续时间随机过程。
as_content_primitive([radical, clear])一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
as_dummy()返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
atoms(*types)返回构成当前对象的原子。
class_key()类的好顺序。
compare(other)如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
count(query)计算匹配的子表达式的数量。
count_ops([visual])用于返回操作计数的 count_ops 的包装器。
doit(**hints)评估默认情况下不评估的对象，如极限、积分、求和和乘积。
dummy_eq(other[, symbol])比较两个表达式并处理哑符号。
expectation(expr[, condition, evaluate])计算期望值
find(query[, group])查找所有匹配查询的子表达式。
fromiter(args, **assumptions)从可迭代对象创建一个新对象。
has(*patterns)测试是否有任何子表达式匹配任何模式。
has_free(*patterns)如果 self 包含对象
x作为自由表达式，则返回 True，否则返回 False。has_xfree(s)如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
is_same(b[, approx])如果 a 和 b 结构相同则返回 True，否则返回 False。
joint_distribution(*args)计算随机索引变量的联合分布。
match(pattern[, old])模式匹配。
matches(expr[, repl_dict, old])用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
probability(condition[, given_condition, ...])计算概率。
rcall(*args)通过表达式树递归应用于参数。
refine([assumption])请参阅 sympy.assumptions 中的 refine 函数。
replace(query, value[, map, simultaneous, exact])将
self中匹配的子表达式替换为value。rewrite(*args[, deep])使用定义的规则重写 self。
simplify(**kwargs)请参阅 sympy.simplify 中的 simplify 函数。
sort_key([order])返回一个排序键。
subs(*args, **kwargs)在简化参数后，在表达式中用新内容替换旧内容。
xreplace(rule)替换表达式中对象的出现。
复制
could_extract_minus_sign
密度
分布
is_hypergeometric
示例
simple_rv
分割
参考文献
示例
>>> 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
将一个泊松过程分成两个独立的泊松过程
>>> N, M = Z.split(l1=2, l2=5) >>> N.lamda, M.lamda (2, 5)
- class sympy.stats.WienerProcess(sym)[源代码][源代码]¶
维纳过程是一个实值连续时间随机过程。在物理学中，它用于研究布朗运动，并且由于其与最初由苏格兰植物学家罗伯特·布朗观察到的同名物理过程的历史联系，它通常也被称为布朗运动。
- 参数:
- sym符号/字符串
- 属性:
args返回 ‘self’ 的参数元组。
assumptions0返回对象 \(type\) 假设。
canonical_variables返回一个字典，将
self.bound_symbols中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。- expr_free_symbols
free_symbols从自身的原子中返回那些自由符号。
func表达式中的顶级函数。
- is_algebraic
- is_antihermitian
- is_commutative
is_comparable如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
- is_complex
- is_composite
- is_even
- is_extended_negative
- is_extended_nonnegative
- is_extended_nonpositive
- is_extended_nonzero
- is_extended_positive
- is_extended_real
- is_finite
- is_hermitian
- is_imaginary
- is_infinite
- is_integer
- is_irrational
- is_negative
- is_noninteger
- is_nonnegative
- is_nonpositive
- is_nonzero
- is_odd
- is_polar
- is_positive
- is_prime
- is_rational
- is_real
- is_transcendental
- is_zero
- 状态空间
- 符号
方法
__call__(time)用于索引连续时间随机过程。
as_content_primitive([radical, clear])一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
as_dummy()返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
atoms(*types)返回构成当前对象的原子。
class_key()类的好顺序。
compare(other)如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
count(query)计算匹配的子表达式的数量。
count_ops([visual])用于返回操作计数的 count_ops 的包装器。
doit(**hints)评估默认情况下不评估的对象，如极限、积分、求和和乘积。
dummy_eq(other[, symbol])比较两个表达式并处理哑符号。
expectation(expr[, condition, evaluate])计算期望值
find(query[, group])查找所有匹配查询的子表达式。
fromiter(args, **assumptions)从可迭代对象创建一个新对象。
has(*patterns)测试是否有任何子表达式匹配任何模式。
has_free(*patterns)如果 self 包含对象
x作为自由表达式，则返回 True，否则返回 False。has_xfree(s)如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
is_same(b[, approx])如果 a 和 b 结构相同则返回 True，否则返回 False。
joint_distribution(*args)计算随机索引变量的联合分布。
match(pattern[, old])模式匹配。
matches(expr[, repl_dict, old])用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
probability(condition[, given_condition, ...])计算概率。
rcall(*args)通过表达式树递归应用于参数。
refine([assumption])请参阅 sympy.assumptions 中的 refine 函数。
replace(query, value[, map, simultaneous, exact])将
self中匹配的子表达式替换为value。rewrite(*args[, deep])使用定义的规则重写 self。
simplify(**kwargs)请参阅 sympy.simplify 中的 simplify 函数。
sort_key([order])返回一个排序键。
subs(*args, **kwargs)在简化参数后，在表达式中用新内容替换旧内容。
xreplace(rule)替换表达式中对象的出现。
复制
could_extract_minus_sign
密度
分布
is_hypergeometric
示例
simple_rv
参考文献
示例
>>> 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)[源代码][源代码]¶
Gamma 过程是一个具有独立伽马分布增量的随机过程。它是一个纯跳跃的递增 Levy 过程。
- 参数:
- sym符号/字符串
- lamda正数
过程的跳跃大小，
lamda > 0- gamma正数
跳跃到达率，\(\gamma > 0\)
- 属性:
args返回 ‘self’ 的参数元组。
assumptions0返回对象 \(type\) 假设。
canonical_variables返回一个字典，将
self.bound_symbols中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。- expr_free_symbols
free_symbols从自身的原子中返回那些自由符号。
func表达式中的顶级函数。
- gamma
- is_algebraic
- is_antihermitian
- is_commutative
is_comparable如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
- is_complex
- is_composite
- is_even
- is_extended_negative
- is_extended_nonnegative
- is_extended_nonpositive
- is_extended_nonzero
- is_extended_positive
- is_extended_real
- is_finite
- is_hermitian
- is_imaginary
- is_infinite
- is_integer
- is_irrational
- is_negative
- is_noninteger
- is_nonnegative
- is_nonpositive
- is_nonzero
- is_odd
- is_polar
- is_positive
- is_prime
- is_rational
- is_real
- is_transcendental
- is_zero
- lamda
- 状态空间
- 符号
方法
__call__(time)用于索引连续时间随机过程。
as_content_primitive([radical, clear])一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
as_dummy()返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
atoms(*types)返回构成当前对象的原子。
class_key()类的好顺序。
compare(other)如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
count(query)计算匹配的子表达式的数量。
count_ops([visual])用于返回操作计数的 count_ops 的包装器。
doit(**hints)评估默认情况下不评估的对象，如极限、积分、求和和乘积。
dummy_eq(other[, symbol])比较两个表达式并处理哑符号。
expectation(expr[, condition, evaluate])计算期望值
find(query[, group])查找所有匹配查询的子表达式。
fromiter(args, **assumptions)从可迭代对象创建一个新对象。
has(*patterns)测试是否有任何子表达式匹配任何模式。
has_free(*patterns)如果 self 包含对象
x作为自由表达式，则返回 True，否则返回 False。has_xfree(s)如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
is_same(b[, approx])如果 a 和 b 结构相同则返回 True，否则返回 False。
joint_distribution(*args)计算随机索引变量的联合分布。
match(pattern[, old])模式匹配。
matches(expr[, repl_dict, old])用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
probability(condition[, given_condition, ...])计算概率。
rcall(*args)通过表达式树递归应用于参数。
refine([assumption])请参阅 sympy.assumptions 中的 refine 函数。
replace(query, value[, map, simultaneous, exact])将
self中匹配的子表达式替换为value。rewrite(*args[, deep])使用定义的规则重写 self。
simplify(**kwargs)请参阅 sympy.simplify 中的 simplify 函数。
sort_key([order])返回一个排序键。
subs(*args, **kwargs)在简化参数后，在表达式中用新内容替换旧内容。
xreplace(rule)替换表达式中对象的出现。
复制
could_extract_minus_sign
密度
分布
is_hypergeometric
示例
simple_rv
参考文献
示例
>>> 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] 中找到。
- 参数:
- alpha: 正实数
形状参数
- beta: 正实数
比例参数
- scale_matrix: 正定实数方阵
缩放矩阵
- 返回:
- 随机符号
参考文献
[1]示例
>>> 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: 正定实数方阵
缩放矩阵
- 返回:
- 随机符号
参考文献
[1]https://en.wikipedia.org/wiki/Wishart_分布
示例
>>> 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: 实数 ``n x p`` 矩阵
表示自由度
- scale_matrix_1: 正定矩阵
形状为
n x n的缩放矩阵- scale_matrix_2: 正定矩阵
形状为
p x p的缩放矩阵
- 返回:
- 随机符号
参考文献
[1]示例
>>> 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发行版
分布必须包含一个随机参数
- 属性:
args返回 ‘self’ 的参数元组。
assumptions0返回对象 \(type\) 假设。
canonical_variables返回一个字典，将
self.bound_symbols中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。- expr_free_symbols
free_symbols从自身的原子中返回那些自由符号。
func表达式中的顶级函数。
- is_Continuous
- is_Discrete
- is_Finite
- is_algebraic
- is_antihermitian
- is_commutative
is_comparable如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
- is_complex
- is_composite
- is_even
- is_extended_negative
- is_extended_nonnegative
- is_extended_nonpositive
- is_extended_nonzero
- is_extended_positive
- is_extended_real
- is_finite
- is_hermitian
- is_imaginary
- is_infinite
- is_integer
- is_irrational
- is_negative
- is_noninteger
- is_nonnegative
- is_nonpositive
- is_nonzero
- is_odd
- is_polar
- is_positive
- is_prime
- is_rational
- is_real
- is_transcendental
- is_zero
- 设置
方法
as_content_primitive([radical, clear])一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
as_dummy()返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
atoms(*types)返回构成当前对象的原子。
class_key()类的好顺序。
compare(other)如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
count(query)计算匹配的子表达式的数量。
count_ops([visual])用于返回操作计数的 count_ops 的包装器。
doit(**hints)评估默认情况下不评估的对象，如极限、积分、求和和乘积。
dummy_eq(other[, symbol])比较两个表达式并处理哑符号。
find(query[, group])查找所有匹配查询的子表达式。
fromiter(args, **assumptions)从可迭代对象创建一个新对象。
has(*patterns)测试是否有任何子表达式匹配任何模式。
has_free(*patterns)如果 self 包含对象
x作为自由表达式，则返回 True，否则返回 False。has_xfree(s)如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
is_same(b[, approx])如果 a 和 b 结构相同则返回 True，否则返回 False。
match(pattern[, old])模式匹配。
matches(expr[, repl_dict, old])用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
rcall(*args)通过表达式树递归应用于参数。
refine([assumption])请参阅 sympy.assumptions 中的 refine 函数。
replace(query, value[, map, simultaneous, exact])将
self中匹配的子表达式替换为value。rewrite(*args[, deep])使用定义的规则重写 self。
sample([size, library, seed])从分布中随机实现
simplify(**kwargs)请参阅 sympy.simplify 中的 simplify 函数。
sort_key([order])返回一个排序键。
subs(*args, **kwargs)在简化参数后，在表达式中用新内容替换旧内容。
xreplace(rule)替换表达式中对象的出现。
复制
could_extract_minus_sign
is_hypergeometric
pdf
参考文献
[1]示例
>>> 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,
一个条件为真的概率，可选地给定第二个条件。
- 参数:
- 条件包含 RandomSymbols 的关系式的组合
你想计算概率的条件
- 给定条件包含 RandomSymbols 的关系式的组合
一个条件表达式。P(X > 1, X > 0) 是在 X > 0 的条件下 X > 1 的期望值。
- numsamples整数
启用采样并使用这些样本近似概率
- 评估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)[源代码][源代码]¶
概率的符号表达式。
- 属性:
args返回 ‘self’ 的参数元组。
assumptions0返回对象 \(type\) 假设。
canonical_variables返回一个字典，将
self.bound_symbols中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。expr_free_symbols类似于
free_symbols，但仅在自由符号包含在表达式节点中时返回它们。free_symbols从自身的原子中返回那些自由符号。
func表达式中的顶级函数。
- is_algebraic
- is_antihermitian
is_comparable如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
- is_complex
- is_composite
- is_even
- is_extended_negative
- is_extended_nonnegative
- is_extended_nonpositive
- is_extended_nonzero
- is_extended_positive
- is_extended_real
- is_finite
- is_hermitian
- is_imaginary
- is_infinite
- is_integer
- is_irrational
- is_negative
- is_noninteger
- is_nonnegative
- is_nonpositive
- is_nonzero
is_number如果
self没有自由符号且没有未定义的函数（确切地说，是 AppliedUndef），则返回 True。- is_odd
- is_polar
- is_positive
- is_prime
- is_rational
- is_real
- is_transcendental
- is_zero
方法
apart([x])请参阅 sympy.polys 中的 apart 函数。
args_cnc([cset, warn, split_1])返回 [交换因子, 非交换因子] 的自身。
as_coeff_Add([rational])高效地提取求和的系数。
as_coeff_Mul([rational])高效地提取乘积的系数。
as_coeff_add(*deps)返回元组 (c, args)，其中 self 被写成一个 Add，
a。as_coeff_exponent(x)c*x**e -> c,e其中 x 可以是任何符号表达式。as_coeff_mul(*deps, **kwargs)返回元组 (c, args)，其中 self 被写成一个 Mul，
m。as_coefficient(expr)提取给定表达式中的符号系数。
as_coefficients_dict(*syms)返回一个字典，将术语映射到它们的 Rational 系数。
as_content_primitive([radical, clear])此方法应递归地从所有参数中移除一个 Rational，并返回该内容和新的 self（原始类型）。
as_dummy()返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
as_expr(*gens)将多项式转换为 SymPy 表达式。
as_independent(*deps, **hint)将 Mul 或 Add 的大部分天真分离为不依赖于 deps 的参数。
as_leading_term(*symbols[, logx, cdir])返回自身级数展开的主导（非零）项。
as_numer_denom()返回一个表达式的分子和分母。
as_ordered_factors([order])返回有序因子列表（如果是 Mul），否则返回 [self]。
as_ordered_terms([order, data])将表达式转换为有序的项列表。
as_poly(*gens, **args)将
self转换为多项式，或返回None。as_powers_dict()将自身作为一个因子的字典返回，每个因子都被视为一个幂。
as_real_imag([deep])对 'self' 执行复杂的扩展，并返回一个包含收集到的实部和虚部的元组。
as_terms()将一个表达式转换为项的列表。
aseries([x, n, bound, hir])自变量的渐近级数展开
atoms(*types)返回构成当前对象的原子。
cancel(*gens, **args)参见 sympy.polys 中的取消函数
class_key()类的好顺序。
coeff(x[, n, right, _first])返回包含
x**n的项中的系数。collect(syms[, func, evaluate, exact, ...])请参阅 sympy.simplify 中的 collect 函数。
combsimp()请参阅 sympy.simplify 中的 combsimp 函数。
compare(other)如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
compute_leading_term(x[, logx])已弃用的函数，用于计算级数的首项。
conjugate()返回 'self' 的复数共轭。
could_extract_minus_sign()如果 self 以 -1 作为前导因子，或在求和中有比正号更多的负号，则返回 True，否则返回 False。
count(query)计算匹配的子表达式的数量。
count_ops([visual])doit(**hints)dummy_eq(other[, symbol])比较两个表达式并处理哑符号。
equals(other[, failing_expression])如果 self == other 则返回 True，如果不相等则返回 False，或者返回 None。
evalf([n, subs, maxn, chop, strict, quad, ...])将给定的公式计算到 n 位精度。
expand([deep, modulus, power_base, ...])使用提示扩展表达式。
extract_additively(c)如果可以从自身减去 c 并且使所有匹配的系数趋向于零，则返回 self - c，否则返回 None。
extract_branch_factor([allow_half])尝试以
exp_polar(2*pi*I*n)*z的方式优雅地表达自身。extract_multiplicatively(c)如果无法以一种良好的方式将 self 表示为 c * something，即保留 self 参数的属性，则返回 None。
factor(*gens, **args)参见 sympy.polys.polytools 中的 factor() 函数
find(query[, group])查找所有匹配查询的子表达式。
fourier_series([limits])计算自身的傅里叶正弦/余弦级数。
fps([x, x0, dir, hyper, order, rational, full])计算自身的形式幂级数。
fromiter(args, **assumptions)从可迭代对象创建一个新对象。
gammasimp()参见 sympy.simplify 中的 gammasimp 函数
getO()如果有加法 O(..) 符号，则返回该符号，否则返回 None。
getn()返回表达式的顺序。
has(*patterns)测试是否有任何子表达式匹配任何模式。
has_free(*patterns)如果 self 包含对象
x作为自由表达式，则返回 True，否则返回 False。has_xfree(s)如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
integrate(*args, **kwargs)请参阅 sympy.integrals 中的 integrate 函数。
invert(g, *gens, **args)返回
self对g的乘法逆元，其中self``（和 ``g）可以是符号表达式。is_algebraic_expr(*syms)此测试给定的表达式是否在给定的符号 syms 中是代数的。
is_constant(*wrt, **flags)如果 self 是常量则返回 True，如果不是则返回 False，如果无法明确确定常量性则返回 None。
is_meromorphic(x, a)此测试表达式是否作为给定符号
x的函数在点a处是亚纯的。is_polynomial(*syms)如果 self 是 syms 中的多项式，则返回 True，否则返回 False。
is_rational_function(*syms)测试函数是否是给定符号 syms 中的两个多项式的比率。
is_same(b[, approx])如果 a 和 b 结构相同则返回 True，否则返回 False。
leadterm(x[, logx, cdir])返回前导项 a*x**b 作为元组 (a, b)。
limit(x, xlim[, dir])计算极限 x->xlim。
lseries([x, x0, dir, logx, cdir])用于生成序列项的迭代器的包装器。
match(pattern[, old])模式匹配。
matches(expr[, repl_dict, old])用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
n([n, subs, maxn, chop, strict, quad, verbose])将给定的公式计算到 n 位精度。
normal()返回表达式为分数形式。
nseries([x, x0, n, dir, logx, cdir])如果假设允许，则包装到 _eval_nseries，否则包装到 series。
nsimplify([constants, tolerance, full])参见 sympy.simplify 中的 nsimplify 函数
powsimp(*args, **kwargs)请参阅 sympy.simplify 中的 powsimp 函数
primitive()返回可以从自身每个项中非递归提取的正有理数（即，将自身视为一个加法）。
radsimp(**kwargs)参见 sympy.simplify 中的 radsimp 函数
ratsimp()参见 sympy.simplify 中的 ratsimp 函数。
rcall(*args)通过表达式树递归应用于参数。
refine([assumption])请参阅 sympy.assumptions 中的 refine 函数。
removeO()如果存在，移除加性的 O(..) 符号
replace(query, value[, map, simultaneous, exact])将
self中匹配的子表达式替换为value。rewrite(*args[, deep])使用定义的规则重写 self。
round([n])返回 x 四舍五入到给定的十进制位数。
separate([deep, force])参见 sympy.simplify 中的单独函数
series([x, x0, n, dir, logx, cdir])在
x = x0附近对 "self" 进行级数展开，当 n=None 时逐项给出级数项（即惰性级数），否则当 n != None 时一次性给出所有项。simplify(**kwargs)请参阅 sympy.simplify 中的 simplify 函数。
sort_key([order])subs(*args, **kwargs)在简化参数后，在表达式中用新内容替换旧内容。
taylor_term(n, x, *previous_terms)泰勒项的一般方法。
together(*args, **kwargs)请参阅 sympy.polys 中的 together 函数。
trigsimp(**args)参见 sympy.simplify 中的 trigsimp 函数
xreplace(rule)替换表达式中对象的出现。
伴随
as_base_exp
复制
差异
目录
evaluate_integral
is_hypergeometric
转置
示例
>>> 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,
返回随机表达式的期望值。
- 参数:
- 表达式包含随机符号的表达式
你想要计算期望值的表达式
- 给定包含随机符号的表达式
一个条件表达式。E(X, X>0) 是在 X > 0 条件下的 X 的期望值。
- numsamples整数
启用采样并使用这些样本近似期望值
- evalfBool (默认为 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)[源代码][源代码]¶
期望的符号表达式。
- 属性:
args返回 ‘self’ 的参数元组。
assumptions0返回对象 \(type\) 假设。
canonical_variables返回一个字典，将
self.bound_symbols中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。expr_free_symbols类似于
free_symbols，但仅在自由符号包含在表达式节点中时返回它们。free_symbols从自身的原子中返回那些自由符号。
func表达式中的顶级函数。
- is_algebraic
- is_antihermitian
- is_commutative
is_comparable如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
- is_complex
- is_composite
- is_even
- is_extended_negative
- is_extended_nonnegative
- is_extended_nonpositive
- is_extended_nonzero
- is_extended_positive
- is_extended_real
- is_finite
- is_hermitian
- is_imaginary
- is_infinite
- is_integer
- is_irrational
- is_negative
- is_noninteger
- is_nonnegative
- is_nonpositive
- is_nonzero
is_number如果
self没有自由符号且没有未定义的函数（确切地说，是 AppliedUndef），则返回 True。- is_odd
- is_polar
- is_positive
- is_prime
- is_rational
- is_real
- is_transcendental
- is_zero
方法
apart([x])请参阅 sympy.polys 中的 apart 函数。
args_cnc([cset, warn, split_1])返回 [交换因子, 非交换因子] 的自身。
as_coeff_Add([rational])高效地提取求和的系数。
as_coeff_Mul([rational])高效地提取乘积的系数。
as_coeff_add(*deps)返回元组 (c, args)，其中 self 被写成一个 Add，
a。as_coeff_exponent(x)c*x**e -> c,e其中 x 可以是任何符号表达式。as_coeff_mul(*deps, **kwargs)返回元组 (c, args)，其中 self 被写成一个 Mul，
m。as_coefficient(expr)提取给定表达式中的符号系数。
as_coefficients_dict(*syms)返回一个字典，将术语映射到它们的 Rational 系数。
as_content_primitive([radical, clear])此方法应递归地从所有参数中移除一个 Rational，并返回该内容和新的 self（原始类型）。
as_dummy()返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
as_expr(*gens)将多项式转换为 SymPy 表达式。
as_independent(*deps, **hint)将 Mul 或 Add 的大部分天真分离为不依赖于 deps 的参数。
as_leading_term(*symbols[, logx, cdir])返回自身级数展开的主导（非零）项。
as_numer_denom()返回一个表达式的分子和分母。
as_ordered_factors([order])返回有序因子列表（如果是 Mul），否则返回 [self]。
as_ordered_terms([order, data])将表达式转换为有序的项列表。
as_poly(*gens, **args)将
self转换为多项式，或返回None。as_powers_dict()将自身作为一个因子的字典返回，每个因子都被视为一个幂。
as_real_imag([deep])对 'self' 执行复杂的扩展，并返回一个包含收集到的实部和虚部的元组。
as_terms()将一个表达式转换为项的列表。
aseries([x, n, bound, hir])自变量的渐近级数展开
atoms(*types)返回构成当前对象的原子。
cancel(*gens, **args)参见 sympy.polys 中的取消函数
class_key()类的好顺序。
coeff(x[, n, right, _first])返回包含
x**n的项中的系数。collect(syms[, func, evaluate, exact, ...])请参阅 sympy.simplify 中的 collect 函数。
combsimp()请参阅 sympy.simplify 中的 combsimp 函数。
compare(other)如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
compute_leading_term(x[, logx])已弃用的函数，用于计算级数的首项。
conjugate()返回 'self' 的复数共轭。
could_extract_minus_sign()如果 self 以 -1 作为前导因子，或在求和中有比正号更多的负号，则返回 True，否则返回 False。
count(query)计算匹配的子表达式的数量。
count_ops([visual])doit(**hints)dummy_eq(other[, symbol])比较两个表达式并处理哑符号。
equals(other[, failing_expression])如果 self == other 则返回 True，如果不相等则返回 False，或者返回 None。
evalf([n, subs, maxn, chop, strict, quad, ...])将给定的公式计算到 n 位精度。
expand(**hints)extract_additively(c)如果可以从自身减去 c 并且使所有匹配的系数趋向于零，则返回 self - c，否则返回 None。
extract_branch_factor([allow_half])尝试以
exp_polar(2*pi*I*n)*z的方式优雅地表达自身。extract_multiplicatively(c)如果无法以一种良好的方式将 self 表示为 c * something，即保留 self 参数的属性，则返回 None。
factor(*gens, **args)参见 sympy.polys.polytools 中的 factor() 函数
find(query[, group])查找所有匹配查询的子表达式。
fourier_series([limits])计算自身的傅里叶正弦/余弦级数。
fps([x, x0, dir, hyper, order, rational, full])计算自身的形式幂级数。
fromiter(args, **assumptions)从可迭代对象创建一个新对象。
gammasimp()参见 sympy.simplify 中的 gammasimp 函数
getO()如果有加法 O(..) 符号，则返回该符号，否则返回 None。
getn()返回表达式的顺序。
has(*patterns)测试是否有任何子表达式匹配任何模式。
has_free(*patterns)如果 self 包含对象
x作为自由表达式，则返回 True，否则返回 False。has_xfree(s)如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
integrate(*args, **kwargs)请参阅 sympy.integrals 中的 integrate 函数。
invert(g, *gens, **args)返回
self对g的乘法逆元，其中self``（和 ``g）可以是符号表达式。is_algebraic_expr(*syms)此测试给定的表达式是否在给定的符号 syms 中是代数的。
is_constant(*wrt, **flags)如果 self 是常量则返回 True，如果不是则返回 False，如果无法明确确定常量性则返回 None。
is_meromorphic(x, a)此测试表达式是否作为给定符号
x的函数在点a处是亚纯的。is_polynomial(*syms)如果 self 是 syms 中的多项式，则返回 True，否则返回 False。
is_rational_function(*syms)测试函数是否是给定符号 syms 中的两个多项式的比率。
is_same(b[, approx])如果 a 和 b 结构相同则返回 True，否则返回 False。
leadterm(x[, logx, cdir])返回前导项 a*x**b 作为元组 (a, b)。
limit(x, xlim[, dir])计算极限 x->xlim。
lseries([x, x0, dir, logx, cdir])用于生成序列项的迭代器的包装器。
match(pattern[, old])模式匹配。
matches(expr[, repl_dict, old])用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
n([n, subs, maxn, chop, strict, quad, verbose])将给定的公式计算到 n 位精度。
normal()返回表达式为分数形式。
nseries([x, x0, n, dir, logx, cdir])如果假设允许，则包装到 _eval_nseries，否则包装到 series。
nsimplify([constants, tolerance, full])参见 sympy.simplify 中的 nsimplify 函数
powsimp(*args, **kwargs)请参阅 sympy.simplify 中的 powsimp 函数
primitive()返回可以从自身每个项中非递归提取的正有理数（即，将自身视为一个加法）。
radsimp(**kwargs)参见 sympy.simplify 中的 radsimp 函数
ratsimp()参见 sympy.simplify 中的 ratsimp 函数。
rcall(*args)通过表达式树递归应用于参数。
refine([assumption])请参阅 sympy.assumptions 中的 refine 函数。
removeO()如果存在，移除加性的 O(..) 符号
replace(query, value[, map, simultaneous, exact])将
self中匹配的子表达式替换为value。rewrite(*args[, deep])使用定义的规则重写 self。
round([n])返回 x 四舍五入到给定的十进制位数。
separate([deep, force])参见 sympy.simplify 中的单独函数
series([x, x0, n, dir, logx, cdir])在
x = x0附近对 "self" 进行级数展开，当 n=None 时逐项给出级数项（即惰性级数），否则当 n != None 时一次性给出所有项。simplify(**kwargs)请参阅 sympy.simplify 中的 simplify 函数。
sort_key([order])subs(*args, **kwargs)在简化参数后，在表达式中用新内容替换旧内容。
taylor_term(n, x, *previous_terms)泰勒项的一般方法。
together(*args, **kwargs)请参阅 sympy.polys 中的 together 函数。
trigsimp(**args)参见 sympy.simplify 中的 trigsimp 函数
xreplace(rule)替换表达式中对象的出现。
伴随
as_base_exp
复制
差异
目录
evaluate_integral
evaluate_sum
is_hypergeometric
转置
示例
>>> 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,
随机表达式的概率密度，可选地给定第二个条件。
- 参数:
- 表达式包含随机符号的表达式
你想要计算密度值的表达式
- 条件包含 RandomSymbols 的关系
一个条件表达式。density(X > 1, X > 0) 是给定 X > 0 条件下 X > 1 的密度。
- numsamples整数
启用采样并以这么多样本近似密度
示例
>>> 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)[源代码][源代码]¶
计算概率分布的熵。
- 参数:
- 表达式要计算其熵的随机表达式
- 条件可选，用于指定随机表达式的条件
- b: 对数的底数，可选
默认情况下，它被视为欧拉数
- 返回:
- 结果表达式的熵，一个常数
参考文献
示例
>>> 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)[源代码][源代码]¶
条件随机表达式。
示例
>>> 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(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)[源代码][源代码]¶
方差的符号表达式。
- 属性:
args返回 ‘self’ 的参数元组。
assumptions0返回对象 \(type\) 假设。
canonical_variables返回一个字典，将
self.bound_symbols中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。expr_free_symbols类似于
free_symbols，但仅在自由符号包含在表达式节点中时返回它们。free_symbols从自身的原子中返回那些自由符号。
func表达式中的顶级函数。
- is_algebraic
- is_antihermitian
- is_commutative
is_comparable如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
- is_complex
- is_composite
- is_even
- is_extended_negative
- is_extended_nonnegative
- is_extended_nonpositive
- is_extended_nonzero
- is_extended_positive
- is_extended_real
- is_finite
- is_hermitian
- is_imaginary
- is_infinite
- is_integer
- is_irrational
- is_negative
- is_noninteger
- is_nonnegative
- is_nonpositive
- is_nonzero
is_number如果
self没有自由符号且没有未定义的函数（确切地说，是 AppliedUndef），则返回 True。- is_odd
- is_polar
- is_positive
- is_prime
- is_rational
- is_real
- is_transcendental
- is_zero
方法
apart([x])请参阅 sympy.polys 中的 apart 函数。
args_cnc([cset, warn, split_1])返回 [交换因子, 非交换因子] 的自身。
as_coeff_Add([rational])高效地提取求和的系数。
as_coeff_Mul([rational])高效地提取乘积的系数。
as_coeff_add(*deps)返回元组 (c, args)，其中 self 被写成一个 Add，
a。as_coeff_exponent(x)c*x**e -> c,e其中 x 可以是任何符号表达式。as_coeff_mul(*deps, **kwargs)返回元组 (c, args)，其中 self 被写成一个 Mul，
m。as_coefficient(expr)提取给定表达式中的符号系数。
as_coefficients_dict(*syms)返回一个字典，将术语映射到它们的 Rational 系数。
as_content_primitive([radical, clear])此方法应递归地从所有参数中移除一个 Rational，并返回该内容和新的 self（原始类型）。
as_dummy()返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
as_expr(*gens)将多项式转换为 SymPy 表达式。
as_independent(*deps, **hint)将 Mul 或 Add 的大部分天真分离为不依赖于 deps 的参数。
as_leading_term(*symbols[, logx, cdir])返回自身级数展开的主导（非零）项。
as_numer_denom()返回一个表达式的分子和分母。
as_ordered_factors([order])返回有序因子列表（如果是 Mul），否则返回 [self]。
as_ordered_terms([order, data])将表达式转换为有序的项列表。
as_poly(*gens, **args)将
self转换为多项式，或返回None。as_powers_dict()将自身作为一个因子的字典返回，每个因子都被视为一个幂。
as_real_imag([deep])对 'self' 执行复杂的扩展，并返回一个包含收集到的实部和虚部的元组。
as_terms()将一个表达式转换为项的列表。
aseries([x, n, bound, hir])自变量的渐近级数展开
atoms(*types)返回构成当前对象的原子。
cancel(*gens, **args)参见 sympy.polys 中的取消函数
class_key()类的好顺序。
coeff(x[, n, right, _first])返回包含
x**n的项中的系数。collect(syms[, func, evaluate, exact, ...])请参阅 sympy.simplify 中的 collect 函数。
combsimp()请参阅 sympy.simplify 中的 combsimp 函数。
compare(other)如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
compute_leading_term(x[, logx])已弃用的函数，用于计算级数的首项。
conjugate()返回 'self' 的复数共轭。
could_extract_minus_sign()如果 self 以 -1 作为前导因子，或在求和中有比正号更多的负号，则返回 True，否则返回 False。
count(query)计算匹配的子表达式的数量。
count_ops([visual])doit(**hints)评估默认情况下不评估的对象，如极限、积分、求和和乘积。
dummy_eq(other[, symbol])比较两个表达式并处理哑符号。
equals(other[, failing_expression])如果 self == other 则返回 True，如果不相等则返回 False，或者返回 None。
evalf([n, subs, maxn, chop, strict, quad, ...])将给定的公式计算到 n 位精度。
expand(**hints)extract_additively(c)如果可以从自身减去 c 并且使所有匹配的系数趋向于零，则返回 self - c，否则返回 None。
extract_branch_factor([allow_half])尝试以
exp_polar(2*pi*I*n)*z的方式优雅地表达自身。extract_multiplicatively(c)如果无法以一种良好的方式将 self 表示为 c * something，即保留 self 参数的属性，则返回 None。
factor(*gens, **args)参见 sympy.polys.polytools 中的 factor() 函数
find(query[, group])查找所有匹配查询的子表达式。
fourier_series([limits])计算自身的傅里叶正弦/余弦级数。
fps([x, x0, dir, hyper, order, rational, full])计算自身的形式幂级数。
fromiter(args, **assumptions)从可迭代对象创建一个新对象。
gammasimp()参见 sympy.simplify 中的 gammasimp 函数
getO()如果有加法 O(..) 符号，则返回该符号，否则返回 None。
getn()返回表达式的顺序。
has(*patterns)测试是否有任何子表达式匹配任何模式。
has_free(*patterns)如果 self 包含对象
x作为自由表达式，则返回 True，否则返回 False。has_xfree(s)如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
integrate(*args, **kwargs)请参阅 sympy.integrals 中的 integrate 函数。
invert(g, *gens, **args)返回
self对g的乘法逆元，其中self``（和 ``g）可以是符号表达式。is_algebraic_expr(*syms)此测试给定的表达式是否在给定的符号 syms 中是代数的。
is_constant(*wrt, **flags)如果 self 是常量则返回 True，如果不是则返回 False，如果无法明确确定常量性则返回 None。
is_meromorphic(x, a)此测试表达式是否作为给定符号
x的函数在点a处是亚纯的。is_polynomial(*syms)如果 self 是 syms 中的多项式，则返回 True，否则返回 False。
is_rational_function(*syms)测试函数是否是给定符号 syms 中的两个多项式的比率。
is_same(b[, approx])如果 a 和 b 结构相同则返回 True，否则返回 False。
leadterm(x[, logx, cdir])返回前导项 a*x**b 作为元组 (a, b)。
limit(x, xlim[, dir])计算极限 x->xlim。
lseries([x, x0, dir, logx, cdir])用于生成序列项的迭代器的包装器。
match(pattern[, old])模式匹配。
matches(expr[, repl_dict, old])用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
n([n, subs, maxn, chop, strict, quad, verbose])将给定的公式计算到 n 位精度。
normal()返回表达式为分数形式。
nseries([x, x0, n, dir, logx, cdir])如果假设允许，则包装到 _eval_nseries，否则包装到 series。
nsimplify([constants, tolerance, full])参见 sympy.simplify 中的 nsimplify 函数
powsimp(*args, **kwargs)请参阅 sympy.simplify 中的 powsimp 函数
primitive()返回可以从自身每个项中非递归提取的正有理数（即，将自身视为一个加法）。
radsimp(**kwargs)参见 sympy.simplify 中的 radsimp 函数
ratsimp()参见 sympy.simplify 中的 ratsimp 函数。
rcall(*args)通过表达式树递归应用于参数。
refine([assumption])请参阅 sympy.assumptions 中的 refine 函数。
removeO()如果存在，移除加性的 O(..) 符号
replace(query, value[, map, simultaneous, exact])将
self中匹配的子表达式替换为value。rewrite(*args[, deep])使用定义的规则重写 self。
round([n])返回 x 四舍五入到给定的十进制位数。
separate([deep, force])参见 sympy.simplify 中的单独函数
series([x, x0, n, dir, logx, cdir])在
x = x0附近对 "self" 进行级数展开，当 n=None 时逐项给出级数项（即惰性级数），否则当 n != None 时一次性给出所有项。simplify(**kwargs)请参阅 sympy.simplify 中的 simplify 函数。
sort_key([order])subs(*args, **kwargs)在简化参数后，在表达式中用新内容替换旧内容。
taylor_term(n, x, *previous_terms)泰勒项的一般方法。
together(*args, **kwargs)请参阅 sympy.polys 中的 together 函数。
trigsimp(**args)参见 sympy.simplify 中的 trigsimp 函数
xreplace(rule)替换表达式中对象的出现。
伴随
as_base_exp
复制
差异
目录
evaluate_integral
is_hypergeometric
转置
示例
>>> 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)[源代码][源代码]¶
两个随机表达式的协方差。
示例
>>> 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)[源代码][源代码]¶
协方差的符号表达式。
- 属性:
args返回 ‘self’ 的参数元组。
assumptions0返回对象 \(type\) 假设。
canonical_variables返回一个字典，将
self.bound_symbols中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。expr_free_symbols类似于
free_symbols，但仅在自由符号包含在表达式节点中时返回它们。free_symbols从自身的原子中返回那些自由符号。
func表达式中的顶级函数。
- is_algebraic
- is_antihermitian
- is_commutative
is_comparable如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
- is_complex
- is_composite
- is_even
- is_extended_negative
- is_extended_nonnegative
- is_extended_nonpositive
- is_extended_nonzero
- is_extended_positive
- is_extended_real
- is_finite
- is_hermitian
- is_imaginary
- is_infinite
- is_integer
- is_irrational
- is_negative
- is_noninteger
- is_nonnegative
- is_nonpositive
- is_nonzero
is_number如果
self没有自由符号且没有未定义的函数（确切地说，是 AppliedUndef），则返回 True。- is_odd
- is_polar
- is_positive
- is_prime
- is_rational
- is_real
- is_transcendental
- is_zero
方法
apart([x])请参阅 sympy.polys 中的 apart 函数。
args_cnc([cset, warn, split_1])返回 [交换因子, 非交换因子] 的自身。
as_coeff_Add([rational])高效地提取求和的系数。
as_coeff_Mul([rational])高效地提取乘积的系数。
as_coeff_add(*deps)返回元组 (c, args)，其中 self 被写成一个 Add，
a。as_coeff_exponent(x)c*x**e -> c,e其中 x 可以是任何符号表达式。as_coeff_mul(*deps, **kwargs)返回元组 (c, args)，其中 self 被写成一个 Mul，
m。as_coefficient(expr)提取给定表达式中的符号系数。
as_coefficients_dict(*syms)返回一个字典，将术语映射到它们的 Rational 系数。
as_content_primitive([radical, clear])此方法应递归地从所有参数中移除一个 Rational，并返回该内容和新的 self（原始类型）。
as_dummy()返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
as_expr(*gens)将多项式转换为 SymPy 表达式。
as_independent(*deps, **hint)将 Mul 或 Add 的大部分天真分离为不依赖于 deps 的参数。
as_leading_term(*symbols[, logx, cdir])返回自身级数展开的主导（非零）项。
as_numer_denom()返回一个表达式的分子和分母。
as_ordered_factors([order])返回有序因子列表（如果是 Mul），否则返回 [self]。
as_ordered_terms([order, data])将表达式转换为有序的项列表。
as_poly(*gens, **args)将
self转换为多项式，或返回None。as_powers_dict()将自身作为一个因子的字典返回，每个因子都被视为一个幂。
as_real_imag([deep])对 'self' 执行复杂的扩展，并返回一个包含收集到的实部和虚部的元组。
as_terms()将一个表达式转换为项的列表。
aseries([x, n, bound, hir])自变量的渐近级数展开
atoms(*types)返回构成当前对象的原子。
cancel(*gens, **args)参见 sympy.polys 中的取消函数
class_key()类的好顺序。
coeff(x[, n, right, _first])返回包含
x**n的项中的系数。collect(syms[, func, evaluate, exact, ...])请参阅 sympy.simplify 中的 collect 函数。
combsimp()请参阅 sympy.simplify 中的 combsimp 函数。
compare(other)如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
compute_leading_term(x[, logx])已弃用的函数，用于计算级数的首项。
conjugate()返回 'self' 的复数共轭。
could_extract_minus_sign()如果 self 以 -1 作为前导因子，或在求和中有比正号更多的负号，则返回 True，否则返回 False。
count(query)计算匹配的子表达式的数量。
count_ops([visual])doit(**hints)评估默认情况下不评估的对象，如极限、积分、求和和乘积。
dummy_eq(other[, symbol])比较两个表达式并处理哑符号。
equals(other[, failing_expression])如果 self == other 则返回 True，如果不相等则返回 False，或者返回 None。
evalf([n, subs, maxn, chop, strict, quad, ...])将给定的公式计算到 n 位精度。
expand(**hints)extract_additively(c)如果可以从自身减去 c 并且使所有匹配的系数趋向于零，则返回 self - c，否则返回 None。
extract_branch_factor([allow_half])尝试以
exp_polar(2*pi*I*n)*z的方式优雅地表达自身。extract_multiplicatively(c)如果无法以一种良好的方式将 self 表示为 c * something，即保留 self 参数的属性，则返回 None。
factor(*gens, **args)参见 sympy.polys.polytools 中的 factor() 函数
find(query[, group])查找所有匹配查询的子表达式。
fourier_series([limits])计算自身的傅里叶正弦/余弦级数。
fps([x, x0, dir, hyper, order, rational, full])计算自身的形式幂级数。
fromiter(args, **assumptions)从可迭代对象创建一个新对象。
gammasimp()参见 sympy.simplify 中的 gammasimp 函数
getO()如果有加法 O(..) 符号，则返回该符号，否则返回 None。
getn()返回表达式的顺序。
has(*patterns)测试是否有任何子表达式匹配任何模式。
has_free(*patterns)如果 self 包含对象
x作为自由表达式，则返回 True，否则返回 False。has_xfree(s)如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
integrate(*args, **kwargs)请参阅 sympy.integrals 中的 integrate 函数。
invert(g, *gens, **args)返回
self对g的乘法逆元，其中self``（和 ``g）可以是符号表达式。is_algebraic_expr(*syms)此测试给定的表达式是否在给定的符号 syms 中是代数的。
is_constant(*wrt, **flags)如果 self 是常量则返回 True，如果不是则返回 False，如果无法明确确定常量性则返回 None。
is_meromorphic(x, a)此测试表达式是否作为给定符号
x的函数在点a处是亚纯的。is_polynomial(*syms)如果 self 是 syms 中的多项式，则返回 True，否则返回 False。
is_rational_function(*syms)测试函数是否是给定符号 syms 中的两个多项式的比率。
is_same(b[, approx])如果 a 和 b 结构相同则返回 True，否则返回 False。
leadterm(x[, logx, cdir])返回前导项 a*x**b 作为元组 (a, b)。
limit(x, xlim[, dir])计算极限 x->xlim。
lseries([x, x0, dir, logx, cdir])用于生成序列项的迭代器的包装器。
match(pattern[, old])模式匹配。
matches(expr[, repl_dict, old])用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
n([n, subs, maxn, chop, strict, quad, verbose])将给定的公式计算到 n 位精度。
normal()返回表达式为分数形式。
nseries([x, x0, n, dir, logx, cdir])如果假设允许，则包装到 _eval_nseries，否则包装到 series。
nsimplify([constants, tolerance, full])参见 sympy.simplify 中的 nsimplify 函数
powsimp(*args, **kwargs)请参阅 sympy.simplify 中的 powsimp 函数
primitive()返回可以从自身每个项中非递归提取的正有理数（即，将自身视为一个加法）。
radsimp(**kwargs)参见 sympy.simplify 中的 radsimp 函数
ratsimp()参见 sympy.simplify 中的 ratsimp 函数。
rcall(*args)通过表达式树递归应用于参数。
refine([assumption])请参阅 sympy.assumptions 中的 refine 函数。
removeO()如果存在，移除加性的 O(..) 符号
replace(query, value[, map, simultaneous, exact])将
self中匹配的子表达式替换为value。rewrite(*args[, deep])使用定义的规则重写 self。
round([n])返回 x 四舍五入到给定的十进制位数。
separate([deep, force])参见 sympy.simplify 中的单独函数
series([x, x0, n, dir, logx, cdir])在
x = x0附近对 "self" 进行级数展开，当 n=None 时逐项给出级数项（即惰性级数），否则当 n != None 时一次性给出所有项。simplify(**kwargs)请参阅 sympy.simplify 中的 simplify 函数。
sort_key([order])subs(*args, **kwargs)在简化参数后，在表达式中用新内容替换旧内容。
taylor_term(n, x, *previous_terms)泰勒项的一般方法。
together(*args, **kwargs)请参阅 sympy.polys 中的 together 函数。
trigsimp(**args)参见 sympy.simplify 中的 trigsimp 函数
xreplace(rule)替换表达式中对象的出现。
伴随
as_base_exp
复制
差异
目录
evaluate_integral
is_hypergeometric
转置
示例
>>> 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)[源代码][源代码]¶
计算三个随机变量的共偏度。
- 参数:
- X随机符号
用于计算偏度协度的随机变量
- Y随机符号
用于计算偏度协度的随机变量
- Z随机符号
用于计算偏度协度的随机变量
- 条件包含随机符号的表达式
条件表达式
- 返回:
- coskewness三个随机变量的偏度
参考文献
示例
>>> 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)[源代码][源代码]¶
计算概率分布的中位数。
- 参数:
- X: 要计算其中位数的随机表达式。
- 返回:
- 包含中位数的有限集合或区间
- 随机表达式。
参考文献
[1]https://en.wikipedia.org/wiki/Median#概率分布
示例
>>> from sympy.stats import Normal, Die, median >>> N = Normal('N', 3, 1) >>> median(N) {3} >>> D = Die('D') >>> median(D) {3, 4}
- sympy.stats.std(X, condition=None, **kwargs)[源代码]¶
随机表达式的标准差
\[std(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)[源代码][源代码]¶
返回概率分布的 \(p^{th}\) 阶分位数。
示例
>>> 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,
随机表达式的实现。
- 参数:
- 表达式随机变量的表达式
从中提取样本的表达式
- 条件包含随机符号的表达式
条件表达式
- 大小int, 元组
表示每个样本在 numsamples 中的大小
- 库str
‘scipy’ : 使用 scipy 的示例
‘numpy’ : 使用 numpy 的示例
‘pymc’ : 使用 PyMC 进行采样
选择任意一个可用选项作为字符串进行采样，默认值为 ‘scipy’
- numsamples整数
样本数量，每个样本的大小为
size。自 1.9 版本弃用.
numsamples参数已被弃用，仅为了与 v1.8 兼容而提供。请改用列表推导或size中的额外维度。详情请参阅 sympy.stats.sample(numsamples=n)。- 种子
一个对象，作为给定外部库用于采样 \(expr\) 的种子。以下是支持的库可能的对象类型的列表，
‘scipy’: int, numpy.random.RandomState, numpy.random.Generator
‘numpy’: int, numpy.random.RandomState, numpy.random.Generator
‘pymc’: int
可选，默认为 None，在这种情况下将使用与给定库相关的种子设置。此参数不会对环境的全球种子设置进行任何修改。
- 返回:
- sample: float/list/numpy.ndarray
一个随机表达式的样本或样本集合。
sample(X) 返回 float/numpy.float64/numpy.int64 对象。
sample(X, size=int/tuple) 返回 numpy.ndarray 对象。
示例
>>> 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 过去返回的是包含样本的迭代器，而不是值。
在 1.9.0 版本发生变更: sample 返回值或值数组，而不是迭代器，numsamples 已被弃用。
- sympy.stats.sample_iter(
- expr,
- condition=None,
- size=(),
- library='scipy',
- numsamples=oo,
- seed=None,
- **kwargs,
返回一个从给定条件的表达式中实现的迭代器。
- 参数:
- expr: Expr
随机表达式待实现
- 条件: Expr, 可选
条件表达式
- 大小int, 元组
表示每个样本在 numsamples 中的大小
- numsamples: 整数, 可选
迭代器的长度（默认为无穷大）
- 种子
一个对象，作为给定外部库用于采样 \(expr\) 的种子。以下是支持的库可能的对象类型的列表，
‘scipy’: int, numpy.random.RandomState, numpy.random.Generator
‘numpy’: int, numpy.random.RandomState, numpy.random.Generator
‘pymc’: int
可选，默认为 None，在这种情况下将使用与给定库相关的种子设置。此参数不会对环境的全球种子设置进行任何修改。
- 返回:
- sample_iter: 迭代器对象
包含给定表达式的样本/多个样本的迭代器对象
参见
samplesampling_Psampling_E
示例
>>> 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)[源代码][源代码]¶
阶乘矩是一个数学量，定义为随机变量的下降阶乘的期望或平均值。
\[factorial-moment(X, n) = E(X(X - 1)(X - 2)...(X - n + 1))\]- 参数:
- n: 一个自然数，第n阶阶乘矩。
- 条件包含随机符号的表达式
一个条件表达式。
参考文献
示例
>>> 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)[源代码][源代码]¶
表征概率分布的尾部/异常值。
- 参数:
- 条件包含随机符号的表达式
一个条件表达式。kurtosis(X, X>0) 是给定 X > 0 时 X 的峰度。
参考文献
示例
>>> 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)[源代码][源代码]¶
概率分布不对称性的度量。
- 参数:
- 条件包含随机符号的表达式
一个条件表达式。skewness(X, X>0) 是给定 X > 0 时 X 的偏度。
示例
>>> 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)[源代码][源代码]¶
两个随机表达式的相关性，也称为相关系数或皮尔逊相关。
示例
>>> 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,
密度采样版本。
参见
densitysampling_Psampling_E
- sympy.stats.rv.sampling_P(
- condition,
- given_condition=None,
- library='scipy',
- numsamples=1,
- evalf=True,
- seed=None,
- **kwargs,
P 的采样版本
- sympy.stats.rv.sampling_E(
- expr,
- given_condition=None,
- library='scipy',
- numsamples=1,
- evalf=True,
- seed=None,
- **kwargs,
E 的采样版本
- class sympy.stats.Moment(X, n, c=0, condition=None, **kwargs)[源代码][源代码]¶
Moment 的符号类
- 属性:
args返回 ‘self’ 的参数元组。
assumptions0返回对象 \(type\) 假设。
canonical_variables返回一个字典，将
self.bound_symbols中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。expr_free_symbols类似于
free_symbols，但仅在自由符号包含在表达式节点中时返回它们。free_symbols从自身的原子中返回那些自由符号。
func表达式中的顶级函数。
- is_algebraic
- is_antihermitian
- is_commutative
is_comparable如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
- is_complex
- is_composite
- is_even
- is_extended_negative
- is_extended_nonnegative
- is_extended_nonpositive
- is_extended_nonzero
- is_extended_positive
- is_extended_real
- is_finite
- is_hermitian
- is_imaginary
- is_infinite
- is_integer
- is_irrational
- is_negative
- is_noninteger
- is_nonnegative
- is_nonpositive
- is_nonzero
is_number如果
self没有自由符号且没有未定义的函数（确切地说，是 AppliedUndef），则返回 True。- is_odd
- is_polar
- is_positive
- is_prime
- is_rational
- is_real
- is_transcendental
- is_zero
方法
apart([x])请参阅 sympy.polys 中的 apart 函数。
args_cnc([cset, warn, split_1])返回 [交换因子, 非交换因子] 的自身。
as_coeff_Add([rational])高效地提取求和的系数。
as_coeff_Mul([rational])高效地提取乘积的系数。
as_coeff_add(*deps)返回元组 (c, args)，其中 self 被写成一个 Add，
a。as_coeff_exponent(x)c*x**e -> c,e其中 x 可以是任何符号表达式。as_coeff_mul(*deps, **kwargs)返回元组 (c, args)，其中 self 被写成一个 Mul，
m。as_coefficient(expr)提取给定表达式中的符号系数。
as_coefficients_dict(*syms)返回一个字典，将术语映射到它们的 Rational 系数。
as_content_primitive([radical, clear])此方法应递归地从所有参数中移除一个 Rational，并返回该内容和新的 self（原始类型）。
as_dummy()返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
as_expr(*gens)将多项式转换为 SymPy 表达式。
as_independent(*deps, **hint)将 Mul 或 Add 的大部分天真分离为不依赖于 deps 的参数。
as_leading_term(*symbols[, logx, cdir])返回自身级数展开的主导（非零）项。
as_numer_denom()返回一个表达式的分子和分母。
as_ordered_factors([order])返回有序因子列表（如果是 Mul），否则返回 [self]。
as_ordered_terms([order, data])将表达式转换为有序的项列表。
as_poly(*gens, **args)将
self转换为多项式，或返回None。as_powers_dict()将自身作为一个因子的字典返回，每个因子都被视为一个幂。
as_real_imag([deep])对 'self' 执行复杂的扩展，并返回一个包含收集到的实部和虚部的元组。
as_terms()将一个表达式转换为项的列表。
aseries([x, n, bound, hir])自变量的渐近级数展开
atoms(*types)返回构成当前对象的原子。
cancel(*gens, **args)参见 sympy.polys 中的取消函数
class_key()类的好顺序。
coeff(x[, n, right, _first])返回包含
x**n的项中的系数。collect(syms[, func, evaluate, exact, ...])请参阅 sympy.simplify 中的 collect 函数。
combsimp()请参阅 sympy.simplify 中的 combsimp 函数。
compare(other)如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
compute_leading_term(x[, logx])已弃用的函数，用于计算级数的首项。
conjugate()返回 'self' 的复数共轭。
could_extract_minus_sign()如果 self 以 -1 作为前导因子，或在求和中有比正号更多的负号，则返回 True，否则返回 False。
count(query)计算匹配的子表达式的数量。
count_ops([visual])doit(**hints)dummy_eq(other[, symbol])比较两个表达式并处理哑符号。
equals(other[, failing_expression])如果 self == other 则返回 True，如果不相等则返回 False，或者返回 None。
evalf([n, subs, maxn, chop, strict, quad, ...])将给定的公式计算到 n 位精度。
expand([deep, modulus, power_base, ...])使用提示扩展表达式。
extract_additively(c)如果可以从自身减去 c 并且使所有匹配的系数趋向于零，则返回 self - c，否则返回 None。
extract_branch_factor([allow_half])尝试以
exp_polar(2*pi*I*n)*z的方式优雅地表达自身。extract_multiplicatively(c)如果无法以一种良好的方式将 self 表示为 c * something，即保留 self 参数的属性，则返回 None。
factor(*gens, **args)参见 sympy.polys.polytools 中的 factor() 函数
find(query[, group])查找所有匹配查询的子表达式。
fourier_series([limits])计算自身的傅里叶正弦/余弦级数。
fps([x, x0, dir, hyper, order, rational, full])计算自身的形式幂级数。
fromiter(args, **assumptions)从可迭代对象创建一个新对象。
gammasimp()参见 sympy.simplify 中的 gammasimp 函数
getO()如果有加法 O(..) 符号，则返回该符号，否则返回 None。
getn()返回表达式的顺序。
has(*patterns)测试是否有任何子表达式匹配任何模式。
has_free(*patterns)如果 self 包含对象
x作为自由表达式，则返回 True，否则返回 False。has_xfree(s)如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
integrate(*args, **kwargs)请参阅 sympy.integrals 中的 integrate 函数。
invert(g, *gens, **args)返回
self对g的乘法逆元，其中self``（和 ``g）可以是符号表达式。is_algebraic_expr(*syms)此测试给定的表达式是否在给定的符号 syms 中是代数的。
is_constant(*wrt, **flags)如果 self 是常量则返回 True，如果不是则返回 False，如果无法明确确定常量性则返回 None。
is_meromorphic(x, a)此测试表达式是否作为给定符号
x的函数在点a处是亚纯的。is_polynomial(*syms)如果 self 是 syms 中的多项式，则返回 True，否则返回 False。
is_rational_function(*syms)测试函数是否是给定符号 syms 中的两个多项式的比率。
is_same(b[, approx])如果 a 和 b 结构相同则返回 True，否则返回 False。
leadterm(x[, logx, cdir])返回前导项 a*x**b 作为元组 (a, b)。
limit(x, xlim[, dir])计算极限 x->xlim。
lseries([x, x0, dir, logx, cdir])用于生成序列项的迭代器的包装器。
match(pattern[, old])模式匹配。
matches(expr[, repl_dict, old])用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
n([n, subs, maxn, chop, strict, quad, verbose])将给定的公式计算到 n 位精度。
normal()返回表达式为分数形式。
nseries([x, x0, n, dir, logx, cdir])如果假设允许，则包装到 _eval_nseries，否则包装到 series。
nsimplify([constants, tolerance, full])参见 sympy.simplify 中的 nsimplify 函数
powsimp(*args, **kwargs)请参阅 sympy.simplify 中的 powsimp 函数
primitive()返回可以从自身每个项中非递归提取的正有理数（即，将自身视为一个加法）。
radsimp(**kwargs)参见 sympy.simplify 中的 radsimp 函数
ratsimp()参见 sympy.simplify 中的 ratsimp 函数。
rcall(*args)通过表达式树递归应用于参数。
refine([assumption])请参阅 sympy.assumptions 中的 refine 函数。
removeO()如果存在，移除加性的 O(..) 符号
replace(query, value[, map, simultaneous, exact])将
self中匹配的子表达式替换为value。rewrite(*args[, deep])使用定义的规则重写 self。
round([n])返回 x 四舍五入到给定的十进制位数。
separate([deep, force])参见 sympy.simplify 中的单独函数
series([x, x0, n, dir, logx, cdir])在
x = x0附近对 "self" 进行级数展开，当 n=None 时逐项给出级数项（即惰性级数），否则当 n != None 时一次性给出所有项。simplify(**kwargs)请参阅 sympy.simplify 中的 simplify 函数。
sort_key([order])subs(*args, **kwargs)在简化参数后，在表达式中用新内容替换旧内容。
taylor_term(n, x, *previous_terms)泰勒项的一般方法。
together(*args, **kwargs)请参阅 sympy.polys 中的 together 函数。
trigsimp(**args)参见 sympy.simplify 中的 trigsimp 函数
xreplace(rule)替换表达式中对象的出现。
伴随
as_base_exp
复制
差异
目录
is_hypergeometric
转置
示例
>>> 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)
要评估 Moment 的结果，请使用 \(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))
用积分形式重写Moment表达式：
>>> 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 阶矩。
\[moment(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)[源代码][源代码]¶
符号类 中心矩
- 属性:
args返回 ‘self’ 的参数元组。
assumptions0返回对象 \(type\) 假设。
canonical_variables返回一个字典，将
self.bound_symbols中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。expr_free_symbols类似于
free_symbols，但仅在自由符号包含在表达式节点中时返回它们。free_symbols从自身的原子中返回那些自由符号。
func表达式中的顶级函数。
- is_algebraic
- is_antihermitian
- is_commutative
is_comparable如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
- is_complex
- is_composite
- is_even
- is_extended_negative
- is_extended_nonnegative
- is_extended_nonpositive
- is_extended_nonzero
- is_extended_positive
- is_extended_real
- is_finite
- is_hermitian
- is_imaginary
- is_infinite
- is_integer
- is_irrational
- is_negative
- is_noninteger
- is_nonnegative
- is_nonpositive
- is_nonzero
is_number如果
self没有自由符号且没有未定义的函数（确切地说，是 AppliedUndef），则返回 True。- is_odd
- is_polar
- is_positive
- is_prime
- is_rational
- is_real
- is_transcendental
- is_zero
方法
apart([x])请参阅 sympy.polys 中的 apart 函数。
args_cnc([cset, warn, split_1])返回 [交换因子, 非交换因子] 的自身。
as_coeff_Add([rational])高效地提取求和的系数。
as_coeff_Mul([rational])高效地提取乘积的系数。
as_coeff_add(*deps)返回元组 (c, args)，其中 self 被写成一个 Add，
a。as_coeff_exponent(x)c*x**e -> c,e其中 x 可以是任何符号表达式。as_coeff_mul(*deps, **kwargs)返回元组 (c, args)，其中 self 被写成一个 Mul，
m。as_coefficient(expr)提取给定表达式中的符号系数。
as_coefficients_dict(*syms)返回一个字典，将术语映射到它们的 Rational 系数。
as_content_primitive([radical, clear])此方法应递归地从所有参数中移除一个 Rational，并返回该内容和新的 self（原始类型）。
as_dummy()返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
as_expr(*gens)将多项式转换为 SymPy 表达式。
as_independent(*deps, **hint)将 Mul 或 Add 的大部分天真分离为不依赖于 deps 的参数。
as_leading_term(*symbols[, logx, cdir])返回自身级数展开的主导（非零）项。
as_numer_denom()返回一个表达式的分子和分母。
as_ordered_factors([order])返回有序因子列表（如果是 Mul），否则返回 [self]。
as_ordered_terms([order, data])将表达式转换为有序的项列表。
as_poly(*gens, **args)将
self转换为多项式，或返回None。as_powers_dict()将自身作为一个因子的字典返回，每个因子都被视为一个幂。
as_real_imag([deep])对 'self' 执行复杂的扩展，并返回一个包含收集到的实部和虚部的元组。
as_terms()将一个表达式转换为项的列表。
aseries([x, n, bound, hir])自变量的渐近级数展开
atoms(*types)返回构成当前对象的原子。
cancel(*gens, **args)参见 sympy.polys 中的取消函数
class_key()类的好顺序。
coeff(x[, n, right, _first])返回包含
x**n的项中的系数。collect(syms[, func, evaluate, exact, ...])请参阅 sympy.simplify 中的 collect 函数。
combsimp()请参阅 sympy.simplify 中的 combsimp 函数。
compare(other)如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
compute_leading_term(x[, logx])已弃用的函数，用于计算级数的首项。
conjugate()返回 'self' 的复数共轭。
could_extract_minus_sign()如果 self 以 -1 作为前导因子，或在求和中有比正号更多的负号，则返回 True，否则返回 False。
count(query)计算匹配的子表达式的数量。
count_ops([visual])doit(**hints)dummy_eq(other[, symbol])比较两个表达式并处理哑符号。
equals(other[, failing_expression])如果 self == other 则返回 True，如果不相等则返回 False，或者返回 None。
evalf([n, subs, maxn, chop, strict, quad, ...])将给定的公式计算到 n 位精度。
expand([deep, modulus, power_base, ...])使用提示扩展表达式。
extract_additively(c)如果可以从自身减去 c 并且使所有匹配的系数趋向于零，则返回 self - c，否则返回 None。
extract_branch_factor([allow_half])尝试以
exp_polar(2*pi*I*n)*z的方式优雅地表达自身。extract_multiplicatively(c)如果无法以一种良好的方式将 self 表示为 c * something，即保留 self 参数的属性，则返回 None。
factor(*gens, **args)参见 sympy.polys.polytools 中的 factor() 函数
find(query[, group])查找所有匹配查询的子表达式。
fourier_series([limits])计算自身的傅里叶正弦/余弦级数。
fps([x, x0, dir, hyper, order, rational, full])计算自身的形式幂级数。
fromiter(args, **assumptions)从可迭代对象创建一个新对象。
gammasimp()参见 sympy.simplify 中的 gammasimp 函数
getO()如果有加法 O(..) 符号，则返回该符号，否则返回 None。
getn()返回表达式的顺序。
has(*patterns)测试是否有任何子表达式匹配任何模式。
has_free(*patterns)如果 self 包含对象
x作为自由表达式，则返回 True，否则返回 False。has_xfree(s)如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
integrate(*args, **kwargs)请参阅 sympy.integrals 中的 integrate 函数。
invert(g, *gens, **args)返回
self对g的乘法逆元，其中self``（和 ``g）可以是符号表达式。is_algebraic_expr(*syms)此测试给定的表达式是否在给定的符号 syms 中是代数的。
is_constant(*wrt, **flags)如果 self 是常量则返回 True，如果不是则返回 False，如果无法明确确定常量性则返回 None。
is_meromorphic(x, a)此测试表达式是否作为给定符号
x的函数在点a处是亚纯的。is_polynomial(*syms)如果 self 是 syms 中的多项式，则返回 True，否则返回 False。
is_rational_function(*syms)测试函数是否是给定符号 syms 中的两个多项式的比率。
is_same(b[, approx])如果 a 和 b 结构相同则返回 True，否则返回 False。
leadterm(x[, logx, cdir])返回前导项 a*x**b 作为元组 (a, b)。
limit(x, xlim[, dir])计算极限 x->xlim。
lseries([x, x0, dir, logx, cdir])用于生成序列项的迭代器的包装器。
match(pattern[, old])模式匹配。
matches(expr[, repl_dict, old])用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
n([n, subs, maxn, chop, strict, quad, verbose])将给定的公式计算到 n 位精度。
normal()返回表达式为分数形式。
nseries([x, x0, n, dir, logx, cdir])如果假设允许，则包装到 _eval_nseries，否则包装到 series。
nsimplify([constants, tolerance, full])参见 sympy.simplify 中的 nsimplify 函数
powsimp(*args, **kwargs)请参阅 sympy.simplify 中的 powsimp 函数
primitive()返回可以从自身每个项中非递归提取的正有理数（即，将自身视为一个加法）。
radsimp(**kwargs)参见 sympy.simplify 中的 radsimp 函数
ratsimp()参见 sympy.simplify 中的 ratsimp 函数。
rcall(*args)通过表达式树递归应用于参数。
refine([assumption])请参阅 sympy.assumptions 中的 refine 函数。
removeO()如果存在，移除加性的 O(..) 符号
replace(query, value[, map, simultaneous, exact])将
self中匹配的子表达式替换为value。rewrite(*args[, deep])使用定义的规则重写 self。
round([n])返回 x 四舍五入到给定的十进制位数。
separate([deep, force])参见 sympy.simplify 中的单独函数
series([x, x0, n, dir, logx, cdir])在
x = x0附近对 "self" 进行级数展开，当 n=None 时逐项给出级数项（即惰性级数），否则当 n != None 时一次性给出所有项。simplify(**kwargs)请参阅 sympy.simplify 中的 simplify 函数。
sort_key([order])subs(*args, **kwargs)在简化参数后，在表达式中用新内容替换旧内容。
taylor_term(n, x, *previous_terms)泰勒项的一般方法。
together(*args, **kwargs)请参阅 sympy.polys 中的 together 函数。
trigsimp(**args)参见 sympy.simplify 中的 trigsimp 函数
xreplace(rule)替换表达式中对象的出现。
伴随
as_base_exp
复制
差异
目录
is_hypergeometric
转置
示例
>>> 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)
要评估 CentralMoment 的结果，请使用 \(doit\)：
>>> CM.doit().simplify() 3*sigma**4
用期望值重写中心矩表达式：
>>> 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))
用积分形式重写中心矩表达式：
>>> 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)[源代码][源代码]¶
随机矩阵表达式的期望。
- 属性:
- 我
T矩阵转置
args返回 ‘self’ 的参数元组。
assumptions0返回对象 \(type\) 假设。
canonical_variables返回一个字典，将
self.bound_symbols中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。- cols
expr_free_symbols类似于
free_symbols，但仅在自由符号包含在表达式节点中时返回它们。free_symbols从自身的原子中返回那些自由符号。
func表达式中的顶级函数。
- is_Identity
- is_antihermitian
is_comparable如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
- is_finite
- is_hermitian
- is_infinite
- is_polar
- is_square
- 行
- 形状
方法
apart([x])请参阅 sympy.polys 中的 apart 函数。
args_cnc([cset, warn, split_1])返回 [交换因子, 非交换因子] 的自身。
as_coeff_Add([rational])高效地提取求和的系数。
as_coeff_Mul([rational])高效地提取乘积的系数。
as_coeff_add(*deps)返回元组 (c, args)，其中 self 被写成一个 Add，
a。as_coeff_exponent(x)c*x**e -> c,e其中 x 可以是任何符号表达式。as_coeff_mul(*deps, **kwargs)返回元组 (c, args)，其中 self 被写成一个 Mul，
m。as_coefficient(expr)提取给定表达式中的符号系数。
as_coefficients_dict(*syms)返回一个字典，将术语映射到它们的 Rational 系数。
as_content_primitive([radical, clear])此方法应递归地从所有参数中移除一个 Rational，并返回该内容和新的 self（原始类型）。
as_dummy()返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
as_explicit()返回一个元素明确表示的密集矩阵
as_expr(*gens)将多项式转换为 SymPy 表达式。
as_independent(*deps, **hint)将 Mul 或 Add 的大部分天真分离为不依赖于 deps 的参数。
as_leading_term(*symbols[, logx, cdir])返回自身级数展开的主导（非零）项。
as_mutable()返回一个密集的、可变的矩阵，其元素明确表示。
as_numer_denom()返回一个表达式的分子和分母。
as_ordered_factors([order])返回有序因子列表（如果是 Mul），否则返回 [self]。
as_ordered_terms([order, data])将表达式转换为有序的项列表。
as_poly(*gens, **args)将
self转换为多项式，或返回None。as_powers_dict()将自身作为一个因子的字典返回，每个因子都被视为一个幂。
as_real_imag([deep])as_terms()将一个表达式转换为项的列表。
aseries([x, n, bound, hir])自变量的渐近级数展开
atoms(*types)返回构成当前对象的原子。
cancel(*gens, **args)参见 sympy.polys 中的取消函数
class_key()类的好顺序。
coeff(x[, n, right, _first])返回包含
x**n的项中的系数。collect(syms[, func, evaluate, exact, ...])请参阅 sympy.simplify 中的 collect 函数。
combsimp()请参阅 sympy.simplify 中的 combsimp 函数。
compare(other)如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
compute_leading_term(x[, logx])已弃用的函数，用于计算级数的首项。
conjugate()could_extract_minus_sign()如果 self 以 -1 作为前导因子，或在求和中有比正号更多的负号，则返回 True，否则返回 False。
count(query)计算匹配的子表达式的数量。
count_ops([visual])doit(**hints)dummy_eq(other[, symbol])比较两个表达式并处理哑符号。
equals(other)在矩阵之间测试逐元素相等性，矩阵类型可能不同
evalf([n, subs, maxn, chop, strict, quad, ...])将给定的公式计算到 n 位精度。
expand(**hints)extract_additively(c)如果可以从自身减去 c 并且使所有匹配的系数趋向于零，则返回 self - c，否则返回 None。
extract_branch_factor([allow_half])尝试以
exp_polar(2*pi*I*n)*z的方式优雅地表达自身。extract_multiplicatively(c)如果无法以一种良好的方式将 self 表示为 c * something，即保留 self 参数的属性，则返回 None。
factor(*gens, **args)参见 sympy.polys.polytools 中的 factor() 函数
find(query[, group])查找所有匹配查询的子表达式。
fourier_series([limits])计算自身的傅里叶正弦/余弦级数。
fps([x, x0, dir, hyper, order, rational, full])计算自身的形式幂级数。
from_index_summation(expr[, first_index, ...])如果可能，将显式求和指标的矩阵表达式解析为无指标的矩阵表达式。
fromiter(args, **assumptions)从可迭代对象创建一个新对象。
gammasimp()参见 sympy.simplify 中的 gammasimp 函数
getO()如果有加法 O(..) 符号，则返回该符号，否则返回 None。
getn()返回表达式的顺序。
has(*patterns)测试是否有任何子表达式匹配任何模式。
has_free(*patterns)如果 self 包含对象
x作为自由表达式，则返回 True，否则返回 False。has_xfree(s)如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
integrate(*args, **kwargs)请参阅 sympy.integrals 中的 integrate 函数。
invert(g, *gens, **args)返回
self对g的乘法逆元，其中self``（和 ``g）可以是符号表达式。is_algebraic_expr(*syms)此测试给定的表达式是否在给定的符号 syms 中是代数的。
is_constant(*wrt, **flags)如果 self 是常量则返回 True，如果不是则返回 False，如果无法明确确定常量性则返回 None。
is_meromorphic(x, a)此测试表达式是否作为给定符号
x的函数在点a处是亚纯的。is_polynomial(*syms)如果 self 是 syms 中的多项式，则返回 True，否则返回 False。
is_rational_function(*syms)测试函数是否是给定符号 syms 中的两个多项式的比率。
is_same(b[, approx])如果 a 和 b 结构相同则返回 True，否则返回 False。
leadterm(x[, logx, cdir])返回前导项 a*x**b 作为元组 (a, b)。
limit(x, xlim[, dir])计算极限 x->xlim。
lseries([x, x0, dir, logx, cdir])用于生成序列项的迭代器的包装器。
match(pattern[, old])模式匹配。
matches(expr[, repl_dict, old])用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
n([n, subs, maxn, chop, strict, quad, verbose])将给定的公式计算到 n 位精度。
normal()返回表达式为分数形式。
nseries([x, x0, n, dir, logx, cdir])如果假设允许，则包装到 _eval_nseries，否则包装到 series。
nsimplify([constants, tolerance, full])参见 sympy.simplify 中的 nsimplify 函数
powsimp(*args, **kwargs)请参阅 sympy.simplify 中的 powsimp 函数
primitive()返回可以从自身每个项中非递归提取的正有理数（即，将自身视为一个加法）。
radsimp(**kwargs)参见 sympy.simplify 中的 radsimp 函数
ratsimp()参见 sympy.simplify 中的 ratsimp 函数。
rcall(*args)通过表达式树递归应用于参数。
refine([assumption])请参阅 sympy.assumptions 中的 refine 函数。
removeO()如果存在，移除加性的 O(..) 符号
replace(query, value[, map, simultaneous, exact])将
self中匹配的子表达式替换为value。rewrite(*args[, deep])使用定义的规则重写 self。
round([n])返回 x 四舍五入到给定的十进制位数。
separate([deep, force])参见 sympy.simplify 中的单独函数
series([x, x0, n, dir, logx, cdir])在
x = x0附近对 "self" 进行级数展开，当 n=None 时逐项给出级数项（即惰性级数），否则当 n != None 时一次性给出所有项。simplify(**kwargs)请参阅 sympy.simplify 中的 simplify 函数。
sort_key([order])subs(*args, **kwargs)在简化参数后，在表达式中用新内容替换旧内容。
taylor_term(n, x, *previous_terms)泰勒项的一般方法。
together(*args, **kwargs)请参阅 sympy.polys 中的 together 函数。
trigsimp(**args)参见 sympy.simplify 中的 trigsimp 函数
xreplace(rule)替换表达式中对象的出现。
伴随
applyfunc
as_base_exp
as_coeff_mmul
规范化
复制
det
差异
目录
evaluate_integral
evaluate_sum
inv
反向
is_hypergeometric
转置
有效索引
示例
>>> 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)[源代码][源代码]¶
随机矩阵概率表达式的方差。也称为协方差矩阵、自协方差矩阵、散布矩阵或方差-协方差矩阵。
- 属性:
- 我
T矩阵转置
args返回 ‘self’ 的参数元组。
assumptions0返回对象 \(type\) 假设。
canonical_variables返回一个字典，将
self.bound_symbols中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。- cols
expr_free_symbols类似于
free_symbols，但仅在自由符号包含在表达式节点中时返回它们。free_symbols从自身的原子中返回那些自由符号。
func表达式中的顶级函数。
- is_Identity
- is_antihermitian
is_comparable如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
- is_finite
- is_hermitian
- is_infinite
- is_polar
- is_square
- 行
- 形状
方法
apart([x])请参阅 sympy.polys 中的 apart 函数。
args_cnc([cset, warn, split_1])返回 [交换因子, 非交换因子] 的自身。
as_coeff_Add([rational])高效地提取求和的系数。
as_coeff_Mul([rational])高效地提取乘积的系数。
as_coeff_add(*deps)返回元组 (c, args)，其中 self 被写成一个 Add，
a。as_coeff_exponent(x)c*x**e -> c,e其中 x 可以是任何符号表达式。as_coeff_mul(*deps, **kwargs)返回元组 (c, args)，其中 self 被写成一个 Mul，
m。as_coefficient(expr)提取给定表达式中的符号系数。
as_coefficients_dict(*syms)返回一个字典，将术语映射到它们的 Rational 系数。
as_content_primitive([radical, clear])此方法应递归地从所有参数中移除一个 Rational，并返回该内容和新的 self（原始类型）。
as_dummy()返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
as_explicit()返回一个元素明确表示的密集矩阵
as_expr(*gens)将多项式转换为 SymPy 表达式。
as_independent(*deps, **hint)将 Mul 或 Add 的大部分天真分离为不依赖于 deps 的参数。
as_leading_term(*symbols[, logx, cdir])返回自身级数展开的主导（非零）项。
as_mutable()返回一个密集的、可变的矩阵，其元素明确表示。
as_numer_denom()返回一个表达式的分子和分母。
as_ordered_factors([order])返回有序因子列表（如果是 Mul），否则返回 [self]。
as_ordered_terms([order, data])将表达式转换为有序的项列表。
as_poly(*gens, **args)将
self转换为多项式，或返回None。as_powers_dict()将自身作为一个因子的字典返回，每个因子都被视为一个幂。
as_real_imag([deep])as_terms()将一个表达式转换为项的列表。
aseries([x, n, bound, hir])自变量的渐近级数展开
atoms(*types)返回构成当前对象的原子。
cancel(*gens, **args)参见 sympy.polys 中的取消函数
class_key()类的好顺序。
coeff(x[, n, right, _first])返回包含
x**n的项中的系数。collect(syms[, func, evaluate, exact, ...])请参阅 sympy.simplify 中的 collect 函数。
combsimp()请参阅 sympy.simplify 中的 combsimp 函数。
compare(other)如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
compute_leading_term(x[, logx])已弃用的函数，用于计算级数的首项。
conjugate()could_extract_minus_sign()如果 self 以 -1 作为前导因子，或在求和中有比正号更多的负号，则返回 True，否则返回 False。
count(query)计算匹配的子表达式的数量。
count_ops([visual])doit(**hints)评估默认情况下不评估的对象，如极限、积分、求和和乘积。
dummy_eq(other[, symbol])比较两个表达式并处理哑符号。
equals(other)在矩阵之间测试逐元素相等性，矩阵类型可能不同
evalf([n, subs, maxn, chop, strict, quad, ...])将给定的公式计算到 n 位精度。
expand(**hints)extract_additively(c)如果可以从自身减去 c 并且使所有匹配的系数趋向于零，则返回 self - c，否则返回 None。
extract_branch_factor([allow_half])尝试以
exp_polar(2*pi*I*n)*z的方式优雅地表达自身。extract_multiplicatively(c)如果无法以一种良好的方式将 self 表示为 c * something，即保留 self 参数的属性，则返回 None。
factor(*gens, **args)参见 sympy.polys.polytools 中的 factor() 函数
find(query[, group])查找所有匹配查询的子表达式。
fourier_series([limits])计算自身的傅里叶正弦/余弦级数。
fps([x, x0, dir, hyper, order, rational, full])计算自身的形式幂级数。
from_index_summation(expr[, first_index, ...])如果可能，将显式求和指标的矩阵表达式解析为无指标的矩阵表达式。
fromiter(args, **assumptions)从可迭代对象创建一个新对象。
gammasimp()参见 sympy.simplify 中的 gammasimp 函数
getO()如果有加法 O(..) 符号，则返回该符号，否则返回 None。
getn()返回表达式的顺序。
has(*patterns)测试是否有任何子表达式匹配任何模式。
has_free(*patterns)如果 self 包含对象
x作为自由表达式，则返回 True，否则返回 False。has_xfree(s)如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
integrate(*args, **kwargs)请参阅 sympy.integrals 中的 integrate 函数。
invert(g, *gens, **args)返回
self对g的乘法逆元，其中self``（和 ``g）可以是符号表达式。is_algebraic_expr(*syms)此测试给定的表达式是否在给定的符号 syms 中是代数的。
is_constant(*wrt, **flags)如果 self 是常量则返回 True，如果不是则返回 False，如果无法明确确定常量性则返回 None。
is_meromorphic(x, a)此测试表达式是否作为给定符号
x的函数在点a处是亚纯的。is_polynomial(*syms)如果 self 是 syms 中的多项式，则返回 True，否则返回 False。
is_rational_function(*syms)测试函数是否是给定符号 syms 中的两个多项式的比率。
is_same(b[, approx])如果 a 和 b 结构相同则返回 True，否则返回 False。
leadterm(x[, logx, cdir])返回前导项 a*x**b 作为元组 (a, b)。
limit(x, xlim[, dir])计算极限 x->xlim。
lseries([x, x0, dir, logx, cdir])用于生成序列项的迭代器的包装器。
match(pattern[, old])模式匹配。
matches(expr[, repl_dict, old])用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
n([n, subs, maxn, chop, strict, quad, verbose])将给定的公式计算到 n 位精度。
normal()返回表达式为分数形式。
nseries([x, x0, n, dir, logx, cdir])如果假设允许，则包装到 _eval_nseries，否则包装到 series。
nsimplify([constants, tolerance, full])参见 sympy.simplify 中的 nsimplify 函数
powsimp(*args, **kwargs)请参阅 sympy.simplify 中的 powsimp 函数
primitive()返回可以从自身每个项中非递归提取的正有理数（即，将自身视为一个加法）。
radsimp(**kwargs)参见 sympy.simplify 中的 radsimp 函数
ratsimp()参见 sympy.simplify 中的 ratsimp 函数。
rcall(*args)通过表达式树递归应用于参数。
refine([assumption])请参阅 sympy.assumptions 中的 refine 函数。
removeO()如果存在，移除加性的 O(..) 符号
replace(query, value[, map, simultaneous, exact])将
self中匹配的子表达式替换为value。rewrite(*args[, deep])使用定义的规则重写 self。
round([n])返回 x 四舍五入到给定的十进制位数。
separate([deep, force])参见 sympy.simplify 中的单独函数
series([x, x0, n, dir, logx, cdir])在
x = x0附近对 "self" 进行级数展开，当 n=None 时逐项给出级数项（即惰性级数），否则当 n != None 时一次性给出所有项。simplify(**kwargs)请参阅 sympy.simplify 中的 simplify 函数。
sort_key([order])subs(*args, **kwargs)在简化参数后，在表达式中用新内容替换旧内容。
taylor_term(n, x, *previous_terms)泰勒项的一般方法。
together(*args, **kwargs)请参阅 sympy.polys 中的 together 函数。
trigsimp(**args)参见 sympy.simplify 中的 trigsimp 函数
xreplace(rule)替换表达式中对象的出现。
伴随
applyfunc
as_base_exp
as_coeff_mmul
规范化
复制
det
差异
目录
evaluate_integral
inv
反向
is_hypergeometric
转置
有效索引
示例
>>> 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)[源代码][源代码]¶
随机矩阵概率表达式的协方差。
- 属性:
- 我
T矩阵转置
args返回 ‘self’ 的参数元组。
assumptions0返回对象 \(type\) 假设。
canonical_variables返回一个字典，将
self.bound_symbols中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。- cols
expr_free_symbols类似于
free_symbols，但仅在自由符号包含在表达式节点中时返回它们。free_symbols从自身的原子中返回那些自由符号。
func表达式中的顶级函数。
- is_Identity
- is_antihermitian
is_comparable如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
- is_finite
- is_hermitian
- is_infinite
- is_polar
- is_square
- 行
- 形状
方法
apart([x])请参阅 sympy.polys 中的 apart 函数。
args_cnc([cset, warn, split_1])返回 [交换因子, 非交换因子] 的自身。
as_coeff_Add([rational])高效地提取求和的系数。
as_coeff_Mul([rational])高效地提取乘积的系数。
as_coeff_add(*deps)返回元组 (c, args)，其中 self 被写成一个 Add，
a。as_coeff_exponent(x)c*x**e -> c,e其中 x 可以是任何符号表达式。as_coeff_mul(*deps, **kwargs)返回元组 (c, args)，其中 self 被写成一个 Mul，
m。as_coefficient(expr)提取给定表达式中的符号系数。
as_coefficients_dict(*syms)返回一个字典，将术语映射到它们的 Rational 系数。
as_content_primitive([radical, clear])此方法应递归地从所有参数中移除一个 Rational，并返回该内容和新的 self（原始类型）。
as_dummy()返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
as_explicit()返回一个元素明确表示的密集矩阵
as_expr(*gens)将多项式转换为 SymPy 表达式。
as_independent(*deps, **hint)将 Mul 或 Add 的大部分天真分离为不依赖于 deps 的参数。
as_leading_term(*symbols[, logx, cdir])返回自身级数展开的主导（非零）项。
as_mutable()返回一个密集的、可变的矩阵，其元素明确表示。
as_numer_denom()返回一个表达式的分子和分母。
as_ordered_factors([order])返回有序因子列表（如果是 Mul），否则返回 [self]。
as_ordered_terms([order, data])将表达式转换为有序的项列表。
as_poly(*gens, **args)将
self转换为多项式，或返回None。as_powers_dict()将自身作为一个因子的字典返回，每个因子都被视为一个幂。
as_real_imag([deep])as_terms()将一个表达式转换为项的列表。
aseries([x, n, bound, hir])自变量的渐近级数展开
atoms(*types)返回构成当前对象的原子。
cancel(*gens, **args)参见 sympy.polys 中的取消函数
class_key()类的好顺序。
coeff(x[, n, right, _first])返回包含
x**n的项中的系数。collect(syms[, func, evaluate, exact, ...])请参阅 sympy.simplify 中的 collect 函数。
combsimp()请参阅 sympy.simplify 中的 combsimp 函数。
compare(other)如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
compute_leading_term(x[, logx])已弃用的函数，用于计算级数的首项。
conjugate()could_extract_minus_sign()如果 self 以 -1 作为前导因子，或在求和中有比正号更多的负号，则返回 True，否则返回 False。
count(query)计算匹配的子表达式的数量。
count_ops([visual])doit(**hints)评估默认情况下不评估的对象，如极限、积分、求和和乘积。
dummy_eq(other[, symbol])比较两个表达式并处理哑符号。
equals(other)在矩阵之间测试逐元素相等性，矩阵类型可能不同
evalf([n, subs, maxn, chop, strict, quad, ...])将给定的公式计算到 n 位精度。
expand(**hints)extract_additively(c)如果可以从自身减去 c 并且使所有匹配的系数趋向于零，则返回 self - c，否则返回 None。
extract_branch_factor([allow_half])尝试以
exp_polar(2*pi*I*n)*z的方式优雅地表达自身。extract_multiplicatively(c)如果无法以一种良好的方式将 self 表示为 c * something，即保留 self 参数的属性，则返回 None。
factor(*gens, **args)参见 sympy.polys.polytools 中的 factor() 函数
find(query[, group])查找所有匹配查询的子表达式。
fourier_series([limits])计算自身的傅里叶正弦/余弦级数。
fps([x, x0, dir, hyper, order, rational, full])计算自身的形式幂级数。
from_index_summation(expr[, first_index, ...])如果可能，将显式求和指标的矩阵表达式解析为无指标的矩阵表达式。
fromiter(args, **assumptions)从可迭代对象创建一个新对象。
gammasimp()参见 sympy.simplify 中的 gammasimp 函数
getO()如果有加法 O(..) 符号，则返回该符号，否则返回 None。
getn()返回表达式的顺序。
has(*patterns)测试是否有任何子表达式匹配任何模式。
has_free(*patterns)如果 self 包含对象
x作为自由表达式，则返回 True，否则返回 False。has_xfree(s)如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
integrate(*args, **kwargs)请参阅 sympy.integrals 中的 integrate 函数。
invert(g, *gens, **args)返回
self对g的乘法逆元，其中self``（和 ``g）可以是符号表达式。is_algebraic_expr(*syms)此测试给定的表达式是否在给定的符号 syms 中是代数的。
is_constant(*wrt, **flags)如果 self 是常量则返回 True，如果不是则返回 False，如果无法明确确定常量性则返回 None。
is_meromorphic(x, a)此测试表达式是否作为给定符号
x的函数在点a处是亚纯的。is_polynomial(*syms)如果 self 是 syms 中的多项式，则返回 True，否则返回 False。
is_rational_function(*syms)测试函数是否是给定符号 syms 中的两个多项式的比率。
is_same(b[, approx])如果 a 和 b 结构相同则返回 True，否则返回 False。
leadterm(x[, logx, cdir])返回前导项 a*x**b 作为元组 (a, b)。
limit(x, xlim[, dir])计算极限 x->xlim。
lseries([x, x0, dir, logx, cdir])用于生成序列项的迭代器的包装器。
match(pattern[, old])模式匹配。
matches(expr[, repl_dict, old])用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
n([n, subs, maxn, chop, strict, quad, verbose])将给定的公式计算到 n 位精度。
normal()返回表达式为分数形式。
nseries([x, x0, n, dir, logx, cdir])如果假设允许，则包装到 _eval_nseries，否则包装到 series。
nsimplify([constants, tolerance, full])参见 sympy.simplify 中的 nsimplify 函数
powsimp(*args, **kwargs)请参阅 sympy.simplify 中的 powsimp 函数
primitive()返回可以从自身每个项中非递归提取的正有理数（即，将自身视为一个加法）。
radsimp(**kwargs)参见 sympy.simplify 中的 radsimp 函数
ratsimp()参见 sympy.simplify 中的 ratsimp 函数。
rcall(*args)通过表达式树递归应用于参数。
refine([assumption])请参阅 sympy.assumptions 中的 refine 函数。
removeO()如果存在，移除加性的 O(..) 符号
replace(query, value[, map, simultaneous, exact])将
self中匹配的子表达式替换为value。rewrite(*args[, deep])使用定义的规则重写 self。
round([n])返回 x 四舍五入到给定的十进制位数。
separate([deep, force])参见 sympy.simplify 中的单独函数
series([x, x0, n, dir, logx, cdir])在
x = x0附近对 "self" 进行级数展开，当 n=None 时逐项给出级数项（即惰性级数），否则当 n != None 时一次性给出所有项。simplify(**kwargs)请参阅 sympy.simplify 中的 simplify 函数。
sort_key([order])subs(*args, **kwargs)在简化参数后，在表达式中用新内容替换旧内容。
taylor_term(n, x, *previous_terms)泰勒项的一般方法。
together(*args, **kwargs)请参阅 sympy.polys 中的 together 函数。
trigsimp(**args)参见 sympy.simplify 中的 trigsimp 函数
xreplace(rule)替换表达式中对象的出现。
伴随
applyfunc
as_base_exp
as_coeff_mmul
规范化
复制
det
差异
目录
evaluate_integral
inv
反向
is_hypergeometric
转置
有效索引
示例
>>> 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 是变量到可能值的映射。例如，我们可以说符号 Symbol('x') 可以取值 \(\{1,2,3,4,5,6\}\)。
一个 PSpace ，或称概率空间，结合了一个 RandomDomain 和一个密度来提供概率信息。例如，上述域可以通过一个有限密度 {1:1/6, 2:1/6, 3:1/6, 4:1/6, 5:1/6, 6:1/6} 来完全定义一个名为 x 的公平骰子的投掷。
RandomSymbol 表示 SymPy 表达式中 PSpace 的符号 ‘x’。
RandomDomain 和 PSpace 类几乎从不直接实例化。相反，它们被用于各种情况的子类化。
RandomDomains 和 PSpaces 必须足够通用，以表示具有任意复杂密度的多个变量的域和空间。这种通用性通常是不必要的。相反，我们通常构建 SingleDomains 和 SinglePSpaces 来表示单一的、单变量的事件和过程，例如单个骰子或单个正态变量。
另一个常见的情况是收集一组这样的单变量随机变量。一组独立的 SinglePSpaces 或 SingleDomains 可以组合在一起形成一个 ProductDomain 或 ProductPSpace。例如，这些对象在表示一起掷三个骰子时会很有用。
每当我们在 RandomDomain 或 PSpace 中添加一个全局条件时，都会添加 Conditional 形容词。一个常见的例子是三个独立的骰子，我们知道它们的总和大于 12。
我们进一步细分为这些类的有限和连续版本，以表示有限（如骰子）和连续（如正态分布）随机变量。
此外，还有一些专门的类实现了某些常见的随机变量类型。例如，有一个 DiePSpace 实现了 SingleFinitePSpace，还有一个 NormalPSpace 实现了 SingleContinuousPSpace。
- class sympy.stats.frv_types.DiePSpace¶
- class sympy.stats.crv_types.NormalPSpace¶
可以使用 PSpace.values 方法从这些对象中提取随机变量。
如前所述，SymPy Stats 采用了相对复杂的类结构。在实现终端类时广泛使用了继承。这种策略的选择是为了在允许 SymPy 表示任意定义的随机变量和优化常见情况之间取得平衡。这使得代码变得复杂，但其结构设计仅对那些扩展 SymPy Stats 以支持其他随机变量类型的人重要。
用户不会直接使用这个类结构。相反，这些机制通过变量创建函数 Die、Coin、FiniteRV、Normal、Exponential 等暴露出来。这些函数构建适当的 SinglePSpaces 并返回相应的 RandomVariable。条件和乘积空间在 SymPy 表达式的自然构造和使用接口函数 E、Given、Density 等时形成。
- sympy.stats.Die()¶
- sympy.stats.Normal()¶
有一些额外的功能可能会有用。它们主要在内部使用。