SymPy-1-13-中文文档-二十九-
SymPy 1.13 中文文档（二十九）
微分几何
介绍
基类参考
class sympy.diffgeom.Manifold(name, dim, **kwargs)
数学流形。
参数：
name : str
流形的名称。
dim : int
流形的维数。
解释
流形是一个在每个点附近局部类似于欧几里得空间的拓扑空间 [1]。尽管如此，这个类并没有提供研究其所代表的流形的拓扑特性的任何手段。
示例
>>> from sympy.diffgeom import Manifold
>>> m = Manifold('M', 2)
>>> m
M
>>> m.dim
2
参考资料
[R175]
en.wikipedia.org/wiki/Manifold
class sympy.diffgeom.Patch(name, manifold, **kwargs)
流形上的一个补丁。
参数：
name : str
补丁的名称。
manifold : 流形
定义坐标系的流形。
解释
坐标补丁，或简称补丁，是流形上一个简单连通的开集，围绕点展开 [1]。在流形上可以有许多不总是包含整个流形的补丁。在这些补丁上可以定义坐标图，允许用实数元组（坐标）参数化补丁上的任意点。
此类不提供研究其所代表的补丁的拓扑特性的任何手段。
示例
>>> from sympy.diffgeom import Manifold, Patch
>>> m = Manifold('M', 2)
>>> p = Patch('P', m)
>>> p
P
>>> p.dim
2
参考资料
[R176]
G. Sussman, J. Wisdom, W. Farr，《函数微分几何》（2013）
class sympy.diffgeom.CoordSystem(name, patch, symbols=None, relations={}, **kwargs)
定义在补丁上的坐标系。
参数：
name : str
坐标系的名称。
patch : 补丁
定义坐标系的补丁。
symbols : 符号列表，可选
定义坐标符号的名称和假设。
relations : 字典，可选
Key 是两个字符串元组，分别是坐标转换前和转换后的系统名称。Value 是转换前的符号元组和转换后表达式的符号元组。
解释
坐标系是一个系统，使用一个或多个坐标来唯一确定流形上的点或其他几何元素的位置 [1]。
通过将 Symbols 传递给 symbols 参数，用户可以定义坐标系统的坐标符号的名称和假设。如果未传递，则这些符号将自动生成，并假定为实值。
通过传递 relations 参数，用户可以定义坐标系之间的转换关系。反向转换和间接转换可以自动找到。如果不传递此参数，则无法进行坐标变换。
示例
我们定义了二维笛卡尔坐标系和极坐标系。
>>> from sympy import symbols, pi, sqrt, atan2, cos, sin
>>> from sympy.diffgeom import Manifold, Patch, CoordSystem
>>> m = Manifold('M', 2)
>>> p = Patch('P', m)
>>> x, y = symbols('x y', real=True)
>>> r, theta = symbols('r theta', nonnegative=True)
>>> relation_dict = {
... ('Car2D', 'Pol'): [(x, y), (sqrt(x**2 + y**2), atan2(y, x))],
... ('Pol', 'Car2D'): [(r, theta), (r*cos(theta), r*sin(theta))]
... }
>>> Car2D = CoordSystem('Car2D', p, (x, y), relation_dict)
>>> Pol = CoordSystem('Pol', p, (r, theta), relation_dict)
symbols 属性返回 CoordinateSymbol 实例。这些符号与用于构建坐标系的符号不同。
>>> Car2D
Car2D
>>> Car2D.dim
2
>>> Car2D.symbols
(x, y)
>>> _[0].func
<class 'sympy.diffgeom.diffgeom.CoordinateSymbol'>
transformation() 方法返回从一个坐标系到另一个坐标系的转换函数。 transform() 方法返回转换后的坐标。
>>> Car2D.transformation(Pol)
Lambda((x, y), Matrix([
[sqrt(x**2 + y**2)],
[ atan2(y, x)]]))
>>> Car2D.transform(Pol)
Matrix([
[sqrt(x**2 + y**2)],
[ atan2(y, x)]])
>>> Car2D.transform(Pol, [1, 2])
Matrix([
[sqrt(5)],
[atan(2)]])
jacobian()方法返回两个系统之间坐标变换的雅可比矩阵。jacobian_determinant()方法返回两个系统之间坐标变换的雅可比行列式。
>>> Pol.jacobian(Car2D)
Matrix([
[cos(theta), -r*sin(theta)],
[sin(theta), r*cos(theta)]])
>>> Pol.jacobian(Car2D, [1, pi/2])
Matrix([
[0, -1],
[1, 0]])
>>> Car2D.jacobian_determinant(Pol)
1/sqrt(x**2 + y**2)
>>> Car2D.jacobian_determinant(Pol, [1,0])
1
参考文献
[R177]
base_oneform(coord_index)
返回基一形式场。此坐标系的基一形式场。它也是矢量场的算子。
base_oneforms()
返回所有基一形式的列表。更多详情请参见此类的base_oneform方法。
base_scalar(coord_index)
返回接受点并返回坐标之一的BaseScalarField。
base_scalars()
返回所有坐标函数的列表。更多详情请参见此类的base_scalar方法。
base_vector(coord_index)
返回基向量场。此坐标系的基向量场。它也是标量场的算子。
base_vectors()
返回所有基向量的列表。更多详情请参见此类的base_vector方法。
coord_function(coord_index)
返回接受点并返回坐标之一的BaseScalarField。
coord_functions()
返回所有坐标函数的列表。更多详情请参见此类的base_scalar方法。
coord_tuple_transform_to(to_sys, coords)
将coords转换到坐标系to_sys。
jacobian(sys, coordinates=None)
返回给定坐标变换的雅可比矩阵。如果未给出坐标，则使用self的坐标符号。
参数：
sys：CoordSystem
coordinates：任何可迭代对象，可选。
返回：
sympy.ImmutableDenseMatrix
示例
>>> from sympy.diffgeom.rn import R2_r, R2_p
>>> R2_p.jacobian(R2_r)
Matrix([
[cos(theta), -rho*sin(theta)],
[sin(theta), rho*cos(theta)]])
>>> R2_p.jacobian(R2_r, [1, 0])
Matrix([
[1, 0],
[0, 1]])
jacobian_determinant(sys, coordinates=None)
返回给定坐标变换的雅可比行列式。如果未给出坐标，则使用self的坐标符号。
参数：
sys：CoordSystem
coordinates：任何可迭代对象，可选。
返回：
sympy.Expr
示例
>>> from sympy.diffgeom.rn import R2_r, R2_p
>>> R2_r.jacobian_determinant(R2_p)
1/sqrt(x**2 + y**2)
>>> R2_r.jacobian_determinant(R2_p, [1, 0])
1
jacobian_matrix(sys, coordinates=None)
返回给定坐标变换的雅可比矩阵。如果未给出坐标，则使用self的坐标符号。
参数：
sys：CoordSystem
coordinates：任何可迭代对象，可选。
返回：
sympy.ImmutableDenseMatrix
示例
>>> from sympy.diffgeom.rn import R2_r, R2_p
>>> R2_p.jacobian(R2_r)
Matrix([
[cos(theta), -rho*sin(theta)],
[sin(theta), rho*cos(theta)]])
>>> R2_p.jacobian(R2_r, [1, 0])
Matrix([
[1, 0],
[0, 1]])
point(coords)
使用在此坐标系中给定的坐标创建一个Point。
point_to_coords(point)
计算此坐标系中某点的坐标。
transform(sys, coordinates=None)
返回从self到sys的坐标变换结果。如果未给出坐标，则使用self的坐标符号。
参数：
sys：CoordSystem
coordinates：任何可迭代对象，可选。
返回：
包含 CoordinateSymbol 的 sympy.ImmutableDenseMatrix
示例
>>> from sympy.diffgeom.rn import R2_r, R2_p
>>> R2_r.transform(R2_p)
Matrix([
[sqrt(x**2 + y**2)],
[ atan2(y, x)]])
>>> R2_r.transform(R2_p, [0, 1])
Matrix([
[ 1],
[pi/2]])
transformation(sys)
返回从self到sys的坐标转换函数。
参数：
sys：CoordSystem
返回：
sympy.Lambda
示例
>>> from sympy.diffgeom.rn import R2_r, R2_p
>>> R2_r.transformation(R2_p)
Lambda((x, y), Matrix([
[sqrt(x**2 + y**2)],
[ atan2(y, x)]]))
class sympy.diffgeom.CoordinateSymbol(coord_sys, index, **assumptions)
表示具有给定上下文中第 i 个坐标系统的抽象值的符号。
参数：
coord_sys：CoordSystem
index：整数
解释
每个坐标系中的坐标由唯一符号表示，例如在笛卡尔坐标系中的 x、y、z。
您不能直接构造此类。而是使用 CoordSystem 的symbols方法。
示例
>>> from sympy import symbols, Lambda, Matrix, sqrt, atan2, cos, sin
>>> from sympy.diffgeom import Manifold, Patch, CoordSystem
>>> m = Manifold('M', 2)
>>> p = Patch('P', m)
>>> x, y = symbols('x y', real=True)
>>> r, theta = symbols('r theta', nonnegative=True)
>>> relation_dict = {
... ('Car2D', 'Pol'): Lambda((x, y), Matrix([sqrt(x**2 + y**2), atan2(y, x)])),
... ('Pol', 'Car2D'): Lambda((r, theta), Matrix([r*cos(theta), r*sin(theta)]))
... }
>>> Car2D = CoordSystem('Car2D', p, [x, y], relation_dict)
>>> Pol = CoordSystem('Pol', p, [r, theta], relation_dict)
>>> x, y = Car2D.symbols
CoordinateSymbol包含其坐标符号和索引。
>>> x.name
'x'
>>> x.coord_sys == Car2D
True
>>> x.index
0
>>> x.is_real
True
您可以使用 rewrite() 方法将 CoordinateSymbol 转换为其他坐标系。
>>> x.rewrite(Pol)
r*cos(theta)
>>> sqrt(x**2 + y**2).rewrite(Pol).simplify()
r
class sympy.diffgeom.Point(coord_sys, coords, **kwargs)
在坐标系中定义的点。
参数：
coord_sys : 坐标系
coords : 列表
点的坐标。
解释
从数学上讲，点在流形中定义，本身没有任何坐标。坐标系通过坐标图为点赋予坐标。然而，由于实现这种逻辑的困难，您必须提供一个坐标系和坐标来定义此处的点。
在定义后，该对象的使用与用于定义它的坐标系无关，但由于简化程序的限制，如果使用不当的坐标系，可能会得到复杂的表达式。
示例
>>> from sympy import pi
>>> from sympy.diffgeom import Point
>>> from sympy.diffgeom.rn import R2, R2_r, R2_p
>>> rho, theta = R2_p.symbols
>>> p = Point(R2_p, [rho, 3*pi/4])
>>> p.manifold == R2
True
>>> p.coords()
Matrix([
[ rho],
[3*pi/4]])
>>> p.coords(R2_r)
Matrix([
[-sqrt(2)*rho/2],
[ sqrt(2)*rho/2]])
coords(sys=None)
在给定坐标系中点的坐标。如果未传递坐标系，则返回在定义点的坐标系中的坐标。
class sympy.diffgeom.BaseScalarField(coord_sys, index, **kwargs)
在给定的坐标系中的基标量场。
参数：
coord_sys : 坐标系
index : 整数
解释
标量场接受点作为参数并返回标量。坐标系的基标量场接受点并返回该点在讨论中的坐标系中的其中一个坐标。
要定义标量场，您需要选择坐标系和坐标的索引。
在定义后，标量场的使用与其定义时所用的坐标系无关，但由于简化程序的限制，如果使用不适当的坐标系，可能会得到更复杂的表达式。您可以通过构建包含 BaseScalarField 实例的 SymPy 表达式来构建复杂的标量场。
示例
>>> from sympy import Function, pi
>>> from sympy.diffgeom import BaseScalarField
>>> from sympy.diffgeom.rn import R2_r, R2_p
>>> rho, _ = R2_p.symbols
>>> point = R2_p.point([rho, 0])
>>> fx, fy = R2_r.base_scalars()
>>> ftheta = BaseScalarField(R2_r, 1)
>>> fx(point)
rho
>>> fy(point)
0
>>> (fx**2+fy**2).rcall(point)
rho**2
>>> g = Function('g')
>>> fg = g(ftheta-pi)
>>> fg.rcall(point)
g(-pi)
class sympy.diffgeom.BaseVectorField(coord_sys, index, **kwargs)
对于给定的坐标系的基向量场。
参数：
coord_sys : 坐标系
index : 整数
解释
向量场是接受标量场并返回方向导数（也是标量场）的运算符。基向量场是相同类型的运算符，但导数特别是相对于选择的坐标进行的。
要定义基向量场，您需要选择坐标系和坐标的索引。
在定义后，向量场的使用与其定义时所用的坐标系无关，但由于简化程序的限制，如果使用不适当的坐标系，可能会得到更复杂的表达式。
示例
>>> from sympy import Function
>>> from sympy.diffgeom.rn import R2_p, R2_r
>>> from sympy.diffgeom import BaseVectorField
>>> from sympy import pprint
>>> x, y = R2_r.symbols
>>> rho, theta = R2_p.symbols
>>> fx, fy = R2_r.base_scalars()
>>> point_p = R2_p.point([rho, theta])
>>> point_r = R2_r.point([x, y])
>>> g = Function('g')
>>> s_field = g(fx, fy)
>>> v = BaseVectorField(R2_r, 1)
>>> pprint(v(s_field))
/ d \|
|---(g(x, xi))||
\dxi /|xi=y
>>> pprint(v(s_field).rcall(point_r).doit())
d
--(g(x, y))
dy
>>> pprint(v(s_field).rcall(point_p))
/ d \|
|---(g(rho*cos(theta), xi))||
\dxi /|xi=rho*sin(theta)
class sympy.diffgeom.Commutator(v1, v2)
两个向量场的交换子。
解释
两个向量场 (v_1) 和 (v_2) 的交换子定义为向量场 ([v_1, v_2])，该向量场在每个标量场 (f) 上的作用等于 (v_1(v_2(f)) - v_2(v_1(f)))。
示例
>>> from sympy.diffgeom.rn import R2_p, R2_r
>>> from sympy.diffgeom import Commutator
>>> from sympy import simplify
>>> fx, fy = R2_r.base_scalars()
>>> e_x, e_y = R2_r.base_vectors()
>>> e_r = R2_p.base_vector(0)
>>> c_xy = Commutator(e_x, e_y)
>>> c_xr = Commutator(e_x, e_r)
>>> c_xy
0
不幸的是，当前代码无法计算所有内容：
>>> c_xr
Commutator(e_x, e_rho)
>>> simplify(c_xr(fy**2))
-2*cos(theta)*y**2/(x**2 + y**2)
class sympy.diffgeom.Differential(form_field)
返回一个形式场的微分（外导数）。
解释
一个形式的微分（即外微分）在一般情况下有一个复杂的定义。对于任何矢量场 (v)，0-形式 (f) 的微分 (df) 定义为 (df(v) = v(f))。
例子
>>> from sympy import Function
>>> from sympy.diffgeom.rn import R2_r
>>> from sympy.diffgeom import Differential
>>> from sympy import pprint
>>> fx, fy = R2_r.base_scalars()
>>> e_x, e_y = R2_r.base_vectors()
>>> g = Function('g')
>>> s_field = g(fx, fy)
>>> dg = Differential(s_field)
>>> dg
d(g(x, y))
>>> pprint(dg(e_x))
/ d \|
|---(g(xi, y))||
\dxi /|xi=x
>>> pprint(dg(e_y))
/ d \|
|---(g(x, xi))||
\dxi /|xi=y
应用外微分算子两次总是得到：
>>> Differential(dg)
0
class sympy.diffgeom.TensorProduct(*args)
形式的张量积。
解释
张量积允许从较低阶场（例如 1-形式和矢量场）创建多线性泛函（即高阶张量）。然而，因此创建的高阶张量缺乏由楔积提供的有趣特征，即它们不是反对称的，因此不是形式场。
例子
>>> from sympy.diffgeom.rn import R2_r
>>> from sympy.diffgeom import TensorProduct
>>> fx, fy = R2_r.base_scalars()
>>> e_x, e_y = R2_r.base_vectors()
>>> dx, dy = R2_r.base_oneforms()
>>> TensorProduct(dx, dy)(e_x, e_y)
1
>>> TensorProduct(dx, dy)(e_y, e_x)
0
>>> TensorProduct(dx, fx*dy)(fx*e_x, e_y)
x**2
>>> TensorProduct(e_x, e_y)(fx**2, fy**2)
4*x*y
>>> TensorProduct(e_y, dx)(fy)
dx
您可以嵌套张量积。
>>> tp1 = TensorProduct(dx, dy)
>>> TensorProduct(tp1, dx)(e_x, e_y, e_x)
1
您可以部分缩并，例如在‘升指标’时。在 rcall 的第二个参数中放入 None 意味着在张量积中该位置保持不变。
>>> TP = TensorProduct
>>> metric = TP(dx, dx) + 3*TP(dy, dy)
>>> metric.rcall(e_y, None)
3*dy
或自动使用 None 填充参数而不指定它们。
>>> metric.rcall(e_y)
3*dy
class sympy.diffgeom.WedgeProduct(*args)
形式的楔积。
解释
在积分的上下文中，只有完全反对称的形式才有意义。楔积允许创建这种形式。
例子
>>> from sympy.diffgeom.rn import R2_r
>>> from sympy.diffgeom import WedgeProduct
>>> fx, fy = R2_r.base_scalars()
>>> e_x, e_y = R2_r.base_vectors()
>>> dx, dy = R2_r.base_oneforms()
>>> WedgeProduct(dx, dy)(e_x, e_y)
1
>>> WedgeProduct(dx, dy)(e_y, e_x)
-1
>>> WedgeProduct(dx, fx*dy)(fx*e_x, e_y)
x**2
>>> WedgeProduct(e_x, e_y)(fy, None)
-e_x
您可以嵌套楔积。
>>> wp1 = WedgeProduct(dx, dy)
>>> WedgeProduct(wp1, dx)(e_x, e_y, e_x)
0
class sympy.diffgeom.LieDerivative(v_field, expr)
对于某个矢量场的李导数。
解释
定义李导数的传输算子是沿着场的积分曲线推动场而得到的。
例子
>>> from sympy.diffgeom.rn import R2_r, R2_p
>>> from sympy.diffgeom import (LieDerivative, TensorProduct)
>>> fx, fy = R2_r.base_scalars()
>>> e_x, e_y = R2_r.base_vectors()
>>> e_rho, e_theta = R2_p.base_vectors()
>>> dx, dy = R2_r.base_oneforms()
>>> LieDerivative(e_x, fy)
0
>>> LieDerivative(e_x, fx)
1
>>> LieDerivative(e_x, e_x)
0
一个张量场的李导数由另一个张量场的对易算子定义：
>>> LieDerivative(e_x, e_rho)
Commutator(e_x, e_rho)
>>> LieDerivative(e_x + e_y, fx)
1
>>> tp = TensorProduct(dx, dy)
>>> LieDerivative(e_x, tp)
LieDerivative(e_x, TensorProduct(dx, dy))
>>> LieDerivative(e_x, tp)
LieDerivative(e_x, TensorProduct(dx, dy))
class sympy.diffgeom.BaseCovarDerivativeOp(coord_sys, index, christoffel)
对于基向量的协变导数算子。
例子
>>> from sympy.diffgeom.rn import R2_r
>>> from sympy.diffgeom import BaseCovarDerivativeOp
>>> from sympy.diffgeom import metric_to_Christoffel_2nd, TensorProduct
>>> TP = TensorProduct
>>> fx, fy = R2_r.base_scalars()
>>> e_x, e_y = R2_r.base_vectors()
>>> dx, dy = R2_r.base_oneforms()
>>> ch = metric_to_Christoffel_2nd(TP(dx, dx) + TP(dy, dy))
>>> ch
[[[0, 0], [0, 0]], [[0, 0], [0, 0]]]
>>> cvd = BaseCovarDerivativeOp(R2_r, 0, ch)
>>> cvd(fx)
1
>>> cvd(fx*e_x)
e_x
class sympy.diffgeom.CovarDerivativeOp(wrt, christoffel)
协变导数算子。
例子
>>> from sympy.diffgeom.rn import R2_r
>>> from sympy.diffgeom import CovarDerivativeOp
>>> from sympy.diffgeom import metric_to_Christoffel_2nd, TensorProduct
>>> TP = TensorProduct
>>> fx, fy = R2_r.base_scalars()
>>> e_x, e_y = R2_r.base_vectors()
>>> dx, dy = R2_r.base_oneforms()
>>> ch = metric_to_Christoffel_2nd(TP(dx, dx) + TP(dy, dy))
>>> ch
[[[0, 0], [0, 0]], [[0, 0], [0, 0]]]
>>> cvd = CovarDerivativeOp(fx*e_x, ch)
>>> cvd(fx)
x
>>> cvd(fx*e_x)
x*e_x
sympy.diffgeom.intcurve_series(vector_field, param, start_point, n=6, coord_sys=None, coeffs=False)
返回场的积分曲线的级数展开。
参数：
vector_field
将给定的矢量场的积分曲线
param
函数 (\gamma) 的参数从 (R) 到曲线
start_point
对应于 (\gamma(0)) 的点
n
要扩展的顺序
coord_sys
在其中展开 coeffs 的坐标系（默认为 False） - 如果为 True，则返回展开元素的列表
解释
积分曲线是一个函数 (\gamma)，将参数从 (R) 映射到流形上的一个点。它满足以下方程：
(V(f)\big(\gamma(t)\big) = \frac{d}{dt}f\big(\gamma(t)\big))
其中给定的 vector_field 被表示为 (V)。这对于参数的任何值 (t) 和任何标量场 (f) 都成立。
此方程还可以分解为坐标函数基础 (V(f_i)\big(\gamma(t)\big) = \frac{d}{dt}f_i\big(\gamma(t)\big) \quad \forall i)
此函数返回 (\gamma(t)) 的坐标系 coord_sys 的级数展开。方程和展开必须以坐标系依赖的方式完成，因为在一般流形上表示点之间的移动没有其他方法（即一般流形上不存在点的差异）。
例子
使用预定义的 R2 流形：
>>> from sympy.abc import t, x, y
>>> from sympy.diffgeom.rn import R2_p, R2_r
>>> from sympy.diffgeom import intcurve_series
指定起点和矢量场：
>>> start_point = R2_r.point([x, y])
>>> vector_field = R2_r.e_x
计算级数：
>>> intcurve_series(vector_field, t, start_point, n=3)
Matrix([
[t + x],
[ y]])
或者在列表中获取扩展的元素：
>>> series = intcurve_series(vector_field, t, start_point, n=3, coeffs=True)
>>> series[0]
Matrix([
[x],
[y]])
>>> series[1]
Matrix([
[t],
[0]])
>>> series[2]
Matrix([
[0],
[0]])
极坐标系中的级数：
>>> series = intcurve_series(vector_field, t, start_point,
... n=3, coord_sys=R2_p, coeffs=True)
>>> series[0]
Matrix([
[sqrt(x**2 + y**2)],
[ atan2(y, x)]])
>>> series[1]
Matrix([
[t*x/sqrt(x**2 + y**2)],
[ -t*y/(x**2 + y**2)]])
>>> series[2]
Matrix([
[t**2*(-x**2/(x**2 + y**2)**(3/2) + 1/sqrt(x**2 + y**2))/2],
[ t**2*x*y/(x**2 + y**2)**2]])
另见
intcurve_diffequ
sympy.diffgeom.intcurve_diffequ(vector_field, param, start_point, coord_sys=None)
返回场的积分曲线的微分方程。
参数：
向量场
将给定的向量场用于给定积分曲线。
参数
函数(\gamma)的参数从(R)到曲线的论点
起始点
对应于(\gamma(0))的点
coord_sys
给出方程的坐标系。
返回：
(方程，初始条件)的元组
解释
积分曲线是一个函数(\gamma)，将参数映射到流形上的点。它满足以下方程：
(V(f)\big(\gamma(t)\big) = \frac{d}{dt}f\big(\gamma(t)\big))
给定vector_field被标记为(V)。这对于参数的任何值(t)和任何标量场(f)都成立。
此函数返回(\gamma(t))在坐标系coord_sys中的微分方程。方程和展开必须以依赖于坐标系的方式进行，因为在一般流形上表示点之间的移动没有其他方式（即通用流形上没有点的差异）。
示例
使用预定义的 R2 流形：
>>> from sympy.abc import t
>>> from sympy.diffgeom.rn import R2, R2_p, R2_r
>>> from sympy.diffgeom import intcurve_diffequ
指定起始点和向量场：
>>> start_point = R2_r.point([0, 1])
>>> vector_field = -R2.y*R2.e_x + R2.x*R2.e_y
获取方程：
>>> equations, init_cond = intcurve_diffequ(vector_field, t, start_point)
>>> equations
[f_1(t) + Derivative(f_0(t), t), -f_0(t) + Derivative(f_1(t), t)]
>>> init_cond
[f_0(0), f_1(0) - 1]
极坐标系中的级数：
>>> equations, init_cond = intcurve_diffequ(vector_field, t, start_point, R2_p)
>>> equations
[Derivative(f_0(t), t), Derivative(f_1(t), t) - 1]
>>> init_cond
[f_0(0) - 1, f_1(0) - pi/2]
另见
intcurve_series
sympy.diffgeom.vectors_in_basis(expr, to_sys)
将所有基向量转换为指定坐标基的基向量。新的基向量位于新的坐标系统基础上，任何系数都保留在旧系统中。
示例
>>> from sympy.diffgeom import vectors_in_basis
>>> from sympy.diffgeom.rn import R2_r, R2_p
>>> vectors_in_basis(R2_r.e_x, R2_p)
-y*e_theta/(x**2 + y**2) + x*e_rho/sqrt(x**2 + y**2)
>>> vectors_in_basis(R2_p.e_r, R2_r)
sin(theta)*e_y + cos(theta)*e_x
sympy.diffgeom.twoform_to_matrix(expr)
返回表示二形式的矩阵。
对于二形式(w)，返回矩阵(M)，使得(M[i,j]=w(e_i, e_j))，其中(e_i)是给定表达式的坐标系的第 i 个基向量场。
示例
>>> from sympy.diffgeom.rn import R2
>>> from sympy.diffgeom import twoform_to_matrix, TensorProduct
>>> TP = TensorProduct
>>> twoform_to_matrix(TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy))
Matrix([
[1, 0],
[0, 1]])
>>> twoform_to_matrix(R2.x*TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy))
Matrix([
[x, 0],
[0, 1]])
>>> twoform_to_matrix(TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy) - TP(R2.dx, R2.dy)/2)
Matrix([
[ 1, 0],
[-1/2, 1]])
sympy.diffgeom.metric_to_Christoffel_1st(expr)
返回给定度量的 Christoffel 符号的嵌套列表。这返回了第一类 Christoffel 符号，代表了给定度量的 Levi-Civita 联络。
示例
>>> from sympy.diffgeom.rn import R2
>>> from sympy.diffgeom import metric_to_Christoffel_1st, TensorProduct
>>> TP = TensorProduct
>>> metric_to_Christoffel_1st(TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy))
[[[0, 0], [0, 0]], [[0, 0], [0, 0]]]
>>> metric_to_Christoffel_1st(R2.x*TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy))
[[[1/2, 0], [0, 0]], [[0, 0], [0, 0]]]
sympy.diffgeom.metric_to_Christoffel_2nd(expr)
返回给定度量的 Christoffel 符号的嵌套列表。这返回了第二类 Christoffel 符号，代表了给定度量的 Levi-Civita 联络。
示例
>>> from sympy.diffgeom.rn import R2
>>> from sympy.diffgeom import metric_to_Christoffel_2nd, TensorProduct
>>> TP = TensorProduct
>>> metric_to_Christoffel_2nd(TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy))
[[[0, 0], [0, 0]], [[0, 0], [0, 0]]]
>>> metric_to_Christoffel_2nd(R2.x*TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy))
[[[1/(2*x), 0], [0, 0]], [[0, 0], [0, 0]]]
sympy.diffgeom.metric_to_Riemann_components(expr)
返回在给定基础上表达的 Riemann 张量的分量。
给定度量，它计算度量表达式给出的坐标系的标准基础中 Riemann 张量的分量。
示例
>>> from sympy import exp
>>> from sympy.diffgeom.rn import R2
>>> from sympy.diffgeom import metric_to_Riemann_components, TensorProduct
>>> TP = TensorProduct
>>> metric_to_Riemann_components(TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy))
[[[[0, 0], [0, 0]], [[0, 0], [0, 0]]], [[[0, 0], [0, 0]], [[0, 0], [0, 0]]]]
>>> non_trivial_metric = exp(2*R2.r)*TP(R2.dr, R2.dr) + R2.r**2*TP(R2.dtheta, R2.dtheta)
>>> non_trivial_metric
exp(2*rho)*TensorProduct(drho, drho) + rho**2*TensorProduct(dtheta, dtheta)
>>> riemann = metric_to_Riemann_components(non_trivial_metric)
>>> riemann[0, :, :, :]
[[[0, 0], [0, 0]], [[0, exp(-2*rho)*rho], [-exp(-2*rho)*rho, 0]]]
>>> riemann[1, :, :, :]
[[[0, -1/rho], [1/rho, 0]], [[0, 0], [0, 0]]]
sympy.diffgeom.metric_to_Ricci_components(expr)
返回在给定基础上表达的 Ricci 张量的分量。
给定度量，它计算度量表达式给出的坐标系的标准基础中 Ricci 张量的分量。
示例
>>> from sympy import exp
>>> from sympy.diffgeom.rn import R2
>>> from sympy.diffgeom import metric_to_Ricci_components, TensorProduct
>>> TP = TensorProduct
>>> metric_to_Ricci_components(TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy))
[[0, 0], [0, 0]]
>>> non_trivial_metric = exp(2*R2.r)*TP(R2.dr, R2.dr) + R2.r**2*TP(R2.dtheta, R2.dtheta)
>>> non_trivial_metric
exp(2*rho)*TensorProduct(drho, drho) + rho**2*TensorProduct(dtheta, dtheta)
>>> metric_to_Ricci_components(non_trivial_metric)
[[1/rho, 0], [0, exp(-2*rho)*rho]]
绘图
简介
绘图模块允许您制作二维和三维图。当前，绘图使用matplotlib作为后端渲染。如果您没有matplotlib，也可以使用TextBackend绘制二维图。
绘图模块包含以下函数：
-
plot()：绘制二维线图。 -
plot_parametric()：绘制二维参数化图。 -
plot_implicit()：绘制二维隐式和区域图。 -
plot3d()：绘制二变量函数的三维图。 -
plot3d_parametric_line()：绘制由参数定义的三维线图。 -
plot3d_parametric_surface()：绘制三维参数化表面图。
上述函数仅用于方便和易用性。通过将相应的Series类传递给Plot，可以绘制任何绘图。
绘图类
class sympy.plotting.plot.Plot(*args, title=None, xlabel=None, ylabel=None, zlabel=None, aspect_ratio='auto', xlim=None, ylim=None, axis_center='auto', axis=True, xscale='linear', yscale='linear', legend=False, autoscale=True, margin=0, annotations=None, markers=None, rectangles=None, fill=None, backend='default', size=None, **kwargs)
所有后端的基类。后端表示绘图库，它实现了必要的功能，以便使用 SymPy 绘图函数。
对于交互式工作，函数plot()更适合。
此类允许使用多个后端（matplotlib、文本绘图、旧的 SymPy pyglet 模块、Google Charts API 等）绘制 SymPy 表达式。
图形可以包含任意数量的 SymPy 表达式、点坐标列表等的绘图。绘图类有一个私有属性 _series，其中包含所有要绘制的数据系列（线条或表面的表达式、点列表等（所有 BaseSeries 的子类））。这些数据系列是由from sympy import *未导入的类的实例。
图形的定制有两个级别。全局选项涉及整个图形（例如标题、xlabel、scale 等），数据系列选项涉及每个数据系列（例如名称）和美学效果（例如颜色、点形状、线型等）。
选项和美学之间的区别在于，美学可以是坐标的函数（或参数在参数化图中）。美学支持的值有：
-
None（后端使用默认值）
-
一个常数
-
一个变量的函数（第一个坐标或参数）
-
两个变量的函数（第一个和第二个坐标或参数）
-
一个三个变量的函数（仅适用于非参数化的 3D 绘图）
它们的实现取决于后端，因此在某些后端中可能无法工作。
如果绘图是参数化的，美学函数的阶数允许它，美学是在参数上计算的而不是在坐标上计算的。如果阶数不允许在参数上计算，则在坐标上进行计算。
目前仅支持笛卡尔坐标，但您可以使用参数化绘图在极坐标、球坐标和柱坐标中绘制。
构造函数 Plot 的参数必须是 BaseSeries 的子类。
任何全局选项都可以指定为关键字参数。
图的全局选项包括：
-
title : str
-
xlabel : str or Symbol
-
ylabel : str or Symbol
-
zlabel : str or Symbol
-
legend : bool
-
xscale :
-
yscale :
-
axis : bool
-
axis_center : tuple of two floats or
-
xlim : tuple of two floats
-
ylim : tuple of two floats
-
aspect_ratio : tuple of two floats or
-
autoscale : bool
-
margin : float in [0, 1]
-
backend : {‘default’, ‘matplotlib’, ‘text’} 或者 BaseBackend 的子类
-
size : optional tuple of two floats, (width, height); default: None
每个数据系列的选项和美学是：在基本系列中没有。有关子类的选项，请参阅下文。
一些数据系列支持额外的美学或选项：
LineOver1DRangeSeries，Parametric2DLineSeries和Parametric3DLineSeries支持以下功能：
美学：
-
line_color 字符串、浮点数或函数，可选
指定绘图的颜色，这取决于使用的后端。
例如，如果使用的是
MatplotlibBackend，那么 Matplotlib 的字符串颜色是可以接受的（"red"，"r"，"cyan"，"c"，...）。或者，我们可以使用一个浮点数，0 < color < 1，包裹在字符串中（例如，line_color="0.5"）来指定灰度颜色。另外，我们可以指定一个返回单个浮点值的函数：这将用于应用颜色循环（例如，line_color=lambda x: math.cos(x)）。请注意，通过设置
line_color，它将同时应用于所有的数据系列。
选项：
-
label : str
-
steps : bool
-
integers_only : bool
SurfaceOver2DRangeSeries和ParametricSurfaceSeries支持以下内容：
美观：
- surface_color：返回浮点数的函数。
注意事项
绘图模块的工作方式：
-
每当调用绘图函数时，处理提供的表达式并创建
BaseSeries类的实例列表，其中包含绘制表达式所需的信息（例如表达式、范围、系列名称等）。最终，这些对象将生成要绘制的数值数据。 -
实例化
Plot类的子类（从现在起称为后端），其中存储系列列表和绘图的主要属性（例如坐标轴标签、标题等）。后端实现生成实际图形的逻辑，使用某些绘图库。 -
当执行
show命令时，数据系列会逐个处理以生成数值数据，并根据 Plot 实例中存储的值设置坐标轴标签、标题等。
后端应检查其是否支持提供的数据系列（例如TextBackend仅支持LineOver1DRangeSeries）。
后端需要知道如何使用它所提供的数据系列类。注意，当前实现的*Series类是“matplotlib 中心”的：get_points和get_meshes方法返回的数值数据预期直接供 Matplotlib 使用。因此，新的后端需要预处理数值数据，使其兼容所选的绘图库。请注意，未来的 SymPy 版本可能改进*Series类，以返回“非 matplotlib 中心”的数值数据，因此如果您编写新的后端，必须负责在每个 SymPy 版本上检查其是否有效。
请查看MatplotlibBackend源代码，了解后端应如何编码。
为了供 SymPy 绘图函数使用，后端必须实现以下方法：
-
show(self)：用于循环处理数据系列，生成数值数据。
数据，绘制它，并设置坐标轴标签、标题等。
-
save(self, path)：用于将当前绘图保存到指定的文件中。
路径。
-
close(self)：用于关闭当前的绘图后端（注意：某些绘图
库不支持此功能。在这种情况下，只需发出警告）。
property annotations
自版本 1.13 起弃用。
append(arg)
将一个图的系列的元素添加到现有图中。
示例
考虑两个 Plot 对象，p1 和 p2。要将第二个图的第一个系列对象添加到第一个图中，请使用 append 方法，如下所示：
>>> from sympy import symbols
>>> from sympy.plotting import plot
>>> x = symbols('x')
>>> p1 = plot(x*x, show=False)
>>> p2 = plot(x, show=False)
>>> p1.append(p2[0])
>>> p1
Plot object containing:
[0]: cartesian line: x**2 for x over (-10.0, 10.0)
[1]: cartesian line: x for x over (-10.0, 10.0)
>>> p1.show()
(png, hires.png, pdf)
另请参阅
extend
extend(arg)
从另一个图中添加所有系列。
示例
考虑两个 Plot 对象，p1 和 p2。要将第二个图添加到第一个图中，请使用 extend 方法，如下所示：
>>> from sympy import symbols
>>> from sympy.plotting import plot
>>> x = symbols('x')
>>> p1 = plot(x**2, show=False)
>>> p2 = plot(x, -x, show=False)
>>> p1.extend(p2)
>>> p1
Plot object containing:
[0]: cartesian line: x**2 for x over (-10.0, 10.0)
[1]: cartesian line: x for x over (-10.0, 10.0)
[2]: cartesian line: -x for x over (-10.0, 10.0)
>>> p1.show()
(png, hires.png, pdf)
property fill
自 1.13 版本起已弃用。
property markers
自 1.13 版本起已弃用。
property rectangles
自 1.13 版本起已弃用。
绘图函数参考
sympy.plotting.plot.plot(*args, show=True, **kwargs)
将单变量函数绘制为曲线。
参数：
args :
第一个参数是表示要绘制的单变量函数的表达式。
最后一个参数是表示自由变量范围的三元组。例如
(x, 0, 5)典型用法示例如下：
绘制单一表达式和单一范围。
plot(expr, range, **kwargs)绘制单一表达式，默认范围为 (-10, 10)。
plot(expr, **kwargs)用单一范围绘制多个表达式。
plot(expr1, expr2, ..., range, **kwargs)绘制多个表达式和多个范围。
plot((expr1, range1), (expr2, range2), ..., **kwargs)最佳实践是显式指定范围，因为如果实施更高级的默认范围检测算法，可能会更改默认范围。
show：布尔值，可选
默认值设置为
True。将show设置为False，函数将不显示绘图。然后可以通过调用save()和show()方法来保存或显示Plot类的返回实例。
line_color：字符串、浮点数或函数，可选
指定绘图的颜色。请参阅
Plot以了解如何设置绘图颜色。注意，通过设置line_color，可以同时应用于所有系列。
title：字符串，可选
绘图的标题。如果图仅有一个表达式，则设置为表达式的 LaTeX 表示。
label：字符串，可选
图中表达式的标签。调用
legend时将使用该标签。默认为表达式的名称。例如sin(x)
xlabel：字符串或表达式，可选
x 轴的标签。
ylabel：字符串或表达式，可选
y 轴的标签。
xscale：'linear' 或 'log'，可选
设置 x 轴的缩放。
yscale : ‘linear’ or ‘log’, optional
设置 y 轴的缩放。
axis_center : (float, float), optional
两个浮点数元组，表示中心的坐标或者
xlim : (float, float), optional
表示 x 轴限制的
(min, max)。
ylim : (float, float), optional
表示 y 轴限制的
(min, max)。
annotations : list, optional
一系列字典，指定所需注释的类型。字典中的键应当与
matplotlib的annotate()方法的参数相对应。
markers : list, optional
一系列字典，指定所需标记的类型。字典中的键应当与
matplotlib的plot()函数的参数及其与标记相关的关键参数相对应。
rectangles : list, optional
一系列字典，指定要绘制的矩形的尺寸。字典中的键应当与
matplotlib的Rectangle类的参数相对应。
fill : dict, optional
绘图所需的颜色填充类型的字典。字典中的键应当与
matplotlib的fill_between()方法的参数相对应。
adaptive : bool, optional
默认值设置为
True。将 adaptive 设置为False并指定n以进行均匀采样。绘图使用自适应算法递归采样以准确绘制。自适应算法使用接近两点中点附近的随机点进行进一步采样。因此，相同的绘图可能会略有不同。
depth : int, optional
自适应算法的递归深度。深度值为(n)时最多采样(2^{n})个点。
如果
adaptive标志设置为False，则此项将被忽略。
n : int, optional
当
adaptive设置为False时使用。函数在n个点处均匀采样。如果adaptive标志设置为True，则将被忽略。此关键字参数替换了nb_of_points，应视为已弃用。
size：(float, float)，可选
以英寸为单位的元组形式（宽度，高度）来指定整个图形的大小。默认值为
None，意味着大小将由默认后端设置。
示例
>>> from sympy import symbols
>>> from sympy.plotting import plot
>>> x = symbols('x')
单一绘图
>>> plot(x**2, (x, -5, 5))
Plot object containing:
[0]: cartesian line: x**2 for x over (-5.0, 5.0)
(png, hires.png, pdf)
单一范围内的多个绘图。
>>> plot(x, x**2, x**3, (x, -5, 5))
Plot object containing:
[0]: cartesian line: x for x over (-5.0, 5.0)
[1]: cartesian line: x**2 for x over (-5.0, 5.0)
[2]: cartesian line: x**3 for x over (-5.0, 5.0)
(png, hires.png, pdf)
使用不同范围绘制多个图形。
>>> plot((x**2, (x, -6, 6)), (x, (x, -5, 5)))
Plot object containing:
[0]: cartesian line: x**2 for x over (-6.0, 6.0)
[1]: cartesian line: x for x over (-5.0, 5.0)
(png, hires.png, pdf)
无自适应采样。
>>> plot(x**2, adaptive=False, n=400)
Plot object containing:
[0]: cartesian line: x**2 for x over (-10.0, 10.0)
(png, hires.png, pdf)
另请参阅
绘图，1D 范围系列线
sympy.plotting.plot.plot_parametric(*args, show=True, **kwargs)
绘制二维参数曲线。
参数：
args
常见规范包括：
绘制带有范围的单一参数曲线
plot_parametric((expr_x, expr_y), range)使用相同范围绘制多个参数曲线
plot_parametric((expr_x, expr_y), ..., range)使用不同范围绘制多个参数曲线
plot_parametric((expr_x, expr_y, range), ...)
expr_x是表示参数函数 (x) 分量的表达式。
expr_y是表示参数函数 (y) 分量的表达式。
range是一个三元组，表示参数符号、起始值和结束值。例如，(u, 0, 5)。如果未指定范围，则使用默认范围 (-10, 10)。
然而，如果参数被指定为
(expr_x, expr_y, range), ...，则必须手动指定每个表达式的范围。如果实现了更先进的算法，将更改默认范围。
adaptive：布尔值，可选
指定是否使用自适应采样。
默认值设置为
True。将adaptive设置为False，并指定n，如果需要均匀采样。
depth : 整数，可选
自适应算法的递归深度。深度为值 (n) 时，最多采样 (2^n) 个点。
n : 整数，可选
当
adaptive标志设置为False时使用。指定用于均匀采样的点数。此关键字参数替换了已被视为弃用的nb_of_points。
line_color : 字符串、浮点数或函数，可选
指定图的颜色。查看
Plot以了解如何为图设置颜色。注意，通过设置line_color，将同时应用于所有系列。
label : 字符串，可选
图中表达式的标签。调用
legend时会使用。默认为表达式的名称。例如sin(x)
xlabel : 字符串，可选
x 轴的标签。
ylabel : 字符串，可选
y 轴的标签。
xscale : ‘linear’ 或 ‘log’，可选
设置 x 轴的缩放。
yscale : ‘linear’ 或 ‘log’，可选
设置 y 轴的缩放。
axis_center : (浮点数, 浮点数)，可选
两个浮点数元组，表示中心坐标或
xlim : (浮点数, 浮点数)，可选
表示 x 轴限制的元组，
(min, max)`。
ylim : (浮点数, 浮点数)，可选
表示 y 轴限制的元组，
(min, max)`。
size : (浮点数, 浮点数)，可选
以英寸为单位的整体图形大小元组（宽度，高度）。默认值为
None，意味着大小将由默认后端设置。
示例
>>> from sympy import plot_parametric, symbols, cos, sin
>>> u = symbols('u')
一个表达式的参数图：
>>> plot_parametric((cos(u), sin(u)), (u, -5, 5))
Plot object containing:
[0]: parametric cartesian line: (cos(u), sin(u)) for u over (-5.0, 5.0)
(png, hires.png, pdf)
带有相同范围的多个表达式的参数图：
>>> plot_parametric((cos(u), sin(u)), (u, cos(u)), (u, -10, 10))
Plot object containing:
[0]: parametric cartesian line: (cos(u), sin(u)) for u over (-10.0, 10.0)
[1]: parametric cartesian line: (u, cos(u)) for u over (-10.0, 10.0)
(png, hires.png, pdf)
带有每条曲线不同范围的多个表达式的参数图：
>>> plot_parametric((cos(u), sin(u), (u, -5, 5)),
... (cos(u), u, (u, -5, 5)))
Plot object containing:
[0]: parametric cartesian line: (cos(u), sin(u)) for u over (-5.0, 5.0)
[1]: parametric cartesian line: (cos(u), u) for u over (-5.0, 5.0)
(png, hires.png, pdf)
注意事项
绘图使用自适应算法递归采样以准确绘制曲线。自适应算法使用接近两点中点的随机点进行进一步采样。因此，由于随机采样的原因，重复相同的绘图命令可能会导致稍有不同的结果。
如果有多个图，则在同一画布上绘制的所有图都应用相同的可选参数。如果要单独设置这些选项，可以索引返回的 Plot 对象并设置它。
例如，当您一次指定 line_color 时，它会同时应用于两个系列。
>>> from sympy import pi
>>> expr1 = (u, cos(2*pi*u)/2 + 1/2)
>>> expr2 = (u, sin(2*pi*u)/2 + 1/2)
>>> p = plot_parametric(expr1, expr2, (u, 0, 1), line_color='blue')
(png, hires.png, pdf)
如果要为特定系列指定线条颜色，应索引每个项目并手动应用属性。
>>> p[0].line_color = 'red'
>>> p.show()
(png, hires.png, pdf)
另请参阅
Plot, Parametric2DLineSeries
sympy.plotting.plot.plot3d(*args, show=True, **kwargs)
绘制三维表面图。
用法
单个绘图
plot3d(expr, range_x, range_y, **kwargs)
如果未指定范围，则使用默认范围 (-10, 10)。
具有相同范围的多个图。
plot3d(expr1, expr2, range_x, range_y, **kwargs)
如果未指定范围，则使用默认范围 (-10, 10)。
具有不同范围的多个图。
plot3d((expr1, range_x, range_y), (expr2, range_x, range_y), ..., **kwargs)
每个表达式都必须指定范围。
如果实施更高级的默认范围检测算法，则默认范围可能会在将来更改。
参数
expr : 表示沿 x 轴的函数表达式。
range_x(Symbol, float, float)
x 变量范围的三元组，例如 (x, 0, 5)。
range_y(Symbol, float, float)
y 变量范围的三元组，例如 (y, 0, 5)。
关键字参数
SurfaceOver2DRangeSeries 类的参数：
n1int
x 范围以 n1 点均匀采样。此关键字参数替代了 nb_of_points_x，应视为已弃用。
n2int
y 范围以 n2 点均匀采样。此关键字参数替代了 nb_of_points_y，应视为已弃用。
美学：
surface_colorFunction 返回一个浮点数
指定绘图表面的颜色。有关更多细节，请参阅 Plot。
如果有多个绘图，则所有绘图都应用相同的系列参数。如果要单独设置这些选项，可以索引返回的 Plot 对象并设置它。
Plot 类的参数：
titlestr
绘图标题。
size(float, float)，可选
以英寸为单位的形式 (width, height) 的元组，用于指定整体图的大小。默认值为 None，表示大小由默认后端设置。
示例
>>> from sympy import symbols
>>> from sympy.plotting import plot3d
>>> x, y = symbols('x y')
单个绘图
>>> plot3d(x*y, (x, -5, 5), (y, -5, 5))
Plot object containing:
[0]: cartesian surface: x*y for x over (-5.0, 5.0) and y over (-5.0, 5.0)
(png, hires.png, pdf)
具有相同范围的多个绘图
>>> plot3d(x*y, -x*y, (x, -5, 5), (y, -5, 5))
Plot object containing:
[0]: cartesian surface: x*y for x over (-5.0, 5.0) and y over (-5.0, 5.0)
[1]: cartesian surface: -x*y for x over (-5.0, 5.0) and y over (-5.0, 5.0)
(png, hires.png, pdf)
具有不同范围的多个绘图。
>>> plot3d((x**2 + y**2, (x, -5, 5), (y, -5, 5)),
... (x*y, (x, -3, 3), (y, -3, 3)))
Plot object containing:
[0]: cartesian surface: x**2 + y**2 for x over (-5.0, 5.0) and y over (-5.0, 5.0)
[1]: cartesian surface: x*y for x over (-3.0, 3.0) and y over (-3.0, 3.0)
(png, hires.png, pdf)
另请参阅
Plot, SurfaceOver2DRangeSeries
sympy.plotting.plot.plot3d_parametric_line(*args, show=True, **kwargs)
绘制 3D 参数化线图。
用法
单个绘图：
plot3d_parametric_line(expr_x, expr_y, expr_z, range, **kwargs)
如果未指定范围，则使用默认范围 (-10, 10)。
多个绘图。
plot3d_parametric_line((expr_x, expr_y, expr_z, range), ..., **kwargs)
必须为每个表达式指定范围。
如果将来实施更高级的默认范围检测算法，则默认范围可能会更改。
参数
expr_x：表示沿 x 轴的函数表达式。
expr_y：表示沿 y 轴的函数表达式。
expr_z：表示沿 z 轴的函数表达式。
range(Symbol, float, float)
表示参数变量范围的 3 元组，例如 (u, 0, 5)。
关键字参数
Parametric3DLineSeries 类的参数。
nint
在 n 个点上均匀采样范围。此关键字参数替代了应视为已弃用的 nb_of_points。
美学特性：
line_colorstring，或 float，或 function，可选
指定图表的颜色。查看 Plot 以了解如何为图表设置颜色。请注意，通过设置 line_color，颜色将同时应用于所有系列。
labelstr
图表的标签。在调用时带有 legend=True 时，用于标识图表中具有给定标签的函数。
如果有多个图表，则所有图表都应用相同的系列参数。如果要分别设置这些选项，可以索引返回的 Plot 对象并设置它。
Plot 类的参数。
titlestr
图表的标题。
size(float, float)，可选
以英寸为单位的图表整体尺寸的二元组 (width, height)。默认值为 None，意味着尺寸将由默认后端设置。
示例
>>> from sympy import symbols, cos, sin
>>> from sympy.plotting import plot3d_parametric_line
>>> u = symbols('u')
单个图表。
>>> plot3d_parametric_line(cos(u), sin(u), u, (u, -5, 5))
Plot object containing:
[0]: 3D parametric cartesian line: (cos(u), sin(u), u) for u over (-5.0, 5.0)
(png, hires.png, pdf)
多个图表。
>>> plot3d_parametric_line((cos(u), sin(u), u, (u, -5, 5)),
... (sin(u), u**2, u, (u, -5, 5)))
Plot object containing:
[0]: 3D parametric cartesian line: (cos(u), sin(u), u) for u over (-5.0, 5.0)
[1]: 3D parametric cartesian line: (sin(u), u**2, u) for u over (-5.0, 5.0)
(png, hires.png, pdf)
另请参阅
Plot，Parametric3DLineSeries
sympy.plotting.plot.plot3d_parametric_surface(*args, show=True, **kwargs)
绘制三维参数化曲面图。
解释
单个图表。
plot3d_parametric_surface(expr_x, expr_y, expr_z, range_u, range_v, **kwargs)
如果未指定范围，则使用默认范围 (-10, 10)。
多个图表。
plot3d_parametric_surface((expr_x, expr_y, expr_z, range_u, range_v), ..., **kwargs)
对于每个表达式，都必须指定范围。
如果将来实现了更先进的默认范围检测算法，则默认范围可能会更改。
参数
expr_x：表示沿 x 的函数表达式。
expr_y：表示沿 y 的函数表达式。
expr_z：表示沿 z 的函数表达式。
range_u(Symbol, float, float)
表示 u 变量范围的三元组，例如 (u, 0, 5)。
range_v(Symbol, float, float)
表示 v 变量范围的三元组，例如 (v, 0, 5)。
关键字参数
ParametricSurfaceSeries 类的参数：
n1int
u 范围以 n1 个点均匀采样。这个关键字参数取代了应该被视为弃用的 nb_of_points_u。
n2int
v 范围以 n2 个点均匀采样。这个关键字参数取代了应该被视为弃用的 nb_of_points_v。
美学：
surface_colorFunction 返回一个 float
指定图面的颜色。有关更多详细信息，请参见 Plot。
如果有多个图，那么相同的系列参数将适用于所有图。如果要单独设置这些选项，可以索引返回的 Plot 对象并设置它。
Plot 类的参数：
titlestr
图的标题。
size(float, float)，可选
一个元组，以英寸为单位指定整体图形的大小（宽度，高度）。默认值为 None，表示大小将由默认后端设置。
示例
>>> from sympy import symbols, cos, sin
>>> from sympy.plotting import plot3d_parametric_surface
>>> u, v = symbols('u v')
单个图。
>>> plot3d_parametric_surface(cos(u + v), sin(u - v), u - v,
... (u, -5, 5), (v, -5, 5))
Plot object containing:
[0]: parametric cartesian surface: (cos(u + v), sin(u - v), u - v) for u over (-5.0, 5.0) and v over (-5.0, 5.0)
(png, hires.png, pdf)
另请参阅
绘图，参数曲面系列
sympy.plotting.plot_implicit.plot_implicit(expr, x_var=None, y_var=None, adaptive=True, depth=0, n=300, line_color='blue', show=True, **kwargs)
绘制隐式方程的绘图函数。
参数
-
expr：要绘制的方程/不等式。
-
x_var（可选）：要在 x 轴上绘制的符号或给定符号和范围的元组作为
(symbol, xmin, xmax) -
y_var（可选）：要绘制在 y 轴上的符号或给定符号和范围的元组作为
(symbol, ymin, ymax)
如果既未给出 x_var 也未给出 y_var，则将按其排序顺序为表达式中的自由符号分配。
还可以使用以下关键字参数：
-
adaptive布尔值。默认值设置为 True。必须如果要使用网格，则设置为 False。
-
depth整数。自适应网格的递归深度。默认值为 0。取值范围为 (0, 4)。
-
n整数。如果自适应网格不可用，则点数。used。默认值为 300。此关键字参数替代了被视为废弃的
points。 -
show布尔值。默认值为 True。如果设置为 False，则图将不会显示。不会显示。有关详细信息，请参见
Plot。 -
title字符串。图的标题。 -
xlabel字符串。x 轴的标签 -
ylabel字符串。y 轴的标签
美学选项：
-
line_color：float 或 string。指定图的颜色。请参阅
Plot以了解如何设置图的颜色。默认值为“Blue”
plot_implicit，默认情况下使用区间算术来绘制函数。如果表达式无法使用区间算术绘制，则默认生成使用固定点数的网格生成轮廓。通过将 adaptive 设置为 False，可以强制 plot_implicit 使用网格。当自适应绘图使用区间算术失败以小线宽绘制时，网格方法可以是有效的。
示例
绘制表达式：
>>> from sympy import plot_implicit, symbols, Eq, And
>>> x, y = symbols('x y')
没有表达式中符号的任何范围：
>>> p1 = plot_implicit(Eq(x**2 + y**2, 5))
(png, hires.png, pdf)
使用符号范围：
>>> p2 = plot_implicit(
... Eq(x**2 + y**2, 3), (x, -3, 3), (y, -3, 3))
(png, hires.png, pdf)
带有递归深度作为参数：
>>> p3 = plot_implicit(
... Eq(x**2 + y**2, 5), (x, -4, 4), (y, -4, 4), depth = 2)
(png, hires.png, pdf)
使用网格和不使用自适应网格：
>>> p4 = plot_implicit(
... Eq(x**2 + y**2, 5), (x, -5, 5), (y, -2, 2),
... adaptive=False)
(png, hires.png, pdf)
使用指定数量的点进行网格绘制而不使用自适应网格：
>>> p5 = plot_implicit(
... Eq(x**2 + y**2, 5), (x, -5, 5), (y, -2, 2),
... adaptive=False, n=400)
(png, hires.png, pdf)
绘制区域：
>>> p6 = plot_implicit(y > x**2)
(png, hires.png, pdf)
使用布尔连接进行绘图：
>>> p7 = plot_implicit(And(y > x, y > -x))
(png, hires.png, pdf)
当绘制单变量表达式（例如 y - 1）时，请明确指定 x 或 y 变量：
>>> p8 = plot_implicit(y - 1, y_var=y)
>>> p9 = plot_implicit(x - 1, x_var=x)
(png, hires.png, pdf)
（png, hires.png, pdf）
PlotGrid 类
class sympy.plotting.plot.PlotGrid(nrows, ncolumns, *args, show=True, size=None, **kwargs)
此类帮助在单个图中绘制已创建的 SymPy 图的子图。
示例
>>> from sympy import symbols
>>> from sympy.plotting import plot, plot3d, PlotGrid
>>> x, y = symbols('x, y')
>>> p1 = plot(x, x**2, x**3, (x, -5, 5))
>>> p2 = plot((x**2, (x, -6, 6)), (x, (x, -5, 5)))
>>> p3 = plot(x**3, (x, -5, 5))
>>> p4 = plot3d(x*y, (x, -5, 5), (y, -5, 5))
（png, hires.png, pdf）
（png, hires.png, pdf）
（png, hires.png, pdf）
（png, hires.png, pdf）
单行垂直绘制：
>>> PlotGrid(2, 1, p1, p2)
PlotGrid object containing:
Plot[0]:Plot object containing:
[0]: cartesian line: x for x over (-5.0, 5.0)
[1]: cartesian line: x**2 for x over (-5.0, 5.0)
[2]: cartesian line: x**3 for x over (-5.0, 5.0)
Plot[1]:Plot object containing:
[0]: cartesian line: x**2 for x over (-6.0, 6.0)
[1]: cartesian line: x for x over (-5.0, 5.0)
（png, hires.png, pdf）
水平单行绘制：
>>> PlotGrid(1, 3, p2, p3, p4)
PlotGrid object containing:
Plot[0]:Plot object containing:
[0]: cartesian line: x**2 for x over (-6.0, 6.0)
[1]: cartesian line: x for x over (-5.0, 5.0)
Plot[1]:Plot object containing:
[0]: cartesian line: x**3 for x over (-5.0, 5.0)
Plot[2]:Plot object containing:
[0]: cartesian surface: x*y for x over (-5.0, 5.0) and y over (-5.0, 5.0)
（png, hires.png, pdf）
以网格形式绘制：
>>> PlotGrid(2, 2, p1, p2, p3, p4)
PlotGrid object containing:
Plot[0]:Plot object containing:
[0]: cartesian line: x for x over (-5.0, 5.0)
[1]: cartesian line: x**2 for x over (-5.0, 5.0)
[2]: cartesian line: x**3 for x over (-5.0, 5.0)
Plot[1]:Plot object containing:
[0]: cartesian line: x**2 for x over (-6.0, 6.0)
[1]: cartesian line: x for x over (-5.0, 5.0)
Plot[2]:Plot object containing:
[0]: cartesian line: x**3 for x over (-5.0, 5.0)
Plot[3]:Plot object containing:
[0]: cartesian surface: x*y for x over (-5.0, 5.0) and y over (-5.0, 5.0)
（png, hires.png, pdf）
系列类
class sympy.plotting.series.BaseSeries(*args, **kwargs)
数据对象的基类，包含要绘制的内容。
注意事项
后端应检查是否支持给定的数据系列（例如，TextBackend 仅支持 LineOver1DRangeSeries）。后端有责任知道如何使用给定的数据系列类。
某些数据系列类根据它们展示的 API（仅基于约定）进行分组（使用类属性如 is_2Dline）。后端不必使用该 API（例如，LineOver1DRangeSeries 属于 is_2Dline 组并呈现 get_points 方法，但 TextBackend 不使用 get_points 方法）。
BaseSeries
eval_color_func(*args)
评估颜色函数。
参数：
args : 元组
要传递给着色函数的参数。可以是坐标、参数或两者。
注释
后端将请求数据系列生成数值数据。根据数据系列的不同，要么数据系列本身要么后端最终执行此函数以生成适当的着色值。
property expr
返回系列的表达式（或表达式）。
get_data()
计算并返回数值数据。
此方法返回的参数数量取决于具体的实例。如果s是系列，请确保阅读help(s.get_data)以了解其返回内容。
get_label(use_latex=False, wrapper='$%s$')
返回用于显示表达式的标签。
参数：
use_latex : 布尔值
如果为 False，则返回表达式的字符串表示。如果为 True，则返回 latex 表示。
wrapper : 字符串
后端可能需要将 latex 表示包装在某些字符中。默认为
"$%s$"。
返回：
label : 字符串
property n
返回数字离散化点的列表[n1, n2, n3]。
property params
获取或设置当前参数字典。
参数：
p : 字典
- 键：与参数相关联的符号
- val: 数值值
class sympy.plotting.series.Line2DBaseSeries(**kwargs)
2D 线的基类。
-
添加标签、步骤和仅整数选项。
-
使 is_2Dline 为真。
-
定义 get_segments 和 get_color_array
get_data()
返回绘制线条的坐标。
返回：
x: np.ndarray
x 坐标
y: np.ndarray
y 坐标
z: np.ndarray（可选）
在 Parametric3DLineSeries、Parametric3DLineInteractiveSeries 的情况下的 z 坐标。
param : np.ndarray（可选）
参数：Parametric2DLineSeries、Parametric3DLineSeries 或 AbsArgLineSeries（及其对应的交互系列）的情况。
class sympy.plotting.series.LineOver1DRangeSeries(expr, var_start_end, label='', **kwargs)
表示由 SymPy 表达式在范围上组成的线条。
get_points()
返回用于绘图的坐标列表。根据adaptive选项，此函数将使用自适应算法或在提供的范围内均匀采样表达式。
此函数供向后兼容性使用。考虑使用get_data()代替。
返回：
x : 列表
x 坐标列表
ylist
y 坐标列表
class sympy.plotting.series.Parametric2DLineSeries(expr_x, expr_y, var_start_end, label='', **kwargs)
表示由两个参数化 SymPy 表达式在范围上组成的线条。
class sympy.plotting.series.Line3DBaseSeries
3D 线的基类。
大多数东西都是从 Line2DBaseSeries 派生的。
class sympy.plotting.series.Parametric3DLineSeries(expr_x, expr_y, expr_z, var_start_end, label='', **kwargs)
表示由三个参数化 SymPy 表达式和一个范围组成的 3D 线的表示。
class sympy.plotting.series.SurfaceBaseSeries(*args, **kwargs)
3D 曲面的基类。
class sympy.plotting.series.SurfaceOver2DRangeSeries(expr, var_start_end_x, var_start_end_y, label='', **kwargs)
表示由 SymPy 表达式和 2D 范围组成的 3D 曲面。
get_data()
返回用于绘图的坐标数组。
返回：
mesh_x : np.ndarray
离散化的 x 域。
mesh_y : np.ndarray
离散化的 y 域。
mesh_z：np.ndarray
评估结果。
get_meshes()
返回用于绘制表面的 x、y、z 坐标。此函数用于向后兼容。考虑改用 get_data()。
class sympy.plotting.series.ParametricSurfaceSeries(expr_x, expr_y, expr_z, var_start_end_u, var_start_end_v, label='', **kwargs)
表示由三个参数化 SymPy 表达式和一个范围组成的 3D 表面。
get_data()
返回用于绘图的坐标数组。
返回：
x：np.ndarray [n2 x n1]
x 坐标。
y：np.ndarray [n2 x n1]
y 坐标。
z：np.ndarray [n2 x n1]
z 坐标。
mesh_u：np.ndarray [n2 x n1]
离散化的 u 范围。
mesh_v：np.ndarray [n2 x n1]
离散化的 v 范围。
get_meshes()
返回用于绘制表面的 x、y、z 坐标。此函数用于向后兼容。考虑改用 get_data()。
class sympy.plotting.series.ImplicitSeries(expr, var_start_end_x, var_start_end_y, label='', **kwargs)
2D 隐式绘图的表示。
get_data()
返回数值数据。
返回：
如果使用 (adaptive=True) 评估系列，则返回：
interval_list：列表
要后处理并最终与 Matplotlib 的
fill命令一起使用的边界矩形间隔列表。
dummy：str
包含
"fill"的字符串。
否则，它返回用于 Matplotlib 的 2D numpy 数组
contour 或 contourf 命令：
x_array：np.ndarray
y_array：np.ndarray
z_array：np.ndarray
plot_type：str
指定要使用的绘图命令的字符串，
"contour"或"contourf"。
get_label(use_latex=False, wrapper='$%s$')
返回用于显示表达式的标签。
参数：
use_latex：bool
如果为 False，则返回表达式的字符串表示。如果为 True，则返回 latex 表示。
wrapper：str
后端可能需要用一些字符包装 latex 表示。默认为
"$%s$".
返回：
label：str
后端
class sympy.plotting.plot.MatplotlibBackend(*series, **kwargs)
此类实现了使用 SymPy 绘图函数与 Matplotlib 的功能。
static get_segments(x, y, z=None)
将两个坐标列表转换为用于 Matplotlib 的段列表 LineCollection.
参数：
x：列表
x 坐标列表
ylist
y 坐标列表
zlist
用于 3D 线条的 z 坐标列表。
process_series()
迭代每个 Plot 对象并进一步调用 _process_series()
class sympy.plotting.plot.TextBackend(*args, **kwargs)
Pyglet 绘图
这是使用 pyglet 的旧绘图模块的文档。此模块有一些限制，并且不再积极开发。您可以查看新的绘图模块作为替代。
Pyglet 绘图模块可以进行美观的 2D 和 3D 绘图，可以通过控制台命令以及键盘和鼠标进行控制，仅依赖于 pyglet。
这是最简单的用法：
>>> from sympy import var
>>> from sympy.plotting.pygletplot import PygletPlot as Plot
>>> var('x y z')
>>> Plot(x*y**3-y*x**3)
要查看大量绘图示例，请参阅 examples/pyglet_plotting.py 并尝试在交互模式下运行它（python -i plotting.py）：
$ python -i examples/pyglet_plotting.py
例如 example(7) 或 example(11) 的类型。
另请参阅 绘图模块 维基页面以查看截图。
绘图窗口控制
| 摄像机 | 键 |
|---|---|
| 灵敏度调整器 | SHIFT |
| 缩放 | R 和 F, Page Up 和 Down, 小键盘 + 和 - |
| 绕 X,Y 轴旋转视角 | 箭头键, A,S,D,W, 小键盘 4,6,8,2 |
| 绕 Z 轴旋转视角 | Q 和 E, 小键盘 7 和 9 |
| 绕纵坐标 Z 轴旋转视角 | Z 和 C, 小键盘 1 和 3 |
| 查看 XY 平面 | F1 |
| 查看 XZ 平面 | F2 |
| 查看 YZ 平面 | F3 |
| 查看透视 | F4 |
| 重置 | X, 小键盘 5 |
| 坐标轴 | 键盘 |
| --- | --- |
| 切换可见性 | F5 |
| 切换颜色 | F6 |
| 窗口 | 键盘 |
| --- | --- |
| 关闭 | ESCAPE |
| 屏幕截图 | F8 |
鼠标可以通过拖动左键、中键和右键来旋转、缩放和平移。
坐标模式
Plot 支持几种曲线坐标模式，每个绘制函数都是独立的。您可以使用mode命名参数明确指定坐标模式，但对于笛卡尔或参数绘图，可以自动确定，因此只需为极坐标、柱坐标和球坐标模式指定。
具体而言，如果您在Plot中提供的函数参数为一个函数，或使用Plot.__setitem__(i, function arguments)（通过数组索引语法访问Plot实例），则参数将被解释为笛卡尔绘图；如果提供两个或三个函数，则会被解释为参数绘图。类似地，如果使用一个变量，则参数将被解释为曲线，如果使用两个变量，则被解释为曲面。
变量个数支持的模式名称：
-
1 (曲线): 参数化、笛卡尔、极坐标
-
2 (曲面): 参数化、笛卡尔、柱坐标、球坐标
>>> Plot(1, 'mode=spherical; color=zfade4')
注意，函数参数以"key1=value1; key2=value2"的形式给出（空格被省略）。直接给出绘图的关键字参数适用于绘图本身。
指定变量的间隔
变量间隔的基本格式为[var, min, max, steps]。然而，语法非常灵活，未指定的参数将从当前坐标模式的默认值中取得：
>>> Plot(x**2) # implies [x,-5,5,100]
>>> Plot(x**2, [], []) # [x,-1,1,40], [y,-1,1,40]
>>> Plot(x**2-y**2, [100], [100]) # [x,-1,1,100], [y,-1,1,100]
>>> Plot(x**2, [x,-13,13,100])
>>> Plot(x**2, [-13,13]) # [x,-13,13,100]
>>> Plot(x**2, [x,-13,13]) # [x,-13,13,100]
>>> Plot(1*x, [], [x], 'mode=cylindrical') # [unbound_theta,0,2*Pi,40], [x,-1,1,20]
使用交互界面
>>> p = Plot(visible=False)
>>> f = x**2
>>> p[1] = f
>>> p[2] = f.diff(x)
>>> p[3] = f.diff(x).diff(x)
>>> p
[1]: x**2, 'mode=cartesian'
[2]: 2*x, 'mode=cartesian'
[3]: 2, 'mode=cartesian'
>>> p.show()
>>> p.clear()
>>> p
<blank plot>
>>> p[1] = x**2+y**2
>>> p[1].style = 'solid'
>>> p[2] = -x**2-y**2
>>> p[2].style = 'wireframe'
>>> p[1].color = z, (0.4,0.4,0.9), (0.9,0.4,0.4)
>>> p[1].style = 'both'
>>> p[2].style = 'both'
>>> p.close()
使用自定义颜色函数
以下代码绘制一个鞍形曲面，并按其梯度的大小着色：
>>> fz = x**2-y**2
>>> Fx, Fy, Fz = fz.diff(x), fz.diff(y), 0
>>> p[1] = fz, 'style=solid'
>>> p[1].color = (Fx**2 + Fy**2 + Fz**2)**(0.5)
着色算法的工作原理如下：
-
在曲线或曲面上评估颜色函数。
-
找出每个分量的最小值和最大值。
-
将每个分量缩放到颜色梯度。
当未明确指定时，默认颜色梯度为 (f(0.0)=(0.4,0.4,0.4) \rightarrow f(1.0)=(0.9,0.9,0.9))。在我们的情况下，所有组成部分都是灰度，因为我们已经统一应用了默认颜色梯度。当以这种方式定义颜色方案时，您可能希望同时提供一个颜色梯度：
>>> p[1].color = (Fx**2 + Fy**2 + Fz**2)**(0.5), (0.1,0.1,0.9), (0.9,0.1,0.1)
这是一个包含四个步骤的颜色梯度：
>>> gradient = [ 0.0, (0.1,0.1,0.9), 0.3, (0.1,0.9,0.1),
... 0.7, (0.9,0.9,0.1), 1.0, (1.0,0.0,0.0) ]
>>> p[1].color = (Fx**2 + Fy**2 + Fz**2)**(0.5), gradient
另一种指定颜色方案的方法是为每个分量 r、g、b 提供单独的函数。使用这种语法时，默认的颜色方案如下所定义：
>>> p[1].color = z,y,x, (0.4,0.4,0.4), (0.9,0.9,0.9)
这将 z 映射为红色、y 映射为绿色、x 映射为蓝色。在某些情况下，您可能更喜欢使用以下替代语法：
>>> p[1].color = z,(0.4,0.9), y,(0.4,0.9), x,(0.4,0.9)
你仍然可以使用三功能颜色方案进行多步渐变。
绘制几何实体
绘图模块能够绘制一些二维几何实体，如线段、圆和椭圆。下面的示例绘制了一个以原点为中心、半径为 2 个单位的圆。
>>> from sympy import *
>>> x,y = symbols('x y')
>>> plot_implicit(Eq(x**2+y**2, 4))
类似地，plot_implicit() 可用于根据其隐式方程绘制任意的二维几何结构。
直接绘制多边形（Polygon、RegularPolygon、Triangle）是不支持的。
使用 ASCII 艺术进行绘图
sympy.plotting.textplot.textplot(expr, a, b, W=55, H=21)
在区间 [a, b] 上打印 SymPy 表达式 'expr' 的粗略 ASCII 艺术图（该表达式应包含一个单一符号，例如 x 或其他内容）。
示例
>>> from sympy import Symbol, sin
>>> from sympy.plotting import textplot
>>> t = Symbol('t')
>>> textplot(sin(t)*t, 0, 15)
14 | ...
| .
| .
| .
| .
| ...
| / . .
| /
| / .
| . . .
1.5 |----.......--------------------------------------------
|.... \ . .
| \ / .
| .. / .
| \ / .
| ....
| .
| . .
|
| . .
-11 |_______________________________________________________
0 7.5 15
统计
SymPy 统计模块
引入了一个随机变量类型到 SymPy 语言中。
可以使用预构建函数（如正态分布、指数分布、硬币、骰子等）声明随机变量，也可以使用函数（如 FiniteRV）构建随机变量。
可以使用函数查询随机表达式
| 表达式 | 含义 |
|---|---|
P(condition) |
概率 |
E(expression) |
期望值 |
H(expression) |
熵 |
variance(expression) |
方差 |
density(expression) |
概率密度函数 |
sample(expression) |
生成实现 |
where(condition) |
条件为真时 |
示例
>>> from sympy.stats import P, E, variance, Die, Normal
>>> from sympy import simplify
>>> X, Y = Die('X', 6), Die('Y', 6) # Define two six sided dice
>>> Z = Normal('Z', 0, 1) # Declare a Normal random variable with mean 0, std 1
>>> P(X>3) # Probability X is greater than 3
1/2
>>> E(X+Y) # Expectation of the sum of two dice
7
>>> variance(X+Y) # Variance of the sum of two dice
35/6
>>> simplify(P(Z>1)) # Probability of Z being greater than 1
1/2 - erf(sqrt(2)/2)/2
您也可以创建自定义分布，并定义自定义随机变量，如下所示：
- 如果您想创建连续随机变量：
>>> from sympy.stats import ContinuousRV, P, E
>>> from sympy import exp, Symbol, Interval, oo
>>> x = Symbol('x')
>>> pdf = exp(-x) # pdf of the Continuous Distribution
>>> Z = ContinuousRV(x, pdf, set=Interval(0, oo))
>>> E(Z)
1
>>> P(Z > 5)
exp(-5)
1.1 创建连续分布的实例：
>>> from sympy.stats import ContinuousDistributionHandmade
>>> from sympy import Lambda
>>> dist = ContinuousDistributionHandmade(Lambda(x, pdf), set=Interval(0, oo))
>>> dist.pdf(x)
exp(-x)
- 如果您想创建离散随机变量：
>>> from sympy.stats import DiscreteRV, P, E
>>> from sympy import Symbol, S
>>> p = S(1)/2
>>> x = Symbol('x', integer=True, positive=True)
>>> pdf = p*(1 - p)**(x - 1)
>>> D = DiscreteRV(x, pdf, set=S.Naturals)
>>> E(D)
2
>>> P(D > 3)
1/8
2.1 创建离散分布的实例：
>>> from sympy.stats import DiscreteDistributionHandmade
>>> from sympy import Lambda
>>> dist = DiscreteDistributionHandmade(Lambda(x, pdf), set=S.Naturals)
>>> dist.pdf(x)
2**(1 - x)/2
- 如果您想创建有限随机变量：
>>> from sympy.stats import FiniteRV, P, E
>>> from sympy import Rational, Eq
>>> pmf = {1: Rational(1, 3), 2: Rational(1, 6), 3: Rational(1, 4), 4: Rational(1, 4)}
>>> X = FiniteRV('X', pmf)
>>> E(X)
29/12
>>> P(X > 3)
1/4
3.1 创建有限分布的实例：
>>> from sympy.stats import FiniteDistributionHandmade
>>> dist = FiniteDistributionHandmade(pmf)
>>> dist.pmf(x)
Lambda(x, Piecewise((1/3, Eq(x, 1)), (1/6, Eq(x, 2)), (1/4, Eq(x, 3) | Eq(x, 4)), (0, True)))
随机变量类型
有限类型
sympy.stats.DiscreteUniform(name, items)
创建一个表示输入集合上均匀分布的有限随机变量。
参数：
items：列表/元组
生成均匀分布的项目
返回：
RandomSymbol
示例
>>> from sympy.stats import DiscreteUniform, density
>>> from sympy import symbols
>>> X = DiscreteUniform('X', symbols('a b c')) # equally likely over a, b, c
>>> density(X).dict
{a: 1/3, b: 1/3, c: 1/3}
>>> Y = DiscreteUniform('Y', list(range(5))) # distribution over a range
>>> density(Y).dict
{0: 1/5, 1: 1/5, 2: 1/5, 3: 1/5, 4: 1/5}
参考文献
[R896]
en.wikipedia.org/wiki/Discrete_uniform_distribution
[R897]
mathworld.wolfram.com/DiscreteUniformDistribution.html
sympy.stats.Die(name, sides=6)
创建一个表示公平骰子的有限随机变量。
参数：
sides：整数
表示骰子的面数，默认为 6
返回：
RandomSymbol
示例
>>> from sympy.stats import Die, density
>>> from sympy import Symbol
>>> D6 = Die('D6', 6) # Six sided Die
>>> density(D6).dict
{1: 1/6, 2: 1/6, 3: 1/6, 4: 1/6, 5: 1/6, 6: 1/6}
>>> D4 = Die('D4', 4) # Four sided Die
>>> density(D4).dict
{1: 1/4, 2: 1/4, 3: 1/4, 4: 1/4}
>>> n = Symbol('n', positive=True, integer=True)
>>> Dn = Die('Dn', n) # n sided Die
>>> density(Dn).dict
Density(DieDistribution(n))
>>> density(Dn).dict.subs(n, 4).doit()
{1: 1/4, 2: 1/4, 3: 1/4, 4: 1/4}
sympy.stats.Bernoulli(name, p, succ=1, fail=0)
创建一个表示伯努利过程的有限随机变量。
参数：
p：0 到 1 之间的有理数
表示成功的概率
succ：整数/符号/字符串
表示成功事件
fail：整数/符号/字符串
表示失败事件
返回：
RandomSymbol
示例
>>> from sympy.stats import Bernoulli, density
>>> from sympy import S
>>> X = Bernoulli('X', S(3)/4) # 1-0 Bernoulli variable, probability = 3/4
>>> density(X).dict
{0: 1/4, 1: 3/4}
>>> X = Bernoulli('X', S.Half, 'Heads', 'Tails') # A fair coin toss
>>> density(X).dict
{Heads: 1/2, Tails: 1/2}
参考文献
[R898]
en.wikipedia.org/wiki/Bernoulli_distribution
[R899]
mathworld.wolfram.com/BernoulliDistribution.html
sympy.stats.Coin(name, p=1 / 2)
创建一个表示抛硬币的有限随机变量。
参数：
p：0 到 1 之间的有理数
表示获得“正面”的概率，默认为一半
返回：
RandomSymbol
示例
>>> from sympy.stats import Coin, density
>>> from sympy import Rational
>>> C = Coin('C') # A fair coin toss
>>> density(C).dict
{H: 1/2, T: 1/2}
>>> C2 = Coin('C2', Rational(3, 5)) # An unfair coin
>>> density(C2).dict
{H: 3/5, T: 2/5}
另见
sympy.stats.Binomial
参考文献
[R900]
en.wikipedia.org/wiki/Coin_flipping
sympy.stats.Binomial(name, n, p, succ=1, fail=0)
创建一个表示二项分布的有限随机变量。
参数：
n：正整数
表示试验次数
p：0 到 1 之间的有理数
表示成功的概率
succ：整数/符号/字符串
表示成功事件，默认为 1
fail：整数/符号/字符串
表示失败事件，默认为 0
返回：
RandomSymbol
示例
>>> from sympy.stats import Binomial, density
>>> from sympy import S, Symbol
>>> X = Binomial('X', 4, S.Half) # Four "coin flips"
>>> density(X).dict
{0: 1/16, 1: 1/4, 2: 3/8, 3: 1/4, 4: 1/16}
>>> n = Symbol('n', positive=True, integer=True)
>>> p = Symbol('p', positive=True)
>>> X = Binomial('X', n, S.Half) # n "coin flips"
>>> density(X).dict
Density(BinomialDistribution(n, 1/2, 1, 0))
>>> density(X).dict.subs(n, 4).doit()
{0: 1/16, 1: 1/4, 2: 3/8, 3: 1/4, 4: 1/16}
参考
[R901]
en.wikipedia.org/wiki/Binomial_distribution
[R902]
mathworld.wolfram.com/BinomialDistribution.html
sympy.stats.BetaBinomial(name, n, alpha, beta)
创建一个表示 Beta 二项分布的有限随机变量。
参数：
n：正整数
表示试验次数
alpha：实数正数
beta：实数正数
返回：
RandomSymbol
示例
>>> from sympy.stats import BetaBinomial, density
>>> X = BetaBinomial('X', 2, 1, 1)
>>> density(X).dict
{0: 1/3, 1: 2*beta(2, 2), 2: 1/3}
参考
[R903]
en.wikipedia.org/wiki/Beta-binomial_distribution
[R904]
mathworld.wolfram.com/BetaBinomialDistribution.html
sympy.stats.Hypergeometric(name, N, m, n)
创建一个表示超几何分布的有限随机变量。
参数：
N：正整数
表示大小为 N 的有限人口。
m：正整数
表示具有所需特征的试验次数。
n：正整数
表示抽取次数。
返回：
RandomSymbol
示例
>>> from sympy.stats import Hypergeometric, density
>>> X = Hypergeometric('X', 10, 5, 3) # 10 marbles, 5 white (success), 3 draws
>>> density(X).dict
{0: 1/12, 1: 5/12, 2: 5/12, 3: 1/12}
参考
[R905]
en.wikipedia.org/wiki/Hypergeometric_distribution
[R906]
mathworld.wolfram.com/HypergeometricDistribution.html
sympy.stats.FiniteRV(name, density, **kwargs)
创建一个给定表示密度的字典的有限随机变量。
参数：
name：符号
表示随机变量的名称。
density：字典
包含有限分布 pdf 的字典
check：布尔值
如果为 True，则检查给定密度是否在给定集合上积分为 1。如果为 False，则不执行此检查。默认为 False。
返回：
RandomSymbol
示例
>>> from sympy.stats import FiniteRV, P, E
>>> density = {0: .1, 1: .2, 2: .3, 3: .4}
>>> X = FiniteRV('X', density)
>>> E(X)
2.00000000000000
>>> P(X >= 2)
0.700000000000000
sympy.stats.Rademacher(name)
创建一个表示 Rademacher 分布的有限随机变量。
返回：
RandomSymbol
示例
>>> from sympy.stats import Rademacher, density
>>> X = Rademacher('X')
>>> density(X).dict
{-1: 1/2, 1: 1/2}
另见
sympy.stats.Bernoulli
参考
[R907]
en.wikipedia.org/wiki/Rademacher_distribution
离散类型
sympy.stats.Geometric(name, p)
创建一个具有几何分布的离散随机变量。
参数：
p：介于 0 和 1 之间的概率
返回：
RandomSymbol
解释
几何分布的密度由以下给出
[f(k) := p (1 - p)^{k - 1}]
示例
>>> from sympy.stats import Geometric, density, E, variance
>>> from sympy import Symbol, S
>>> p = S.One / 5
>>> z = Symbol("z")
>>> X = Geometric("x", p)
>>> density(X)(z)
(5/4)**(1 - z)/5
>>> E(X)
5
>>> variance(X)
20
参考
[R908]
en.wikipedia.org/wiki/Geometric_distribution
[R909]
mathworld.wolfram.com/GeometricDistribution.html
sympy.stats.Hermite(name, a1, a2)
创建一个具有 Hermite 分布的离散随机变量。
参数：
a1：大于等于 0 的正数。
a2 ：一个大于等于 0 的正数
返回：
随机符号
解释
Hermite 分布的密度函数为
[f(x):= e^{-a_1 -a_2}\sum_{j=0}^{\left \lfloor x/2 \right \rfloor} \frac{a_{1}{x-2j}a_{2}{j}}{(x-2j)!j!}]
例子
>>> 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
参考
[R910]
en.wikipedia.org/wiki/Hermite_distribution
sympy.stats.Poisson(name, lamda)
创建一个服从泊松分布的离散随机变量。
参数：
lamda ：一个正率值
返回：
随机符号
解释
Poisson 分布的密度函数为
[f(k) := \frac{\lambda^{k} e^{- \lambda}}{k!}]
例子
>>> from sympy.stats import Poisson, density, E, variance
>>> from sympy import Symbol, simplify
>>> rate = Symbol("lambda", positive=True)
>>> z = Symbol("z")
>>> X = Poisson("x", rate)
>>> density(X)(z)
lambda**z*exp(-lambda)/factorial(z)
>>> E(X)
lambda
>>> simplify(variance(X))
lambda
参考
[R911]
en.wikipedia.org/wiki/Poisson_distribution
[R912]
mathworld.wolfram.com/PoissonDistribution.html
sympy.stats.Logarithmic(name, p)
创建一个服从对数分布的离散随机变量。
参数：
p ：一个介于 0 和 1 之间的值
返回：
随机符号
解释
对数分布的密度函数为
[f(k) := \frac{-p^k}{k \ln{(1 - p)}}]
例子
>>> 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))
参考
[R913]
en.wikipedia.org/wiki/Logarithmic_distribution
[R914]
mathworld.wolfram.com/LogarithmicDistribution.html
sympy.stats.NegativeBinomial(name, r, p)
创建一个服从负二项分布的离散随机变量。
参数：
r ：一个正数
p ：一个介于 0 和 1 之间的值
返回：
随机符号
解释
负二项分布的密度函数为
[f(k) := \binom{k + r - 1}{k} (1 - p)^r p^k]
例子
>>> from sympy.stats import NegativeBinomial, density, E, variance
>>> from sympy import Symbol, S
>>> r = 5
>>> p = S.One / 5
>>> z = Symbol("z")
>>> X = NegativeBinomial("x", r, p)
>>> density(X)(z)
1024*binomial(z + 4, z)/(3125*5**z)
>>> E(X)
5/4
>>> variance(X)
25/16
参考
[R915]
en.wikipedia.org/wiki/Negative_binomial_distribution
[R916]
mathworld.wolfram.com/NegativeBinomialDistribution.html
sympy.stats.Skellam(name, mu1, mu2)
创建一个服从 Skellam 分布的离散随机变量。
参数：
mu1 ：一个非负值
mu2 ：一个非负值
返回：
随机符号
解释
Skellam 分布是两个统计独立的泊松分布随机变量 N1 和 N2 差值 N1 - N2 的分布，其期望值分别为 mu1 和 mu2。
Skellam 分布的密度函数为
[f(k) := e{-(\mu_1+\mu_2)}(\frac{\mu_1}{\mu_2})I_k(2\sqrt{\mu_1\mu_2})]
例子
>>> from sympy.stats import Skellam, density, E, variance
>>> from sympy import Symbol, pprint
>>> z = Symbol("z", integer=True)
>>> mu1 = Symbol("mu1", positive=True)
>>> mu2 = Symbol("mu2", positive=True)
>>> X = Skellam("x", mu1, mu2)
>>> pprint(density(X)(z), use_unicode=False)
z
-
2
/mu1\ -mu1 - mu2 / _____ _____\
|---| *e *besseli\z, 2*\/ mu1 *\/ mu2 /
\mu2/
>>> E(X)
mu1 - mu2
>>> variance(X).expand()
mu1 + mu2
参考
[R917]
en.wikipedia.org/wiki/Skellam_distribution
sympy.stats.YuleSimon(name, rho)
创建一个服从 Yule-Simon 分布的离散随机变量。
参数：
rho ：一个正数
返回：
随机符号
解释
Yule-Simon 分布的密度函数为
[f(k) := \rho B(k, \rho + 1)]
例子
>>> from sympy.stats import YuleSimon, density, E, variance
>>> from sympy import Symbol, simplify
>>> p = 5
>>> z = Symbol("z")
>>> X = YuleSimon("x", p)
>>> density(X)(z)
5*beta(z, 6)
>>> simplify(E(X))
5/4
>>> simplify(variance(X))
25/48
参考
[R918]
en.wikipedia.org/wiki/Yule%E2%80%93Simon_distribution
sympy.stats.Zeta(name, s)
使用 Zeta 分布创建离散随机变量。
参数：
s：大于 1 的值
返回：
随机符号
解释
Zeta 分布的密度函数为
[f(k) := \frac{1}{k^s \zeta{(s)}}]
示例
>>> from sympy.stats import Zeta, density, E, variance
>>> from sympy import Symbol
>>> s = 5
>>> z = Symbol("z")
>>> X = Zeta("x", s)
>>> density(X)(z)
1/(z**5*zeta(5))
>>> E(X)
pi**4/(90*zeta(5))
>>> variance(X)
-pi**8/(8100*zeta(5)**2) + zeta(3)/zeta(5)
参考文献
[R919]
en.wikipedia.org/wiki/Zeta_distribution
连续类型
sympy.stats.Arcsin(name, a=0, b=1)
使用 arcsin 分布创建连续随机变量。
arcsin 分布的密度函数为
[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))
参考文献
[R920]
en.wikipedia.org/wiki/Arcsine_distribution
sympy.stats.Benini(name, alpha, beta, sigma)
使用 Benini 分布创建连续随机变量。
Benini 分布的密度函数为
[f(x) := e^{-\alpha\log{\frac{x}{\sigma}} -\beta\log²\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))
参考文献
[R921]
en.wikipedia.org/wiki/Benini_distribution
[R922]
reference.wolfram.com/legacy/v8/ref/BeniniDistribution.html
sympy.stats.Beta(name, alpha, 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))
参考文献
[R923]
en.wikipedia.org/wiki/Beta_distribution
[R924]
mathworld.wolfram.com/BetaDistribution.html
sympy.stats.BetaNoncentral(name, alpha, beta, lamda)
使用 Type I 非中心贝塔分布创建连续随机变量。
非中心贝塔分布的密度函数为
[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)，非中心参数
返回：
随机符号
示例
>>> 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(BetaNoncentral("x", 1, 1, 1), evaluate=False)(2).doit()
2*exp(1/2)
参数 evaluate=False 阻止在传递参数 2 之前对一般 x 进行求和的尝试。
参考文献
[R925]
en.wikipedia.org/wiki/Noncentral_beta_distribution
[R926]
reference.wolfram.com/language/ref/NoncentralBetaDistribution.html
sympy.stats.BetaPrime(name, alpha, beta)
创建一个具有 Beta prime 分布的连续随机变量。
Beta prime 分布的密度函数为
[f(x) := \frac{x^{\alpha-1} (1+x)^{-\alpha -\beta}}{B(\alpha,\beta)}]
当 (x > 0) 时。
参数：
alpha : 实数, (\alpha > 0), 一个形状
beta : 实数, (\beta > 0), 一个形状
返回：
RandomSymbol
示例
>>> from sympy.stats import BetaPrime, density
>>> from sympy import Symbol, pprint
>>> alpha = Symbol("alpha", positive=True)
>>> beta = Symbol("beta", positive=True)
>>> z = Symbol("z")
>>> X = BetaPrime("x", alpha, beta)
>>> D = density(X)(z)
>>> pprint(D, use_unicode=False)
alpha - 1 -alpha - beta
z *(z + 1)
-------------------------------
B(alpha, beta)
参考文献
[R927]
en.wikipedia.org/wiki/Beta_prime_distribution
[R928]
mathworld.wolfram.com/BetaPrimeDistribution.html
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)
位置参数
返回：
RandomSymbol
示例
>>> from sympy.stats import BoundedPareto, density, cdf, E
>>> from sympy import symbols
>>> L, H = symbols('L, H', positive=True)
>>> X = BoundedPareto('X', 2, L, H)
>>> x = symbols('x')
>>> density(X)(x)
2*L**2/(x**3*(1 - L**2/H**2))
>>> cdf(X)(x)
Piecewise((-H**2*L**2/(x**2*(H**2 - L**2)) + H**2/(H**2 - L**2), L <= x), (0, True))
>>> E(X).simplify()
2*H*L/(H + L)
参考文献
[R929]
en.wikipedia.org/wiki/Pareto_distribution#Bounded_Pareto_distribution
sympy.stats.Cauchy(name, x0, gamma)
创建一个具有 Cauchy 分布的连续随机变量。
Cauchy 分布的密度函数为
[f(x) := \frac{1}{\pi \gamma [1 + {(\frac{x-x_0}{\gamma})}²]}]
参数：
x0 : 实数, 位置
gamma : 实数, (\gamma > 0), 一个尺度
返回：
RandomSymbol
示例
>>> from sympy.stats import Cauchy, density
>>> from sympy import Symbol
>>> x0 = Symbol("x0")
>>> gamma = Symbol("gamma", positive=True)
>>> z = Symbol("z")
>>> X = Cauchy("x", x0, gamma)
>>> density(X)(z)
1/(pi*gamma*(1 + (-x0 + z)**2/gamma**2))
参考文献
[R930]
en.wikipedia.org/wiki/Cauchy_distribution
[R931]
mathworld.wolfram.com/CauchyDistribution.html
sympy.stats.Chi(name, k)
创建一个具有 Chi 分布的连续随机变量。
Chi 分布的密度函数为
[f(x) := \frac{2{1-k/2}xe^{-x²/2}}{\Gamma(k/2)}]
当 (x \geq 0) 时。
参数：
k : 正整数, 自由度数目
返回：
RandomSymbol
示例
>>> from sympy.stats import Chi, density, E
>>> from sympy import Symbol, simplify
>>> k = Symbol("k", integer=True)
>>> z = Symbol("z")
>>> X = Chi("x", k)
>>> density(X)(z)
2**(1 - k/2)*z**(k - 1)*exp(-z**2/2)/gamma(k/2)
>>> simplify(E(X))
sqrt(2)*gamma(k/2 + 1/2)/gamma(k/2)
参考文献
[R932]
en.wikipedia.org/wiki/Chi_distribution
[R933]
mathworld.wolfram.com/ChiDistribution.html
sympy.stats.ChiNoncentral(name, k, l)
创建一个具有非中心 Chi 分布的连续随机变量。
参数：
k : 正整数, (k > 0)
自由度数目。
lambda : 实数, (\lambda > 0)
移动参数。
返回:
RandomSymbol
解释
非中心卡方分布的密度由
[f(x) := \frac{e^{-(x²+\lambda²)/2} x^k\lambda} {(\lambda x)^{k/2}} I_{k/2-1}(\lambda x)]
其中 (x \geq 0). 这里，(I_\nu (x)) 是第一类修正贝塞尔函数。
例子
>>> 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)
参考
[R934]
en.wikipedia.org/wiki/Noncentral_chi_distribution是指非中心卡方分布。
sympy.stats.ChiSquared(name, k)
创建一个具有卡方分布的连续随机变量。
参数:
k : 正整数
自由度的数量。
返回:
RandomSymbol
解释
卡方分布的密度由
[f(x) := \frac{1}{2^{\frac{k}{2}}\Gamma\left(\frac{k}{2}\right)} x^{\frac{k}{2}-1} e^{-\frac{x}{2}}]
其中 (x \geq 0).
例子
>>> from sympy.stats import ChiSquared, density, E, variance, moment
>>> from sympy import Symbol
>>> k = Symbol("k", integer=True, positive=True)
>>> z = Symbol("z")
>>> X = ChiSquared("x", k)
>>> density(X)(z)
z**(k/2 - 1)*exp(-z/2)/(2**(k/2)*gamma(k/2))
>>> E(X)
k
>>> variance(X)
2*k
>>> moment(X, 3)
k**3 + 6*k**2 + 8*k
参考
[R935]
en.wikipedia.org/wiki/Chi_squared_distribution是指卡方分布。
[R936]给出。
mathworld.wolfram.com/Chi-SquaredDistribution.html
sympy.stats.Dagum(name, p, a, b)
创建一个具有 Dagum 分布的连续随机变量。
参数:
p : 实数
(p > 0), 一种形状。
a : 实数
(a > 0), 一种形状。
b : 实数
(b > 0), 一个尺度。
返回:
RandomSymbol
解释
Dagum 分布的密度由
[f(x) := \frac{a p}{x} \left( \frac{\left(\tfrac{x}{b}\right)^{a p}} {\left(\left(\tfrac{x}{b}\right)^a + 1 \right)^{p+1}} \right)]
其中 (x > 0).
例子
>>> from sympy.stats import Dagum, density, cdf
>>> from sympy import Symbol
>>> p = Symbol("p", positive=True)
>>> a = Symbol("a", positive=True)
>>> b = Symbol("b", positive=True)
>>> z = Symbol("z")
>>> X = Dagum("x", p, a, b)
>>> density(X)(z)
a*p*(z/b)**(a*p)*((z/b)**a + 1)**(-p - 1)/z
>>> cdf(X)(z)
Piecewise(((1 + (z/b)**(-a))**(-p), z >= 0), (0, True))
参考
[R937]
en.wikipedia.org/wiki/Dagum_distribution
sympy.stats.Davis(name, b, n, mu)
创建一个具有 Davis 分布的连续随机变量。
参数:
b : 实数
(p > 0), 一个尺度。
n : 实数
(n > 1), 一种形状。
mu : 实数
(mu > 0), 一个位置。
返回:
RandomSymbol
解释
Davis 分布的密度由
[f(x; \mu; b, n) := \frac{b^{n}(x - \mu)^{1-n}}{ \left( e^{\frac{b}{x-\mu}} - 1 \right) \Gamma(n)\zeta(n)}]
其中 (x \in [0,\infty]).
Davis 分布是来自统计物理学的普朗克辐射定律的一般化。用于建模收入分布。
例子
>>> 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))
参考
[R938]
en.wikipedia.org/wiki/Davis_distribution
[R939]
reference.wolfram.com/language/ref/DavisDistribution.html
sympy.stats.Erlang(name, k, l)
创建一个具有 Erlang 分布的连续随机变量。
参数:
k : 正整数
l : 实数, (\lambda > 0), 比率
返回:
RandomSymbol
解释
Erlang 分布的密度由
[f(x) := \frac{\lambda^k x^{k-1} e^{-\lambda x}}{(k-1)!}]
其中 (x \in [0,\infty]).
例子
>>> from sympy.stats import Erlang, density, cdf, E, variance
>>> from sympy import Symbol, simplify, pprint
>>> k = Symbol("k", integer=True, positive=True)
>>> l = Symbol("l", positive=True)
>>> z = Symbol("z")
>>> X = Erlang("x", k, l)
>>> D = density(X)(z)
>>> pprint(D, use_unicode=False)
k k - 1 -l*z
l *z *e
---------------
Gamma(k)
>>> C = cdf(X)(z)
>>> pprint(C, use_unicode=False)
/lowergamma(k, l*z)
|------------------ for z > 0
< Gamma(k)
|
\ 0 otherwise
>>> E(X)
k/l
>>> simplify(variance(X))
k/l**2
参考
[R940]
en.wikipedia.org/wiki/Erlang_distribution
[R941]
mathworld.wolfram.com/ErlangDistribution.html
sympy.stats.ExGaussian(name, mean, std, rate)
创建一个连续随机变量，其服从指数修正高斯分布。
参数:
name : 字符串，给出此分布的名称
mean : 实数，高斯分布组分的均值
std : 正实数,
数学:
(\sigma² > 0)，高斯分布组分的方差
rate : 正实数,
数学:
(\lambda > 0)，指数分布组分的速率
返回:
RandomSymbol
说明
指数修正高斯分布的密度函数为
[f(x) := \frac{\lambda}{2}e^{\frac{\lambda}{2}(2\mu+\lambda\sigma²-2x)} \text{erfc}(\frac{\mu + \lambda\sigma² - x}{\sqrt{2}\sigma})]
对于 (x > 0)。注意期望值为 (1/\lambda)。
示例
>>> from sympy.stats import ExGaussian, density, cdf, E
>>> from sympy.stats import variance, skewness
>>> from sympy import Symbol, pprint, simplify
>>> mean = Symbol("mu")
>>> std = Symbol("sigma", positive=True)
>>> rate = Symbol("lamda", positive=True)
>>> z = Symbol("z")
>>> X = ExGaussian("x", mean, std, rate)
>>> pprint(density(X)(z), use_unicode=False)
/ 2 \
lamda*\lamda*sigma + 2*mu - 2*z/
--------------------------------- / ___ / 2 \\
2 |\/ 2 *\lamda*sigma + mu - z/|
lamda*e *erfc|-----------------------------|
\ 2*sigma /
----------------------------------------------------------------------------
2
>>> cdf(X)(z)
-(erf(sqrt(2)*(-lamda**2*sigma**2 + lamda*(-mu + z))/(2*lamda*sigma))/2 + 1/2)*exp(lamda**2*sigma**2/2 - lamda*(-mu + z)) + erf(sqrt(2)*(-mu + z)/(2*sigma))/2 + 1/2
>>> E(X)
(lamda*mu + 1)/lamda
>>> simplify(variance(X))
sigma**2 + lamda**(-2)
>>> simplify(skewness(X))
2/(lamda**2*sigma**2 + 1)**(3/2)
参考文献
[R942]
en.wikipedia.org/wiki/Exponentially_modified_Gaussian_distribution
sympy.stats.Exponential(name, rate)
创建一个连续随机变量，其服从指数分布。
参数:
rate : 正实数，(\lambda > 0)，速率（或逆比例/逆均值）
返回:
RandomSymbol
说明
指数分布的密度函数为
[f(x) := \lambda \exp(-\lambda x)]
对于 (x > 0)。注意期望值为 (1/\lambda)。
示例
>>> from sympy.stats import Exponential, density, cdf, E
>>> from sympy.stats import variance, std, skewness, quantile
>>> from sympy import Symbol
>>> l = Symbol("lambda", positive=True)
>>> z = Symbol("z")
>>> p = Symbol("p")
>>> X = Exponential("x", l)
>>> density(X)(z)
lambda*exp(-lambda*z)
>>> cdf(X)(z)
Piecewise((1 - exp(-lambda*z), z >= 0), (0, True))
>>> quantile(X)(p)
-log(1 - p)/lambda
>>> E(X)
1/lambda
>>> variance(X)
lambda**(-2)
>>> skewness(X)
2
>>> X = Exponential('x', 10)
>>> density(X)(z)
10*exp(-10*z)
>>> E(X)
1/10
>>> std(X)
1/10
参考文献
[R943]
en.wikipedia.org/wiki/Exponential_distribution
[R944]
mathworld.wolfram.com/ExponentialDistribution.html
sympy.stats.FDistribution(name, d1, d2)
创建一个连续随机变量，其服从 F 分布。
参数:
d1 : (d_1 > 0)，其中 (d_1) 是自由度 ((n_1 - 1))
d2 : (d_2 > 0)，其中 (d_2) 是自由度 ((n_2 - 1))
返回:
RandomSymbol
说明
F 分布的密度函数为
[f(x) := \frac{\sqrt{\frac{(d_1 x)^{d_1} d_2^{d_2}} {(d_1 x + d_2)^{d_1 + d_2}}}} {x \mathrm{B} \left(\frac{d_1}{2}, \frac{d_2}{2}\right)}]
对于 (x > 0)。
示例
>>> from sympy.stats import FDistribution, density
>>> from sympy import Symbol, pprint
>>> d1 = Symbol("d1", positive=True)
>>> d2 = Symbol("d2", positive=True)
>>> z = Symbol("z")
>>> X = FDistribution("x", d1, d2)
>>> D = density(X)(z)
>>> pprint(D, use_unicode=False)
d2
-- ______________________________
2 / d1 -d1 - d2
d2 *\/ (d1*z) *(d1*z + d2)
--------------------------------------
/d1 d2\
z*B|--, --|
\2 2 /
参考文献
[R945]
en.wikipedia.org/wiki/F-distribution
[R946]
mathworld.wolfram.com/F-Distribution.html
sympy.stats.FisherZ(name, d1, d2)
创建一个连续随机变量，其服从 Fisher's Z 分布。
参数:
d1 : (d_1 > 0)
自由度。
d2 : (d_2 > 0)
自由度。
返回:
RandomSymbol
说明
Fisher's Z 分布的密度函数为
[f(x) := \frac{2d_1^{d_1/2} d_2^{d_2/2}} {\mathrm{B}(d_1/2, d_2/2)} \frac{e{d_1z}}{\left(d_1e+d_2\right)^{\left(d_1+d_2\right)/2}}]
示例
>>> from sympy.stats import FisherZ, density
>>> from sympy import Symbol, pprint
>>> d1 = Symbol("d1", positive=True)
>>> d2 = Symbol("d2", positive=True)
>>> z = Symbol("z")
>>> X = FisherZ("x", d1, d2)
>>> D = density(X)(z)
>>> pprint(D, use_unicode=False)
d1 d2
d1 d2 - -- - --
-- -- 2 2
2 2 / 2*z \ d1*z
2*d1 *d2 *\d1*e + d2/ *e
-----------------------------------------
/d1 d2\
B|--, --|
\2 2 /
参考文献
[R947]
zh.wikipedia.org/wiki/Fisher%E7%9A%84z%E5%88%86%E5%B8%83
[R948]
mathworld.wolfram.com/Fishersz-Distribution.html
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))，最小值
返回：
随机符号
解释
Frechet 分布的密度为
[f(x) := \frac{\alpha}{s} \left(\frac{x-m}{s}\right)^{-1-\alpha} e{-(\frac{x-m}{s}){-\alpha}}]
对于 (x \geq m)。
例子
>>> from sympy.stats import Frechet, density, cdf
>>> from sympy import Symbol
>>> a = Symbol("a", positive=True)
>>> s = Symbol("s", positive=True)
>>> m = Symbol("m", real=True)
>>> z = Symbol("z")
>>> X = Frechet("x", a, s, m)
>>> density(X)(z)
a*((-m + z)/s)**(-a - 1)*exp(-1/((-m + z)/s)**a)/s
>>> cdf(X)(z)
Piecewise((exp(-1/((-m + z)/s)**a), m <= z), (0, True))
参考文献
[R949]
zh.wikipedia.org/wiki/Fr%C3%A9chet%E5%88%86%E5%B8%83
sympy.stats.Gamma(name, k, theta)
利用 Gamma 分布创建一个连续随机变量。
参数：
k : 实数，(k > 0)，一个形状
theta : 实数，(\theta > 0)，一个尺度
返回：
随机符号
解释
Gamma 分布的密度为
[f(x) := \frac{1}{\Gamma(k) \theta^k} x^{k - 1} e^{-\frac{x}{\theta}}]
对于 (x \in [0,1])。
例子
>>> from sympy.stats import Gamma, density, cdf, E, variance
>>> from sympy import Symbol, pprint, simplify
>>> k = Symbol("k", positive=True)
>>> theta = Symbol("theta", positive=True)
>>> z = Symbol("z")
>>> X = Gamma("x", k, theta)
>>> D = density(X)(z)
>>> pprint(D, use_unicode=False)
-z
-----
-k k - 1 theta
theta *z *e
---------------------
Gamma(k)
>>> C = cdf(X, meijerg=True)(z)
>>> pprint(C, use_unicode=False)
/ / z \
|k*lowergamma|k, -----|
| \ theta/
<---------------------- for z >= 0
| Gamma(k + 1)
|
\ 0 otherwise
>>> E(X)
k*theta
>>> V = simplify(variance(X))
>>> pprint(V, use_unicode=False)
2
k*theta
参考文献
[R950]
zh.wikipedia.org/wiki/Gamma%E5%88%86%E5%B8%83
[R951]
mathworld.wolfram.com/GammaDistribution.html
sympy.stats.GammaInverse(name, a, b)
利用逆 Gamma 分布创建一个连续随机变量。
参数：
a : 实数，(a > 0)，一个形状
b : 实数，(b > 0)，一个尺度
返回：
随机符号
解释
逆 Gamma 分布的密度为
[f(x) := \frac{\beta^\alpha}{\Gamma(\alpha)} x^{-\alpha - 1} \exp\left(\frac{-\beta}{x}\right)]
对于 (x > 0)。
例子
>>> from sympy.stats import GammaInverse, density, cdf
>>> from sympy import Symbol, pprint
>>> a = Symbol("a", positive=True)
>>> b = Symbol("b", positive=True)
>>> z = Symbol("z")
>>> X = GammaInverse("x", a, b)
>>> D = density(X)(z)
>>> pprint(D, use_unicode=False)
-b
---
a -a - 1 z
b *z *e
---------------
Gamma(a)
>>> cdf(X)(z)
Piecewise((uppergamma(a, b/z)/gamma(a), z > 0), (0, True))
参考文献
[R952]
zh.wikipedia.org/wiki/%E5%80%92%E4%B8%B2%E5%88%86%E5%B8%83
sympy.stats.Gompertz(name, b, eta)
利用 Gompertz 分布创建一个连续随机变量。
参数：
b : 实数，(b > 0)，一个尺度
eta : 实数，(\eta > 0)，一个形状
返回：
随机符号
解释
Gompertz 分布的密度为
[f(x) := b \eta e^{b x} e^{\eta} \exp \left(-\eta e^{bx} \right)]
对于 (x \in 0, \infty))。
例子
>>> from sympy.stats import Gompertz, density
>>> from sympy import Symbol
>>> b = Symbol("b", positive=True)
>>> eta = Symbol("eta", positive=True)
>>> z = Symbol("z")
>>> X = Gompertz("x", b, eta)
>>> density(X)(z)
b*eta*exp(eta)*exp(b*z)*exp(-eta*exp(b*z))
参考文献
[[R953]
zh.wikipedia.org/wiki/Gompertz%E5%88%86%E5%B8%83
sympy.stats.Gumbel(name, beta, mu, minimum=False)
利用 Gumbel 分布创建一个连续随机变量。
参数：
mu : 实数，(\mu)，一个位置
beta : 实数，(\beta > 0)，一个尺度
minimum : 布尔值，默认为 False，设置为 True 以启用最小分布
返回：
随机符号
解释
Gumbel 分布的密度为
对于最大值
[f(x) := \dfrac{1}{\beta} \exp \left( -\dfrac{x-\mu}{\beta} - \exp \left( -\dfrac{x - \mu}{\beta} \right) \right)]
对于 (x \in [ - \infty, \infty ])。
最小值
[f(x) := \frac{e^{- e^{\frac{- \mu + x}{\beta}} + \frac{- \mu + x}{\beta}}}{\beta}]
对于(x \in [ - \infty, \infty ])。
示例
>>> from sympy.stats import Gumbel, density, cdf
>>> from sympy import Symbol
>>> x = Symbol("x")
>>> mu = Symbol("mu")
>>> beta = Symbol("beta", positive=True)
>>> X = Gumbel("x", beta, mu)
>>> density(X)(x)
exp(-exp(-(-mu + x)/beta) - (-mu + x)/beta)/beta
>>> cdf(X)(x)
exp(-exp(-(-mu + x)/beta))
参考文献
[R954]
mathworld.wolfram.com/GumbelDistribution.html
[R955]
zh.wikipedia.org/wiki/%E6%B3%BB%E5%8D%9C%E5%88%86%E5%B8%83
[R956]
[R957]
sympy.stats.Kumaraswamy(name, a, b)
使用 Kumaraswamy 分布创建连续随机变量。
参数：
a：实数，(a > 0)，一个形状
b：实数，(b > 0)，一个形状
返回：
随机符号
说明
Kumaraswamy 分布的密度由以下给出
[f(x) := a b x^{a-1} (1-xa)]
对于(x \in [0,1])。
示例
>>> from sympy.stats import Kumaraswamy, density, cdf
>>> from sympy import Symbol, pprint
>>> a = Symbol("a", positive=True)
>>> b = Symbol("b", positive=True)
>>> z = Symbol("z")
>>> X = Kumaraswamy("x", a, b)
>>> D = density(X)(z)
>>> pprint(D, use_unicode=False)
b - 1
a - 1 / a\
a*b*z *\1 - z /
>>> cdf(X)(z)
Piecewise((0, z < 0), (1 - (1 - z**a)**b, z <= 1), (1, True))
参考文献
[R958]
zh.wikipedia.org/wiki/Kumaraswamy%E5%88%86%E5%B8%83
sympy.stats.Laplace(name, mu, b)
使用拉普拉斯分布创建连续随机变量。
参数：
mu：实数或列表/矩阵，位置（平均值）或
位置向量
b：实数或正定矩阵，表示一个比例
或协方差矩阵。
返回：
随机符号
说明
Logistic 分布的密度由以下给出
[f(x) := \frac{1}{2 b} \exp \left(-\frac{|x-\mu|}b \right)]
示例
>>> 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
参考文献
[R959]
en.wikipedia.org/wiki/Laplace_distribution
[R960]
mathworld.wolfram.com/LaplaceDistribution.html
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)))
参考文献
[R961]
zh.wikipedia.org/wiki/L%C3%A9vy%E5%88%86%E5%B8%83
[R962]
mathworld.wolfram.com/LevyDistribution.html
sympy.stats.Logistic(name, mu, s)
使用 Logistic 分布创建连续随机变量。
参数：
mu：实数，位置（平均值）
s：实数，(s > 0)，一个比例
返回：
随机符号
说明
Laplace 分布的密度由以下给出
[f(x) := \frac{e^{-(x-\mu)/s}} {s\left(1+e^{-(x-\mu)/s}\right)²}]
示例
>>> 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)
参考文献
[R963]
en.wikipedia.org/wiki/Logistic_distribution
[R964]
mathworld.wolfram.com/LogisticDistribution.html
sympy.stats.LogLogistic(name, alpha, beta)
创建一个带有对数-逻辑分布的连续随机变量。当 beta > 1 时，分布是单峰的。
参数：
alpha：实数，(\alpha > 0)，尺度参数和分布的中位数
beta：实数，(\beta > 0)，为形状参数
返回：
随机符号
解释
对数-逻辑分布的密度由以下给出
[f(x) := \frac{(\frac{\beta}{\alpha})(\frac{x}{\alpha})^{\beta - 1}} {(1 + (\frac{x}{\alpha})^{\beta})²}]
示例
>>> 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)
参考文献
[R965]
en.wikipedia.org/wiki/Log-logistic_distribution
sympy.stats.LogNormal(name, mean, std)
创建一个带有对数正态分布的连续随机变量。
参数：
mu：实数
对数尺度。
sigma：实数
一个形状。（(\sigma² > 0)）
返回：
随机符号
解释
对数正态分布的密度由以下给出
[f(x) := \frac{1}{x\sqrt{2\pi\sigma²}} e^{-\frac{\left(\ln x-\mu\right)²}{2\sigma²}}]
当 (x \geq 0) 时。
示例
>>> from sympy.stats import LogNormal, density
>>> from sympy import Symbol, pprint
>>> mu = Symbol("mu", real=True)
>>> sigma = Symbol("sigma", positive=True)
>>> z = Symbol("z")
>>> X = LogNormal("x", mu, sigma)
>>> D = density(X)(z)
>>> pprint(D, use_unicode=False)
2
-(-mu + log(z))
-----------------
2
___ 2*sigma
\/ 2 *e
------------------------
____
2*\/ pi *sigma*z
>>> X = LogNormal('x', 0, 1) # Mean 0, standard deviation 1
>>> density(X)(z)
sqrt(2)*exp(-log(z)**2/2)/(2*sqrt(pi)*z)
参考文献
[R966]
en.wikipedia.org/wiki/Lognormal
[R967]
mathworld.wolfram.com/LogNormalDistribution.html
sympy.stats.Lomax(name, alpha, lamda)
创建一个带有 Lomax 分布的连续随机变量。
参数：
alpha：实数，(\alpha > 0)
形状参数
lamda：实数，(\lambda > 0)
尺度参数
返回：
随机符号
解释
Lomax 分布的密度由以下给出
[f(x) := \frac{\alpha}{\lambda}\left[1+\frac{x}{\lambda}\right]^{-(\alpha+1)}]
示例
>>> from sympy.stats import Lomax, density, cdf, E
>>> from sympy import symbols
>>> a, l = symbols('a, l', positive=True)
>>> X = Lomax('X', a, l)
>>> x = symbols('x')
>>> density(X)(x)
a*(1 + x/l)**(-a - 1)/l
>>> cdf(X)(x)
Piecewise((1 - 1/(1 + x/l)**a, x >= 0), (0, True))
>>> a = 2
>>> X = Lomax('X', a, l)
>>> E(X)
l
参考文献
[R968]
en.wikipedia.org/wiki/Lomax_distribution
sympy.stats.Maxwell(name, a)
创建一个带有 Maxwell 分布的连续随机变量。
参数：
a：实数，(a > 0)
返回：
随机符号
解释
Maxwell 分布的密度由以下给出
[f(x) := \sqrt{\frac{2}{\pi}} \frac{x² e^{-x²/(2a²)}}{a³}]
当 (x \geq 0) 时。
示例
>>> from sympy.stats import Maxwell, density, E, variance
>>> from sympy import Symbol, simplify
>>> a = Symbol("a", positive=True)
>>> z = Symbol("z")
>>> X = Maxwell("x", a)
>>> density(X)(z)
sqrt(2)*z**2*exp(-z**2/(2*a**2))/(sqrt(pi)*a**3)
>>> E(X)
2*sqrt(2)*a/sqrt(pi)
>>> simplify(variance(X))
a**2*(-8 + 3*pi)/pi
参考文献
[R969]
en.wikipedia.org/wiki/Maxwell_distribution
[R970]
mathworld.wolfram.com/MaxwellDistribution.html
sympy.stats.Moyal(name, mu, sigma)
创建一个带有 Moyal 分布的连续随机变量。
参数：
mu：实数
位置参数
sigma：实数正数
尺度参数
返回：
随机符号
解释
Moyal 分布的密度由以下给出
[f(x) := \frac{\exp-\frac{1}{2}\exp-\frac{x-\mu}{\sigma}-\frac{x-\mu}{2\sigma}}{\sqrt{2\pi}\sigma}]
其中 (x \in \mathbb{R})。
示例
>>> from sympy.stats import Moyal, density, cdf
>>> from sympy import Symbol, simplify
>>> mu = Symbol("mu", real=True)
>>> sigma = Symbol("sigma", positive=True, real=True)
>>> z = Symbol("z")
>>> X = Moyal("x", mu, sigma)
>>> density(X)(z)
sqrt(2)*exp(-exp((mu - z)/sigma)/2 - (-mu + z)/(2*sigma))/(2*sqrt(pi)*sigma)
>>> simplify(cdf(X)(z))
1 - erf(sqrt(2)*exp((mu - z)/(2*sigma))/2)
参考文献
[R971]
reference.wolfram.com/language/ref/MoyalDistribution.html
[R972]
www.stat.rice.edu/~dobelman/textfiles/DistributionsHandbook.pdf
sympy.stats.Nakagami(name, mu, omega)
创建一个带有 Nakagami 分布的连续随机变量。
参数：
mu：实数，(\mu \geq \frac{1}{2})，形状
omega：实数，(\omega > 0)，扩散
返回：
RandomSymbol
解释
Nakagami 分布的密度由以下公式给出
[f(x) := \frac{2\mu\mu}{\Gamma(\mu)\omega\mu} x^{2\mu-1} \exp\left(-\frac{\mu}{\omega}x² \right)]
在(x > 0)的条件下。
示例
>>> from sympy.stats import Nakagami, density, E, variance, cdf
>>> from sympy import Symbol, simplify, pprint
>>> mu = Symbol("mu", positive=True)
>>> omega = Symbol("omega", positive=True)
>>> z = Symbol("z")
>>> X = Nakagami("x", mu, omega)
>>> D = density(X)(z)
>>> pprint(D, use_unicode=False)
2
-mu*z
-------
mu -mu 2*mu - 1 omega
2*mu *omega *z *e
----------------------------------
Gamma(mu)
>>> simplify(E(X))
sqrt(mu)*sqrt(omega)*gamma(mu + 1/2)/gamma(mu + 1)
>>> V = simplify(variance(X))
>>> pprint(V, use_unicode=False)
2
omega*Gamma (mu + 1/2)
omega - -----------------------
Gamma(mu)*Gamma(mu + 1)
>>> cdf(X)(z)
Piecewise((lowergamma(mu, mu*z**2/omega)/gamma(mu), z > 0),
(0, True))
参考
[R973]
en.wikipedia.org/wiki/Nakagami_distribution
sympy.stats.Normal(name, mean, std)
创建一个带有正态分布的连续随机变量。
参数：
mu：实数或表示均值或均值向量的列表
sigma：实数或正定方阵，
(\sigma² > 0)，方差
返回：
RandomSymbol
解释
正态分布的密度由以下公式给出
[f(x) := \frac{1}{\sigma\sqrt{2\pi}} e^{ -\frac{(x-\mu)²}{2\sigma²} }]
示例
>>> 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))
参考
[R974]
en.wikipedia.org/wiki/Normal_distribution
[R975]
mathworld.wolfram.com/NormalDistributionFunction.html
sympy.stats.Pareto(name, xm, alpha)
创建一个带有 Pareto 分布的连续随机变量。
参数：
xm：实数，(x_m > 0)，尺度
alpha：实数，(\alpha > 0)，形状
返回：
RandomSymbol
解释
Pareto 分布的密度由以下公式给出
[f(x) := \frac{\alpha,x_m\alpha}{x{\alpha+1}}]
在(x \in [x_m,\infty])的条件下。
示例
>>> from sympy.stats import Pareto, density
>>> from sympy import Symbol
>>> xm = Symbol("xm", positive=True)
>>> beta = Symbol("beta", positive=True)
>>> z = Symbol("z")
>>> X = Pareto("x", xm, beta)
>>> density(X)(z)
beta*xm**beta*z**(-beta - 1)
参考
[R976]
en.wikipedia.org/wiki/Pareto_distribution
[R977]
mathworld.wolfram.com/ParetoDistribution.html
sympy.stats.PowerFunction(name, alpha, a, b)
创建一个带有 Power Function Distribution 的连续随机变量。
参数：
alpha：正数，(0 < \alpha)，形状参数
a：实数，(-\infty < a)，左边界
b：实数，(a < b < \infty)，右边界
返回：
RandomSymbol
解释
PowerFunction 分布的密度由以下公式给出
[f(x) := \frac{{\alpha}(x - a)^{\alpha - 1}}{(b - a)^{\alpha}}]
在(x \in [a,b])的条件下。
示例
>>> from sympy.stats import PowerFunction, density, cdf, E, variance
>>> from sympy import Symbol
>>> alpha = Symbol("alpha", positive=True)
>>> a = Symbol("a", real=True)
>>> b = Symbol("b", real=True)
>>> z = Symbol("z")
>>> X = PowerFunction("X", 2, a, b)
>>> density(X)(z)
(-2*a + 2*z)/(-a + b)**2
>>> cdf(X)(z)
Piecewise((a**2/(a**2 - 2*a*b + b**2) - 2*a*z/(a**2 - 2*a*b + b**2) +
z**2/(a**2 - 2*a*b + b**2), a <= z), (0, True))
>>> alpha = 2
>>> a = 0
>>> b = 1
>>> Y = PowerFunction("Y", alpha, a, b)
>>> E(Y)
2/3
>>> variance(Y)
1/18
参考
[R978]
sympy.stats.QuadraticU(name, a, b)
创建一个带有 U-二次分布的连续随机变量。
参数：
a：实数
b：实数，(a < b)
返回：
RandomSymbol
说明
U-二次分布的密度由下式给出：
[f(x) := \alpha (x-\beta)²]
当 (x \in [a,b]) 时。
示例
>>> from sympy.stats import QuadraticU, density
>>> from sympy import Symbol, pprint
>>> a = Symbol("a", real=True)
>>> b = Symbol("b", real=True)
>>> z = Symbol("z")
>>> X = QuadraticU("x", a, b)
>>> D = density(X)(z)
>>> pprint(D, use_unicode=False)
/ 2
| / a b \
|12*|- - - - + z|
| \ 2 2 /
<----------------- for And(b >= z, a <= z)
| 3
| (-a + b)
|
\ 0 otherwise
参考文献
[R979]
en.wikipedia.org/wiki/U-quadratic_distribution
sympy.stats.RaisedCosine(name, mu, s)
使用提升余弦分布创建连续随机变量。
参数：
mu：实数
s：实数，(s > 0)
返回：
随机符号
说明
提升余弦分布的密度由下式给出：
[f(x) := \frac{1}{2s}\left(1+\cos\left(\frac{x-\mu}{s}\pi\right)\right)]
当 (x \in [\mu-s,\mu+s]) 时。
示例
>>> from sympy.stats import RaisedCosine, density
>>> from sympy import Symbol, pprint
>>> mu = Symbol("mu", real=True)
>>> s = Symbol("s", positive=True)
>>> z = Symbol("z")
>>> X = RaisedCosine("x", mu, s)
>>> D = density(X)(z)
>>> pprint(D, use_unicode=False)
/ /pi*(-mu + z)\
|cos|------------| + 1
| \ s /
<--------------------- for And(z >= mu - s, z <= mu + s)
| 2*s
|
\ 0 otherwise
参考文献
[R980]
en.wikipedia.org/wiki/Raised_cosine_distribution
sympy.stats.Rayleigh(name, sigma)
使用雷利分布创建连续随机变量。
参数：
sigma：实数，(\sigma > 0)
返回：
随机符号
说明
雷利分布的密度由下式给出：
[f(x) := \frac{x}{\sigma²} e^{-x²/2\sigma²}]
当 (x > 0) 时。
示例
>>> from sympy.stats import Rayleigh, density, E, variance
>>> from sympy import Symbol
>>> sigma = Symbol("sigma", positive=True)
>>> z = Symbol("z")
>>> X = Rayleigh("x", sigma)
>>> density(X)(z)
z*exp(-z**2/(2*sigma**2))/sigma**2
>>> E(X)
sqrt(2)*sqrt(pi)*sigma/2
>>> variance(X)
-pi*sigma**2/2 + 2*sigma**2
参考
[R981]
en.wikipedia.org/wiki/Rayleigh_distribution
[R982]
mathworld.wolfram.com/RayleighDistribution.html
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))
参考
[R983]
en.wikipedia.org/wiki/Reciprocal_distribution
sympy.stats.StudentT(name, nu)
使用学生 t 分布创建连续随机变量。
参数：
nu：实数，(\nu > 0)，自由度
返回：
随机符号
说明
学生 t 分布的密度由下式给出：
[f(x) := \frac{\Gamma \left(\frac{\nu+1}{2} \right)} {\sqrt{\nu\pi}\Gamma \left(\frac{\nu}{2} \right)} \left(1+\frac{x²}{\nu} \right)^{-\frac{\nu+1}{2}}]
示例
>>> 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))
参考
[R984]
en.wikipedia.org/wiki/Student_t-distribution
[R985]
mathworld.wolfram.com/Studentst-Distribution.html
sympy.stats.ShiftedGompertz(name, b, eta)
使用移位戈姆佩尔茨分布创建连续随机变量。
参数：
b：实数，(b > 0)，一个尺度
eta：实数，(\eta > 0)，一个形状
返回：
随机符号
说明
移位戈姆佩尔茨分布的密度由下式给出：
[f(x) := b e^{-b x} e^{-\eta \exp(-b x)} \left[1 + \eta(1 - e^(-bx)) \right]]
当 (x \in 0, \infty)) 时。
示例
>>> from sympy.stats import ShiftedGompertz, density
>>> from sympy import Symbol
>>> b = Symbol("b", positive=True)
>>> eta = Symbol("eta", positive=True)
>>> x = Symbol("x")
>>> X = ShiftedGompertz("x", b, eta)
>>> density(X)(x)
b*(eta*(1 - exp(-b*x)) + 1)*exp(-b*x)*exp(-eta*exp(-b*x))
参考文献
[[R986]
en.wikipedia.org/wiki/Shifted_Gompertz_distribution
sympy.stats.Trapezoidal(name, a, b, c, d)
使用梯形分布创建连续随机变量。
参数：
a：实数，(a < d)
b：实数，(a \le b < c)
c：实数，(b < c \le d)
d : 实数
返回：
RandomSymbol
解释
梯形分布的密度由以下给出
[\begin{split}f(x) := \begin{cases} 0 & \mathrm{对于\ } x < a, \ \frac{2(x-a)}{(b-a)(d+c-a-b)} & \mathrm{对于\ } a \le x < b, \ \frac{2}{d+c-a-b} & \mathrm{对于\ } b \le x < c, \ \frac{2(d-x)}{(d-c)(d+c-a-b)} & \mathrm{对于\ } c \le x < d, \ 0 & \mathrm{对于\ } d < x. \end{cases}\end{split}]
示例
>>> 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
参考
[R987]
sympy.stats.Triangular(name, a, b, c)
创建一个具有三角分布的连续随机变量。
参数：
a : 实数，(a \in \left(-\infty, \infty\right))，左边界
b : 实数，(a < b)
c : 实数，(a \leq c \leq b)
返回：
RandomSymbol
解释
三角分布的密度由以下给出
[\begin{split}f(x) := \begin{cases} 0 & \mathrm{对于\ } x < a, \ \frac{2(x-a)}{(b-a)(c-a)} & \mathrm{对于\ } a \le x < c, \ \frac{2}{b-a} & \mathrm{对于\ } x = c, \ \frac{2(b-x)}{(b-a)(b-c)} & \mathrm{对于\ } c < x \le b, \ 0 & \mathrm{对于\ } b < x. \end{cases}\end{split}]
示例
>>> 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
参考
[R988]
[R989]
mathworld.wolfram.com/TriangularDistribution.html
sympy.stats.Uniform(name, left, right)
创建一个具有均匀分布的连续随机变量。
参数：
a : 实数，(-\infty < a)，左边界
b : 实数，(a < b < \infty)，右边界
返回：
RandomSymbol
解释
一致分布的密度由以下给出
[\begin{split}f(x) := \begin{cases} \frac{1}{b - a} & \text{对于 } x \in [a,b] \ 0 & \text{其他情况} \end{cases}\end{split}]
其中 (x \in [a,b]).
示例
>>> from sympy.stats import Uniform, density, cdf, E, variance
>>> from sympy import Symbol, simplify
>>> a = Symbol("a", negative=True)
>>> b = Symbol("b", positive=True)
>>> z = Symbol("z")
>>> X = Uniform("x", a, b)
>>> density(X)(z)
Piecewise((1/(-a + b), (b >= z) & (a <= z)), (0, True))
>>> cdf(X)(z)
Piecewise((0, a > z), ((-a + z)/(-a + b), b >= z), (1, True))
>>> E(X)
a/2 + b/2
>>> simplify(variance(X))
a**2/12 - a*b/6 + b**2/12
参考
[R990]
[R991]
mathworld.wolfram.com/UniformDistribution.html
sympy.stats.UniformSum(name, n)
创建一个具有 Irwin-Hall 分布的连续随机变量。
参数：
n : 正整数，(n > 0)
返回：
RandomSymbol
解释
概率分布函数依赖于一个整数参数 (n)。
Irwin-Hall 分布的密度由以下给出
[f(x) := \frac{1}{(n-1)!}\sum_{k=0}^{\left\lfloor x\right\rfloor}(-1)^k \binom{n}{k}(x-k)^{n-1}]
示例
>>> 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 的求和的评估。
参考
[R992]
[R993]
mathworld.wolfram.com/UniformSumDistribution.html
sympy.stats.VonMises(name, mu, k)
创建一个具有 von Mises 分布的连续随机变量。
参数：
mu：实数
位置度量。
k：实数
集中度量。
返回：
RandomSymbol
解释
von Mises 分布的密度函数为
[f(x) := \frac{e^{\kappa\cos(x-\mu)}}{2\pi I_0(\kappa)}]
其中 (x \in [0,2\pi])。
示例
>>> from sympy.stats import VonMises, density
>>> from sympy import Symbol, pprint
>>> mu = Symbol("mu")
>>> k = Symbol("k", positive=True)
>>> z = Symbol("z")
>>> X = VonMises("x", mu, k)
>>> D = density(X)(z)
>>> pprint(D, use_unicode=False)
k*cos(mu - z)
e
------------------
2*pi*besseli(0, k)
参考文献
[R994]
en.wikipedia.org/wiki/Von_Mises_distribution
[R995]
mathworld.wolfram.com/vonMisesDistribution.html
sympy.stats.Wald(name, mean, shape)
创建一个具有逆高斯分布的连续随机变量。逆高斯分布也称为 Wald 分布。
参数：
mu：
正数，表示平均数。
lambda：
正数，表示形状参数。
返回：
RandomSymbol
解释
逆高斯分布的密度函数为
[f(x) := \sqrt{\frac{\lambda}{2\pi x³}} e^{-\frac{\lambda(x-\mu)²}{2x\mu²}}]
示例
>>> 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)
参考文献
[R996]
en.wikipedia.org/wiki/Inverse_Gaussian_distribution
[R997]
mathworld.wolfram.com/InverseGaussianDistribution.html
sympy.stats.Weibull(name, alpha, beta)
创建一个具有 Weibull 分布的连续随机变量。
参数：
lambda：实数，(\lambda > 0)，表示尺度
k：实数，(k > 0)，表示形状
返回：
RandomSymbol
解释
Weibull 分布的密度函数为
[\begin{split}f(x) := \begin{cases} \frac{k}{\lambda}\left(\frac{x}{\lambda}\right)^{k-1} e{-(x/\lambda){k}} & x\geq0\ 0 & x<0 \end{cases}\end{split}]
示例
>>> 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))
参考文献
[R998]
en.wikipedia.org/wiki/Weibull_distribution
[R999]
mathworld.wolfram.com/WeibullDistribution.html
sympy.stats.WignerSemicircle(name, R)
创建一个具有 Wigner 半圆分布的连续随机变量。
参数：
R：实数，(R > 0)，表示半径
返回：
一个 RandomSymbol。
解释
Wigner 半圆分布的密度函数为
[f(x) := \frac2{\pi R²},\sqrt{R²-x²}]
其中 (x \in [-R,R])。
示例
>>> from sympy.stats import WignerSemicircle, density, E
>>> from sympy import Symbol
>>> R = Symbol("R", positive=True)
>>> z = Symbol("z")
>>> X = WignerSemicircle("x", R)
>>> density(X)(z)
2*sqrt(R**2 - z**2)/(pi*R**2)
>>> E(X)
0
参考文献
[R1000]
en.wikipedia.org/wiki/Wigner_semicircle_distribution
[R1001]
mathworld.wolfram.com/WignersSemicircleLaw.html
sympy.stats.ContinuousRV(symbol, density, set=Interval(-oo, oo), **kwargs)
创建一个给定以下内容的连续随机变量：
参数：
symbol：符号
表示随机变量的名称。
density：包含符号的表达式
表示概率密度函数。
set：集合/区间
默认情况下，表示 pdf 有效的区域是实线。
check：布尔值
如果为 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)
创建一个联合随机变量，其中每个组件都是连续的，给定以下内容：
参数：
symbol：符号
表示随机变量的名称。
pdf：关于给定符号的索引符号的概率密度函数
作为第一个参数
返回：
随机符号
注意
到目前为止，每个组件对于JointRV的集合等于所有整数的集合，这不能改变。
示例
>>> 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：具有联合概率分布的随机变量。
indices：组件索引或索引的随机符号
用于计算联合分布
返回：
(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]
参考文献
[R1002]
en.wikipedia.org/wiki/Multivariate_normal_distribution
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)
参考文献
[R1003]
en.wikipedia.org/wiki/Multivariate_Laplace_distribution
sympy.stats.GeneralizedMultivariateLogGamma(syms, delta, v, lamda, mu)
使用广义多元对数伽玛分布创建联合随机变量。
可以在[1]找到联合概率密度函数。
参数：
syms：用于识别每个组件的符号列表/元组/集合
delta：介于 ([0, 1]) 范围内的常数
v：正实数
lamda：正实数列表
mu：正实数列表
返回：
随机符号
示例
>>> 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
注意
如果 GeneralizedMultivariateLogGamma 太长无法输入，请使用，
>>> from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGamma as GMVLG
>>> Gd = GMVLG('G', d, v, l, mu)
如果要传递矩阵 omega 而不是常数 delta，则使用GeneralizedMultivariateLogGammaOmega。
参考文献
[R1004]
en.wikipedia.org/wiki/Generalized_multivariate_log-gamma_distribution
[R1005]
sympy.stats.GeneralizedMultivariateLogGammaOmega(syms, omega, v, lamda, mu)
扩展 GeneralizedMultivariateLogGamma。
参数：
syms：符号的列表/元组/集合
用于识别每个组件
omega：方阵
方阵的每个元素必须是相关系数的平方根的绝对值
v：正实数
lamda：正实数列表
mu：正实数列表
返回：
RandomSymbol
示例
>>> from sympy.stats import density
>>> from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGammaOmega
>>> from sympy import Matrix, symbols, S
>>> omega = Matrix([[1, S.Half, S.Half], [S.Half, 1, S.Half], [S.Half, S.Half, 1]])
>>> v = 1
>>> l, mu = [1, 1, 1], [1, 1, 1]
>>> G = GeneralizedMultivariateLogGammaOmega('G', omega, v, l, mu)
>>> y = symbols('y_1:4', positive=True)
>>> density(G)(y[0], y[1], y[2])
sqrt(2)*Sum((1 - sqrt(2)/2)**n*exp((n + 1)*(y_1 + y_2 + y_3) - exp(y_1) -
exp(y_2) - exp(y_3))/gamma(n + 1)**3, (n, 0, oo))/2
注意
如果 GeneralizedMultivariateLogGammaOmega 过长无法输入，请使用以下符号，
>>> from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGammaOmega as GMVLGO
>>> G = GMVLGO('G', omega, v, l, mu)
参考文献
[R1006]
en.wikipedia.org/wiki/Generalized_multivariate_log-gamma_distribution
[R1007]
sympy.stats.Multinomial(syms, n, *p)
创建具有多项分布的离散随机变量。
该分布的密度可以在[1]处找到。
参数：
n：正整数
表示试验次数
p：事件概率列表
必须在[0, 1]范围内。
返回：
RandomSymbol
示例
>>> from sympy.stats import density, Multinomial, marginal_distribution
>>> from sympy import symbols
>>> x1, x2, x3 = symbols('x1, x2, x3', nonnegative=True, integer=True)
>>> p1, p2, p3 = symbols('p1, p2, p3', positive=True)
>>> M = Multinomial('M', 3, p1, p2, p3)
>>> density(M)(x1, x2, x3)
Piecewise((6*p1**x1*p2**x2*p3**x3/(factorial(x1)*factorial(x2)*factorial(x3)),
Eq(x1 + x2 + x3, 3)), (0, True))
>>> marginal_distribution(M, M[0])(x1).subs(x1, 1)
3*p1*p2**2 + 6*p1*p2*p3 + 3*p1*p3**2
参考文献
[R1008]
en.wikipedia.org/wiki/Multinomial_distribution
[R1009]
mathworld.wolfram.com/MultinomialDistribution.html
sympy.stats.MultivariateBeta(syms, *alpha)
创建具有 Dirichlet/多变量贝塔分布的连续随机变量。
Dirichlet 分布的密度可以在[1]处找到。
参数：
alpha：正实数列表
表示浓度数字。
返回：
RandomSymbol
示例
>>> from sympy.stats import density, MultivariateBeta, marginal_distribution
>>> from sympy import Symbol
>>> a1 = Symbol('a1', positive=True)
>>> a2 = Symbol('a2', positive=True)
>>> B = MultivariateBeta('B', [a1, a2])
>>> C = MultivariateBeta('C', a1, a2)
>>> x = Symbol('x')
>>> y = Symbol('y')
>>> density(B)(x, y)
x**(a1 - 1)*y**(a2 - 1)*gamma(a1 + a2)/(gamma(a1)*gamma(a2))
>>> marginal_distribution(C, C[0])(x)
x**(a1 - 1)*gamma(a1 + a2)/(a2*gamma(a1)*gamma(a2))
参考文献
[R1010]
en.wikipedia.org/wiki/Dirichlet_distribution
[R1011]
mathworld.wolfram.com/DirichletDistribution.html
sympy.stats.MultivariateEwens(syms, n, theta)
创建具有多变量 Ewens 分布的离散随机变量。
该分布的密度可以在[1]处找到。
参数：
n：正整数
样本的大小或者考虑的整数的分区
theta：正实数
表示突变率
返回：
RandomSymbol
示例
>>> from sympy.stats import density, marginal_distribution, MultivariateEwens
>>> from sympy import Symbol
>>> a1 = Symbol('a1', positive=True)
>>> a2 = Symbol('a2', positive=True)
>>> ed = MultivariateEwens('E', 2, 1)
>>> density(ed)(a1, a2)
Piecewise((1/(2**a2*factorial(a1)*factorial(a2)), Eq(a1 + 2*a2, 2)), (0, True))
>>> marginal_distribution(ed, ed[0])(a1)
Piecewise((1/factorial(a1), Eq(a1, 2)), (0, True))
参考文献
[R1012]
en.wikipedia.org/wiki/Ewens%27s_sampling_formula
[R1013]
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])范围内
返回：
随机符号
示例
>>> 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
参考文献
[R1014]
en.wikipedia.org/wiki/Negative_multinomial_distribution
[R1015]
mathworld.wolfram.com/NegativeBinomialDistribution.html
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))
参考文献
[R1016]
en.wikipedia.org/wiki/Normal-gamma_distribution
随机过程
class sympy.stats.DiscreteMarkovChain(sym, state_space=None, trans_probs=None)
表示有限离散时间同质马尔可夫链。
这种马尔可夫链可以通过其（有序的）状态空间和其一步转移概率矩阵唯一地描述。
参数：
sym:
马尔可夫链的命名
state_space:
可选，默认为 Range(n)
trans_probs:
可选，默认为 MatrixSymbol(‘_T’, n, n)
示例
>>> from sympy.stats import DiscreteMarkovChain, TransitionMatrixOf, P, E
>>> from sympy import Matrix, MatrixSymbol, Eq, symbols
>>> T = Matrix([[0.5, 0.2, 0.3],[0.2, 0.5, 0.3],[0.2, 0.3, 0.5]])
>>> Y = DiscreteMarkovChain("Y", [0, 1, 2], T)
>>> YS = DiscreteMarkovChain("Y")
>>> Y.state_space
{0, 1, 2}
>>> Y.transition_probabilities
Matrix([
[0.5, 0.2, 0.3],
[0.2, 0.5, 0.3],
[0.2, 0.3, 0.5]])
>>> TS = MatrixSymbol('T', 3, 3)
>>> P(Eq(YS[3], 2), Eq(YS[1], 1) & TransitionMatrixOf(YS, TS))
T[0, 2]*T[1, 0] + T[1, 1]*T[1, 2] + T[1, 2]*T[2, 2]
>>> P(Eq(Y[3], 2), Eq(Y[1], 1)).round(2)
0.36
概率将基于索引而不是状态名称计算。例如，对于具有字符串状态名称的晴天-多云-雨天模型：
>>> 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
可以计算具有多个 RandomIndexedSymbols 的表达式的概率，前提是给定条件中只有 1 个 RandomIndexedSymbol。在转移矩阵中，最好使用有理数而不是浮点数作为概率，以避免错误。
>>> 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]
参考文献
[R1017]
en.wikipedia.org/wiki/Markov_chain#Discrete-time_Markov_chain
[R1018]
absorbing_probabilities()
计算吸收概率，即矩阵的 ij-th 条目表示从状态 i 开始到状态 j 吸收马尔可夫链的概率。
canonical_form() → Tuple[List[Basic], ImmutableDenseMatrix]
重新排列一步转移矩阵，使得经常性状态先出现，瞬态状态最后出现。其他表示包括先插入瞬态状态，后插入经常性状态。
返回：
states, 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]])
参见
sympy.stats.DiscreteMarkovChain.communication_classes，sympy.stats.DiscreteMarkovChain.decompose
参考文献
[R1019]
onlinelibrary.wiley.com/doi/pdf/10.1002/9780470316887.app1
[R1020]
www.columbia.edu/~ww2040/6711F12/lect1023big.pdf
communication_classes() → List[Tuple[List[Basic], Boolean, Integer]]
返回马尔可夫链状态分割的通信类列表。
通信类被定义为一组状态，使得该集合中的每个状态都可以从该集合中的任何其他状态到达。由于其属性，这在数学上形成一个类。通信类也称为循环类。
返回：
类
classes是一个元组列表。每个元组表示一个通信类及其属性。元组中的第一个元素是该类中的状态列表，第二个元素是该类是否是经常性的，第三个元素是通信类的周期。
示例
>>> 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。
注意事项
使用的算法是O(n**2)阶的，其中n是马尔可夫链中的状态数。它使用 Tarjan 算法找到类本身，然后使用广度优先搜索算法找到每个类的周期性。随着矩阵变得越来越稀疏，算法的大部分组件趋近于O(n)。
参考文献
[R1021]
web.archive.org/web/20220207032113/https://www.columbia.edu/~ww2040/4701Sum07/4701-06-Notes-MCII.pdf
[R1022]
cecas.clemson.edu/~shierd/Shier/markov.pdf
[R1023]
www.proquest.com/openview/4adc6a51d8371be5b0e4c7dff287fc70/1?pq-origsite=gscholar&cbl=2026366&diss=y
[R1024]
www.mathworks.com/help/econ/dtmc.classify.html
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 如何互动。
另请参阅
sympy.stats.DiscreteMarkovChain.communication_classes, sympy.stats.DiscreteMarkovChain.canonical_form
参考文献
[R1025]
en.wikipedia.org/wiki/Absorbing_Markov_chain
[R1026]
people.brandeis.edu/~igusa/Math56aS08/Math56a_S08_notes015.pdf
fixed_row_vector()
stationary_distribution()的包装器。
fundamental_matrix()
每个基本矩阵条目可以解释为如果以状态 i 开始，则链条处于状态 j 的预期次数。
参考文献
[R1027]
lips.cs.princeton.edu/the-fundamental-matrix-of-a-finite-markov-chain/
property limiting_distribution
固定的行向量是离散马尔可夫链的极限分布。
sample()
返回：
样本：迭代对象
包含样本的迭代对象
stationary_distribution(condition_set=False) → ImmutableDenseMatrix | ConditionSet | Lambda
静止分布是任何解 p = pP 的行向量 p，它是行随机的，p 中的每个元素必须是非负的。这意味着在矩阵形式中：((P-I)^T p^T = 0)，且 ((1, \dots, 1) p = 1)，其中 P 是一步转移矩阵。
所有有限状态空间的时齐马尔可夫链至少有一个静止分布。此外，如果一个有限时齐马尔可夫链是不可约的，则静止分布是唯一的。
参数：
condition_set ：bool
如果链具有符号大小或转移矩阵，则返回
Lambda（若为False）或返回ConditionSet（若为True）。
示例
>>> 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))
参见
sympy.stats.DiscreteMarkovChain.limiting_distribution
参考文献
[R1028]
www.probabilitycourse.com/chapter11/11_2_6_stationary_and_limiting_distributions.php
[R1029]
property transition_probabilities
离散马尔可夫链的转移概率，可以是 Matrix 的实例或 MatrixSymbol。
class sympy.stats.ContinuousMarkovChain(sym, state_space=None, gen_mat=None)
表示连续时间马尔可夫链。
参数：
sym ：Symbol/str
state_space ：集合
可选项，默认为 S.Reals
gen_mat ：Matrix/ImmutableMatrix/MatrixSymbol
可选项，默认为 None
示例
>>> 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
可以计算具有多个 RandomIndexedSymbols 的表达式的概率，前提是给定条件中只有 1 个 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
参考文献
[R1030]
en.wikipedia.org/wiki/Markov_chain#Continuous-time_Markov_chain
[R1031]
u.math.biu.ac.il/~amirgi/CTMCnotes.pdf
class sympy.stats.BernoulliProcess(sym, p, success=1, failure=0)
伯努利过程由重复独立的伯努利试验组成，这些试验具有相同的参数 (p)。假定概率 (p) 适用于每个试验，并且每次试验的结果都与其余所有试验独立。因此，伯努利过程是离散状态和离散时间随机过程。
参数：
sym ：Symbol/str
success：整数/字符串
被认为是成功的事件。默认值：1。
failure: 整数/字符串
被认为是失败的事件。默认值：0。
p：0 到 1 之间的实数
表示成功的概率。
示例
>>> from sympy.stats import BernoulliProcess, P, E
>>> from sympy import Eq, Gt
>>> B = BernoulliProcess("B", p=0.7, success=1, failure=0)
>>> B.state_space
{0, 1}
>>> B.p.round(2)
0.70
>>> B.success
1
>>> B.failure
0
>>> X = B[1] + B[2] + B[3]
>>> P(Eq(X, 0)).round(2)
0.03
>>> P(Eq(X, 2)).round(2)
0.44
>>> P(Eq(X, 4)).round(2)
0
>>> P(Gt(X, 1)).round(2)
0.78
>>> P(Eq(B[1], 0) & Eq(B[2], 1) & Eq(B[3], 0) & Eq(B[4], 1)).round(2)
0.04
>>> B.joint_distribution(B[1], B[2])
JointDistributionHandmade(Lambda((B[1], B[2]), Piecewise((0.7, Eq(B[1], 1)),
(0.3, Eq(B[1], 0)), (0, True))*Piecewise((0.7, Eq(B[2], 1)), (0.3, Eq(B[2], 0)),
(0, True))))
>>> E(2*B[1] + B[2]).round(2)
2.10
>>> P(B[1] < 1).round(2)
0.30
参考文献
[R1032]
en.wikipedia.org/wiki/Bernoulli_process
[R1033]
mathcs.clarku.edu/~djoyce/ma217/bernoulli.pdf
expectation(expr, condition=None, evaluate=True, **kwargs)
计算期望。
参数：
expr：随机索引符号、关系、逻辑
必须包含过程的随机索引符号的条件，计算期望的条件。
condition：关系、逻辑
应进行计算的给定条件。
返回：
随机索引符号的期望。
probability(condition, given_condition=None, evaluate=True, **kwargs)
计算概率。
参数：
condition：关系
计算概率的条件。必须包含过程的随机索引符号。
given_condition：关系、逻辑
应进行计算的给定条件。
返回：
条件的概率。
class sympy.stats.PoissonProcess(sym, lamda)
泊松过程是一个计数过程。通常用于我们计算出现在某一特定速率下似乎完全随机发生的某些事件的发生次数的场景中。
参数：
sym：符号/字符串
lamda：正数
进程的速率，
lambda > 0
示例
>>> from sympy.stats import PoissonProcess, P, E
>>> from sympy import symbols, Eq, Ne, Contains, Interval
>>> X = PoissonProcess("X", lamda=3)
>>> X.state_space
Naturals0
>>> X.lamda
3
>>> t1, t2 = symbols('t1 t2', positive=True)
>>> P(X(t1) < 4)
(9*t1**3/2 + 9*t1**2/2 + 3*t1 + 1)*exp(-3*t1)
>>> P(Eq(X(t1), 2) | Ne(X(t1), 4), Contains(t1, Interval.Ropen(2, 4)))
1 - 36*exp(-6)
>>> P(Eq(X(t1), 2) & Eq(X(t2), 3), Contains(t1, Interval.Lopen(0, 2))
... & Contains(t2, Interval.Lopen(2, 4)))
648*exp(-12)
>>> E(X(t1))
3*t1
>>> E(X(t1)**2 + 2*X(t2), Contains(t1, Interval.Lopen(0, 1))
... & Contains(t2, Interval.Lopen(1, 2)))
18
>>> P(X(3) < 1, Eq(X(1), 0))
exp(-6)
>>> P(Eq(X(4), 3), Eq(X(2), 3))
exp(-6)
>>> P(X(2) <= 3, X(1) > 1)
5*exp(-3)
合并两个泊松过程
>>> Y = PoissonProcess("Y", lamda=4)
>>> Z = X + Y
>>> Z.lamda
7
将泊松过程分割为两个独立的泊松过程
>>> N, M = Z.split(l1=2, l2=5)
>>> N.lamda, M.lamda
(2, 5)
参考文献
[R1034]
www.probabilitycourse.com/chapter11/11_0_0_intro.php
[R1035]
en.wikipedia.org/wiki/Poisson_point_process
class sympy.stats.WienerProcess(sym)
Wiener 过程是一个实值连续时间随机过程。在物理学中，它用于研究布朗运动，由于其与最初由苏格兰植物学家罗伯特·布朗观察到的同名物理过程的历史联系，通常也被称为布朗运动。
参数：
sym：符号/字符串
示例
>>> 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
参考文献
[R1036]
www.probabilitycourse.com/chapter11/11_4_0_brownian_motion_wiener_process.php
[R1037]
en.wikipedia.org/wiki/Wiener_process
class sympy.stats.GammaProcess(sym, lamda, gamma)
伽玛过程是一个具有独立伽玛分布增量的随机过程。它是一个纯跳跃递增的列维过程。
参数：
sym：符号/字符串
lamda：正数
过程的跳跃大小，
lamda > 0
gamma：正数
跳跃到达的速率，(\gamma > 0)
示例
>>> from sympy.stats import GammaProcess, E, P, variance
>>> from sympy import symbols, Contains, Interval, Not
>>> t, d, x, l, g = symbols('t d x l g', positive=True)
>>> X = GammaProcess("X", l, g)
>>> E(X(t))
g*t/l
>>> variance(X(t)).simplify()
g*t/l**2
>>> X = GammaProcess('X', 1, 2)
>>> P(X(t) < 1).simplify()
lowergamma(2*t, 1)/gamma(2*t)
>>> P(Not((X(t) < 5) & (X(d) > 3)), Contains(t, Interval.Ropen(2, 4)) &
... Contains(d, Interval.Lopen(7, 8))).simplify()
-4*exp(-3) + 472*exp(-8)/3 + 1
>>> E(X(2) + x*E(X(5)))
10*x + 4
参考文献
[R1038]
en.wikipedia.org/wiki/Gamma_process
矩阵分布
sympy.stats.MatrixGamma(symbol, alpha, beta, scale_matrix)
创建具有矩阵伽玛分布的随机变量。
所述分布的密度可在[1]找到。
参数：
alpha: 正实数
形状参数
beta: 正实数
规模参数
scale_matrix: 正定实数方阵
规模矩阵
返回：
随机符号
示例
>>> 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))
参考资料
[R1039]
sympy.stats.Wishart(symbol, n, scale_matrix)
创建具有 Wishart 分布的随机变量。
所述分布的密度可在[1]找到。
参数：
n: 正实数
代表自由度
scale_matrix: 正定实数方阵
规模矩阵
返回：
随机符号
示例
>>> 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))
参考资料
[R1040]
zh.wikipedia.org/wiki/Wishart 分布
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的规模矩阵
返回：
随机符号
示例
>>> 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)
参考资料
[R1041]
复合分布
class sympy.stats.compound_rv.CompoundDistribution(dist)
复合分布类。
参数：
dist : 分布
分布必须包含随机参数
示例
>>> from sympy.stats.compound_rv import CompoundDistribution
>>> from sympy.stats.crv_types import NormalDistribution
>>> from sympy.stats import Normal
>>> from sympy.abc import x
>>> X = Normal('X', 2, 4)
>>> N = NormalDistribution(X, 4)
>>> C = CompoundDistribution(N)
>>> C.set
Interval(-oo, oo)
>>> C.pdf(x, evaluate=True).simplify()
exp(-x**2/64 + x/16 - 1/16)/(8*sqrt(pi))
参考资料
[R1042]
接口
sympy.stats.P(condition, given_condition=None, numsamples=None, evaluate=True, **kwargs)
一个条件为真的概率，可选地给出第二个条件。
参数：
condition : 包含随机符号的关系组合
要计算概率的条件
given_condition : 包含随机符号的关系组合
一个条件表达式。P(X > 1, X > 0) 是给定 X > 0 的期望 X > 1
numsamples : 整数
启用抽样并使用这么多样本近似概率
evaluate : 布尔值（默认为真）
对于连续系统返回未评估的积分
示例
>>> from sympy.stats import P, Die
>>> from sympy import Eq
>>> X, Y = Die('X', 6), Die('Y', 6)
>>> P(X > 3)
1/2
>>> P(Eq(X, 5), X > 2) # Probability that X == 5 given that X > 2
1/4
>>> P(X > Y)
5/12
class sympy.stats.Probability(prob, condition=None, **kwargs)
概率的符号表达式。
示例
>>> from sympy.stats import Probability, Normal
>>> from sympy import Integral
>>> X = Normal("X", 0, 1)
>>> prob = Probability(X > 1)
>>> prob
Probability(X > 1)
积分表示：
>>> prob.rewrite(Integral)
Integral(sqrt(2)*exp(-_z**2/2)/(2*sqrt(pi)), (_z, 1, oo))
积分的评估：
>>> prob.evaluate_integral()
sqrt(2)*(-sqrt(2)*sqrt(pi)*erf(sqrt(2)/2) + sqrt(2)*sqrt(pi))/(4*sqrt(pi))
sympy.stats.E(expr, condition=None, numsamples=None, evaluate=True, **kwargs)
返回随机表达式的期望值。
参数：
expr : 包含随机符号的表达式
您希望计算期望值的表达式
given : 包含随机符号的表达式
一个条件表达式。E(X, X>0) 是给定 X > 0 的期望
numsamples : 整数
启用抽样并使用这么多样本近似期望
evalf : 布尔值（默认为真）
如果抽样返回一个数字而不是一个复杂的表达式
evaluate : 布尔值（默认为真）
对于连续系统返回未评估的积分
示例
>>> from sympy.stats import E, Die
>>> X = Die('X', 6)
>>> E(X)
7/2
>>> E(2*X + 1)
8
>>> E(X, X > 3) # Expectation of X given that it is above 3
5
class sympy.stats.Expectation(expr, condition=None, **kwargs)
期望的符号表达式。
示例
>>> from sympy.stats import Expectation, Normal, Probability, Poisson
>>> from sympy import symbols, Integral, Sum
>>> mu = symbols("mu")
>>> sigma = symbols("sigma", positive=True)
>>> X = Normal("X", mu, sigma)
>>> Expectation(X)
Expectation(X)
>>> Expectation(X).evaluate_integral().simplify()
mu
要获得期望的积分表达式：
>>> Expectation(X).rewrite(Integral)
Integral(sqrt(2)*X*exp(-(X - mu)**2/(2*sigma**2))/(2*sqrt(pi)*sigma), (X, -oo, oo))
更抽象术语中相同的积分表达式：
>>> Expectation(X).rewrite(Probability)
Integral(x*Probability(Eq(X, x)), (x, -oo, oo))
对于离散随机变量，要获得期望的求和表达式：
>>> lamda = symbols('lamda', positive=True)
>>> Z = Poisson('Z', lamda)
>>> Expectation(Z).rewrite(Sum)
Sum(Z*lamda**Z*exp(-lamda)/factorial(Z), (Z, 0, oo))
该类意识到期望的某些属性：
>>> from sympy.abc import a
>>> Expectation(a*X)
Expectation(a*X)
>>> Y = Normal("Y", 1, 2)
>>> Expectation(X + Y)
Expectation(X + Y)
要扩展Expectation为其表达式，请使用expand()：
>>> Expectation(X + Y).expand()
Expectation(X) + Expectation(Y)
>>> Expectation(a*X + Y).expand()
a*Expectation(X) + Expectation(Y)
>>> Expectation(a*X + Y)
Expectation(a*X + Y)
>>> Expectation((X + Y)*(X - Y)).expand()
Expectation(X**2) - Expectation(Y**2)
要评估Expectation，请使用doit()：
>>> Expectation(X + Y).doit()
mu + 1
>>> Expectation(X + Expectation(Y + Expectation(2*X))).doit()
3*mu + 1
要防止评估嵌套的Expectation，请使用doit(deep=False)
>>> Expectation(X + Expectation(Y)).doit(deep=False)
mu + Expectation(Expectation(Y))
>>> Expectation(X + Expectation(Y + Expectation(2*X))).doit(deep=False)
mu + Expectation(Expectation(Expectation(2*X) + Y))
sympy.stats.density(expr, condition=None, evaluate=True, numsamples=None, **kwargs)
随机表达式的概率密度，可选给定第二个条件。
参数：
expr：包含随机符号的表达式
您想要计算其密度值的表达式
condition：包含随机符号的关系
一个条件表达式。density(X > 1, X > 0) 是给定 X > 0 的情况下 X > 1 的密度
numsamples：整数
启用抽样并使用这么多样本来近似密度
说明
对于不同类型的概率空间，该密度将采取不同的形式。离散变量产生字典，连续变量产生 Lambda 函数。
示例
>>> 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)
计算概率分布的熵。
参数：
expression：要计算熵的随机表达式
condition：可选项，用于指定随机表达式的条件
b：对数的底数，可选
默认情况下，它被视为欧拉数
返回：
result：表达式的熵，一个常数
示例
>>> 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)
参考
[R1043]
en.wikipedia.org/wiki/Entropy_%28information_theory%29
[R1044]
www.crmarsh.com/static/pdf/Charles_Marsh_Continuous_Entropy.pdf
[R1045]
kconrad.math.uconn.edu/blurbs/analysis/entropypost.pdf
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)
返回条件为 True 的域。
示例
>>> 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)
协方差的符号表达式。
示例
>>> from sympy import symbols, Integral
>>> from sympy.stats import Normal, Expectation, Variance, Probability
>>> mu = symbols("mu", positive=True)
>>> sigma = symbols("sigma", positive=True)
>>> X = Normal("X", mu, sigma)
>>> Variance(X)
Variance(X)
>>> Variance(X).evaluate_integral()
sigma**2
底层计算的积分表示：
>>> Variance(X).rewrite(Integral)
Integral(sqrt(2)*(X - Integral(sqrt(2)*X*exp(-(X - mu)**2/(2*sigma**2))/(2*sqrt(pi)*sigma), (X, -oo, oo)))**2*exp(-(X - mu)**2/(2*sigma**2))/(2*sqrt(pi)*sigma), (X, -oo, oo))
积分表示，不扩展 PDF：
>>> Variance(X).rewrite(Probability)
-Integral(x*Probability(Eq(X, x)), (x, -oo, oo))**2 + Integral(x**2*Probability(Eq(X, x)), (x, -oo, oo))
重写期望的方差
>>> Variance(X).rewrite(Expectation)
-Expectation(X)**2 + Expectation(X**2)
可能基于方差属性的某些转换会发生：
>>> from sympy.abc import a
>>> Y = Normal("Y", 0, 1)
>>> Variance(a*X)
Variance(a*X)
要展开方差为其表达式，请使用expand()：
>>> Variance(a*X).expand()
a**2*Variance(X)
>>> Variance(X + Y)
Variance(X + Y)
>>> Variance(X + Y).expand()
2*Covariance(X, Y) + Variance(X) + Variance(Y)
sympy.stats.covariance(X, Y, condition=None, **kwargs)
两个随机表达式的协方差。
说明
预期这两个变量将共同上升和下降
[covariance(X,Y) = E((X-E(X)) (Y-E(Y)))]
示例
>>> from sympy.stats import Exponential, covariance
>>> from sympy import Symbol
>>> rate = Symbol('lambda', positive=True, real=True)
>>> X = Exponential('X', rate)
>>> Y = Exponential('Y', rate)
>>> covariance(X, X)
lambda**(-2)
>>> covariance(X, Y)
0
>>> covariance(X, Y + rate*X)
1/lambda
class sympy.stats.Covariance(arg1, arg2, condition=None, **kwargs)
协方差的符号表达式。
示例
>>> from sympy.stats import Covariance
>>> from sympy.stats import Normal
>>> X = Normal("X", 3, 2)
>>> Y = Normal("Y", 0, 1)
>>> Z = Normal("Z", 0, 1)
>>> W = Normal("W", 0, 1)
>>> cexpr = Covariance(X, Y)
>>> cexpr
Covariance(X, Y)
评估协方差，(X) 和 (Y) 是独立的，因此结果为零：
>>> cexpr.evaluate_integral()
0
重新用期望表达协方差表达式：
>>> from sympy.stats import Expectation
>>> cexpr.rewrite(Expectation)
Expectation(X*Y) - Expectation(X)*Expectation(Y)
为了扩展参数，请使用expand()：
>>> from sympy.abc import a, b, c, d
>>> Covariance(a*X + b*Y, c*Z + d*W)
Covariance(a*X + b*Y, c*Z + d*W)
>>> Covariance(a*X + b*Y, c*Z + d*W).expand()
a*c*Covariance(X, Z) + a*d*Covariance(W, X) + b*c*Covariance(Y, Z) + b*d*Covariance(W, Y)
此类别知晓协方差的一些属性：
>>> Covariance(X, X).expand()
Variance(X)
>>> Covariance(a*X, b*Y).expand()
a*b*Covariance(X, Y)
sympy.stats.coskewness(X, Y, Z, condition=None, **kwargs)
计算三个随机变量的共偏度。
参数：
X：RandomSymbol
用于计算共偏度的随机变量
Y：RandomSymbol
用于计算共偏度的随机变量
Z：RandomSymbol
用于计算共偏度的随机变量
condition：包含 RandomSymbols 的表达式
条件表达式
返回：
coskewness：三个随机变量的共偏度
解释
在数学上，共偏度定义为
[coskewness(X,Y,Z)=\frac{E[(X-E[X]) * (Y-E[Y]) * (Z-E[Z])]} {\sigma_{X}\sigma_{Y}\sigma_{Z}}]
示例
>>> from sympy.stats import coskewness, Exponential, skewness
>>> from sympy import symbols
>>> p = symbols('p', positive=True)
>>> X = Exponential('X', p)
>>> Y = Exponential('Y', 2*p)
>>> coskewness(X, Y, Y)
0
>>> coskewness(X, Y + X, Y + 2*X)
16*sqrt(85)/85
>>> coskewness(X + 2*Y, Y + X, Y + 2*X, X > 3)
9*sqrt(170)/85
>>> coskewness(Y, Y, Y) == skewness(Y)
True
>>> coskewness(X, Y + p*X, Y + 2*p*X)
4/(sqrt(1 + 1/(4*p**2))*sqrt(4 + 1/(4*p**2)))
参考
[R1046]
zh.wikipedia.org/wiki/Coskewness
sympy.stats.median(X, evaluate=True, **kwargs)
计算概率分布的中位数。
参数：
X：要计算中位数的随机表达式。
返回：
包含中位数的 FiniteSet 或 Interval
随机表达式。
解释
在数学上，概率分布的中位数定义为所有满足以下条件的值(m)：
[P(X\leq m) \geq \frac{1}{2} \text{ and} \text{ } P(X\geq m)\geq \frac{1}{2}]
示例
>>> from sympy.stats import Normal, Die, median
>>> N = Normal('N', 3, 1)
>>> median(N)
{3}
>>> D = Die('D')
>>> median(D)
{3, 4}
参考
[R1047]
zh.wikipedia.org/wiki/Median#Probability_distributions
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}) 阶分位数。
解释
分位数被定义为随机变量概率小于或等于给定概率的值。
[Q(p) = \inf{x \in (-\infty, \infty) : p \le F(x)}]
示例
>>> from sympy.stats import quantile, Die, Exponential
>>> from sympy import Symbol, pprint
>>> p = Symbol("p")
>>> l = Symbol("lambda", positive=True)
>>> X = Exponential("x", l)
>>> quantile(X)(p)
-log(1 - p)/lambda
>>> D = Die("d", 6)
>>> pprint(quantile(D)(p), use_unicode=False)
/nan for Or(p > 1, p < 0)
|
| 1 for p <= 1/6
|
| 2 for p <= 1/3
|
< 3 for p <= 1/2
|
| 4 for p <= 2/3
|
| 5 for p <= 5/6
|
\ 6 for p <= 1
sympy.stats.sample(expr, condition=None, size=(), library='scipy', numsamples=1, seed=None, **kwargs)
随机表达式的实现。
参数：
expr：随机变量的表达式
从中提取样本的表达式
condition：包含 RandomSymbols 的表达式
条件表达式
size：整数，元组
表示每个样本在
numsamples中的大小
library：字符串
- ‘scipy’：使用 scipy 进行示例
- ‘numpy’：使用 numpy 进行示例
- ‘pymc’：使用 PyMC 进行抽样
选择任一可用选项作为字符串进行抽样，默认为‘scipy’
numsamples：整数
样本数量，每个大小为
size。自版本 1.9 起已弃用。
numsamples参数已弃用，仅为与 v1.8 兼容性而提供。请改用列表推导或在size中添加额外维度。有关详细信息，请参阅 sympy.stats.sample(numsamples=n)。
seed：
作为给定外部库的种子使用的对象，用于采样(expr)。以下是支持库的可能对象类型列表，
- ‘scipy’：整数，numpy.random.RandomState，numpy.random.Generator
- ‘numpy’：整数，numpy.random.RandomState，numpy.random.Generator
- ‘pymc’：整数
可选，默认为 None，在这种情况下，将使用与给定库相关的种子设置。此参数不会对环境的全局种子设置进行修改。
返回：
sample: 浮点数/列表/numpy.ndarray
一个样本或随机表达式的一组样本。
- sample(X) 返回浮点数/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
要实现的随机表达式
condition: Expr, optional
一个条件表达式
size : 整数，元组
表示 numsamples 中每个样本的大小
numsamples: 整数，可选
迭代器的长度（默认为无穷大）
seed :
一个用于由给定外部库进行抽样(expr)的种子对象。以下是支持库的可能对象类型列表，
- ‘scipy’: 整数, numpy.random.RandomState, numpy.random.Generator
- ‘numpy’: 整数, numpy.random.RandomState, numpy.random.Generator
- ‘pymc’: int
可选，默认为 None，在这种情况下，将使用与给定库相关的种子设置。此参数不会对环境的全局种子设置进行修改。
返回：
sample_iter: 迭代器对象
包含给定表达式样本/样本的迭代器对象
示例
>>> 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]
另见
sample, sampling_P, sampling_E
sympy.stats.factorial_moment(X, n, condition=None, **kwargs)
阶乘矩是数学量，定义为随机变量的下降阶乘的期望或平均值。
[factorial-moment(X, n) = E(X(X - 1)(X - 2)...(X - n + 1))]
参数：
n: 自然数，n 阶阶乘矩。
condition : 包含随机符号的表达式
一个条件表达式。
示例
>>> 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
参考
[R1048]
en.wikipedia.org/wiki/Factorial_moment
[R1049]
mathworld.wolfram.com/FactorialMoment.html
sympy.stats.kurtosis(X, condition=None, **kwargs)
描述概率分布的尾部/异常值。
参数：
condition : 包含随机符号的表达式
一个条件表达式。kurtosis(X, X>0) 是给定 X > 0 的 kurtosis
解释
任何一元正态分布的峰度为 3。峰度小于 3 表示该分布产生的异常值较少且不那么极端。
[kurtosis(X) = E(((X - E(X))/\sigma_X)^{4})]
示例
>>> from sympy.stats import kurtosis, Exponential, Normal
>>> from sympy import Symbol
>>> X = Normal('X', 0, 1)
>>> kurtosis(X)
3
>>> kurtosis(X, X > 0) # find kurtosis given X > 0
(-4/pi - 12/pi**2 + 3)/(1 - 2/pi)**2
>>> rate = Symbol('lamda', positive=True, real=True)
>>> Y = Exponential('Y', rate)
>>> kurtosis(Y)
9
参考文献
[R1050]
en.wikipedia.org/wiki/Kurtosis
[R1051]
mathworld.wolfram.com/Kurtosis.html
sympy.stats.skewness(X, condition=None, **kwargs)
概率分布不对称度的度量。
参数：
condition：包含随机符号的表达式
一个条件表达式。skewness(X, X>0)是在给定 X > 0 时 X 的偏度。
解释
正偏表示大多数值位于均值右侧。
[偏度(X) = E(((X - E(X))/\sigma_X)^{3})]
示例
>>> from sympy.stats import skewness, Exponential, Normal
>>> from sympy import Symbol
>>> X = Normal('X', 0, 1)
>>> skewness(X)
0
>>> skewness(X, X > 0) # find skewness given X > 0
(-sqrt(2)/sqrt(pi) + 4*sqrt(2)/pi**(3/2))/(1 - 2/pi)**(3/2)
>>> rate = Symbol('lambda', positive=True, real=True)
>>> Y = Exponential('Y', rate)
>>> skewness(Y)
2
sympy.stats.correlation(X, Y, condition=None, **kwargs)
两个随机表达式的相关性，也称为相关系数或 Pearson 相关系数。
解释
两个变量共同上升和下降的归一化期望
[相关性(X,Y) = E((X-E(X))(Y-E(Y)) / (\sigma_x \sigma_y))]
示例
>>> from sympy.stats import Exponential, correlation
>>> from sympy import Symbol
>>> rate = Symbol('lambda', positive=True, real=True)
>>> X = Exponential('X', rate)
>>> Y = Exponential('Y', rate)
>>> correlation(X, X)
1
>>> correlation(X, Y)
0
>>> correlation(X, Y + rate*X)
1/sqrt(1 + lambda**(-2))
sympy.stats.rv.sampling_density(expr, given_condition=None, library='scipy', numsamples=1, seed=None, **kwargs)
密度的抽样版本。
另请参阅
density, sampling_P, sampling_E
sympy.stats.rv.sampling_P(condition, given_condition=None, library='scipy', numsamples=1, evalf=True, seed=None, **kwargs)
P 的抽样版本。
另请参阅
P, sampling_E, sampling_density
sympy.stats.rv.sampling_E(expr, given_condition=None, library='scipy', numsamples=1, evalf=True, seed=None, **kwargs)
E 的抽样版本。
另请参阅
P, sampling_P, sampling_density
class sympy.stats.Moment(X, n, c=0, condition=None, **kwargs)
用于 Moment 的符号类
示例
>>> 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
将Moment表达式重写为期望的形式：
>>> M.rewrite(Expectation)
Expectation((X - 1)**3)
将Moment表达式重写为概率的形式：
>>> 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)
返回关于随机表达式的第 n 阶矩，关于 c。
[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)
中心矩的符号类
示例
>>> 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
将CentralMoment表达式重写为期望的形式：
>>> CM.rewrite(Expectation)
Expectation((-Expectation(X) + X)**4)
将CentralMoment表达式重写为概率的形式：
>>> CM.rewrite(Probability)
Integral((x - Integral(x*Probability(True), (x, -oo, oo)))**4*Probability(Eq(X, x)), (x, -oo, oo))
将CentralMoment表达式重写为积分的形式：
>>> CM.rewrite(Integral)
Integral(sqrt(2)*(X - Integral(sqrt(2)*X*exp(-(X - mu)**2/(2*sigma**2))/(2*sqrt(pi)*sigma), (X, -oo, oo)))**4*exp(-(X - mu)**2/(2*sigma**2))/(2*sqrt(pi)*sigma), (X, -oo, oo))
sympy.stats.cmoment(X, n, condition=None, *, evaluate=True, **kwargs)
返回关于其均值的随机表达式的第 n 阶中心矩。
[cmoment(X, n) = E((X - E(X))^{n})]
示例
>>> from sympy.stats import Die, cmoment, variance
>>> X = Die('X', 6)
>>> cmoment(X, 3)
0
>>> cmoment(X, 2)
35/12
>>> cmoment(X, 2) == variance(X)
True
class sympy.stats.ExpectationMatrix(expr, condition=None)
随机矩阵表达式的期望。
示例
>>> from sympy.stats import ExpectationMatrix, Normal
>>> from sympy.stats.rv import RandomMatrixSymbol
>>> from sympy import symbols, MatrixSymbol, Matrix
>>> k = symbols("k")
>>> A, B = MatrixSymbol("A", k, k), MatrixSymbol("B", k, k)
>>> X, Y = RandomMatrixSymbol("X", k, 1), RandomMatrixSymbol("Y", k, 1)
>>> ExpectationMatrix(X)
ExpectationMatrix(X)
>>> ExpectationMatrix(A*X).shape
(k, 1)
要展开期望表达式，请使用expand()：
>>> ExpectationMatrix(A*X + B*Y).expand()
A*ExpectationMatrix(X) + B*ExpectationMatrix(Y)
>>> ExpectationMatrix((X + Y)*(X - Y).T).expand()
ExpectationMatrix(X*X.T) - ExpectationMatrix(X*Y.T) + ExpectationMatrix(Y*X.T) - ExpectationMatrix(Y*Y.T)
要评估ExpectationMatrix，请使用doit()：
>>> N11, N12 = Normal('N11', 11, 1), Normal('N12', 12, 1)
>>> N21, N22 = Normal('N21', 21, 1), Normal('N22', 22, 1)
>>> M11, M12 = Normal('M11', 1, 1), Normal('M12', 2, 1)
>>> M21, M22 = Normal('M21', 3, 1), Normal('M22', 4, 1)
>>> x1 = Matrix([[N11, N12], [N21, N22]])
>>> x2 = Matrix([[M11, M12], [M21, M22]])
>>> ExpectationMatrix(x1 + x2).doit()
Matrix([
[12, 14],
[24, 26]])
class sympy.stats.VarianceMatrix(arg, condition=None)
随机矩阵概率表达式的方差。也称为协方差矩阵、自协方差矩阵、离散矩阵或方差-协方差矩阵。
示例
>>> from sympy.stats import VarianceMatrix
>>> from sympy.stats.rv import RandomMatrixSymbol
>>> from sympy import symbols, MatrixSymbol
>>> k = symbols("k")
>>> A, B = MatrixSymbol("A", k, k), MatrixSymbol("B", k, k)
>>> X, Y = RandomMatrixSymbol("X", k, 1), RandomMatrixSymbol("Y", k, 1)
>>> VarianceMatrix(X)
VarianceMatrix(X)
>>> VarianceMatrix(X).shape
(k, k)
要展开方差表达式，请使用expand()：
>>> VarianceMatrix(A*X).expand()
A*VarianceMatrix(X)*A.T
>>> VarianceMatrix(A*X + B*Y).expand()
2*A*CrossCovarianceMatrix(X, Y)*B.T + A*VarianceMatrix(X)*A.T + B*VarianceMatrix(Y)*B.T
class sympy.stats.CrossCovarianceMatrix(arg1, arg2, condition=None)
随机矩阵概率表达式的协方差。
示例
>>> from sympy.stats import CrossCovarianceMatrix
>>> from sympy.stats.rv import RandomMatrixSymbol
>>> from sympy import symbols, MatrixSymbol
>>> k = symbols("k")
>>> A, B = MatrixSymbol("A", k, k), MatrixSymbol("B", k, k)
>>> C, D = MatrixSymbol("C", k, k), MatrixSymbol("D", k, k)
>>> X, Y = RandomMatrixSymbol("X", k, 1), RandomMatrixSymbol("Y", k, 1)
>>> Z, W = RandomMatrixSymbol("Z", k, 1), RandomMatrixSymbol("W", k, 1)
>>> CrossCovarianceMatrix(X, Y)
CrossCovarianceMatrix(X, Y)
>>> CrossCovarianceMatrix(X, Y).shape
(k, k)
要展开协方差表达式，请使用expand()：
>>> CrossCovarianceMatrix(X + Y, Z).expand()
CrossCovarianceMatrix(X, Z) + CrossCovarianceMatrix(Y, Z)
>>> CrossCovarianceMatrix(A*X, Y).expand()
A*CrossCovarianceMatrix(X, Y)
>>> CrossCovarianceMatrix(A*X, B.T*Y).expand()
A*CrossCovarianceMatrix(X, Y)*B
>>> CrossCovarianceMatrix(A*X + B*Y, C.T*Z + D.T*W).expand()
A*CrossCovarianceMatrix(X, W)*D + A*CrossCovarianceMatrix(X, Z)*C + B*CrossCovarianceMatrix(Y, W)*D + B*CrossCovarianceMatrix(Y, Z)*C
机制
SymPy Stats 使用相对复杂的类层次结构。
RandomDomain是变量到可能值的映射。例如，我们可以说符号Symbol('x')可以取值({1,2,3,4,5,6})。
class sympy.stats.rv.RandomDomain
PSpace 或概率空间将 RandomDomain 与密度结合起来，提供概率信息。例如，上述域可以通过有限密度 {1:1/6, 2:1/6, 3:1/6, 4:1/6, 5:1/6, 6:1/6} 来完整定义名为 x 的公平骰子的投掷结果。
class sympy.stats.rv.PSpace
RandomSymbol 在 SymPy 表达式中表示 PSpace 的符号 x。
class sympy.stats.rv.RandomSymbol
RandomDomain 和 PSpace 类几乎从不直接实例化。而是为各种情况进行子类化。
RandomDomains 和 PSpaces 必须足够通用，以表示具有任意复杂密度的多个变量的域和空间。这种普遍性通常是不必要的。相反，我们经常构建 SingleDomains 和 SinglePSpaces 来表示单一的单变量事件和过程，例如单个骰子或单个正态变量。
class sympy.stats.rv.SinglePSpace
class sympy.stats.rv.SingleDomain
另一个常见情况是将一组这样的单变量随机变量聚集在一起。可以将独立的 SinglePSpaces 或 SingleDomains 集合在一起，形成 ProductDomain 或 ProductPSpace。例如，这些对象在表示三个同时掷的骰子时非常有用。
class sympy.stats.rv.ProductDomain
class sympy.stats.rv.ProductPSpace
当我们向随机域或概率空间添加全局条件时，需要添加条件形容词。一个常见的例子是三个独立的骰子，我们知道它们的总和大于 12。
class sympy.stats.rv.ConditionalDomain
我们进一步专门化这些类的有限版本和连续版本，以表示有限（例如骰子）和连续（例如正态分布）的随机变量。
class sympy.stats.frv.FiniteDomain
class sympy.stats.frv.FinitePSpace
class sympy.stats.crv.ContinuousDomain
class sympy.stats.crv.ContinuousPSpace
另外还有一些专门的类，实现了某些常见的随机变量类型。例如，DiePSpace 实现了 SingleFinitePSpace，而 NormalPSpace 实现了 SingleContinuousPSpace。
class sympy.stats.frv_types.DiePSpace
class sympy.stats.crv_types.NormalPSpace
可以使用 PSpace.values 方法从这些对象中提取随机变量。
正如之前提到的，SymPy 统计模块采用了相对复杂的类结构。继承广泛用于实现末级类。这种策略被选择来在允许 SymPy 表示任意定义的随机变量和优化常见情况之间取得平衡。这增加了代码复杂性，但结构化得仅对于那些在将 SymPy 统计扩展到其他随机变量类型上工作的人员是重要的。
用户不会直接使用这种类结构。相反，这些机制通过变量创建函数 Die、Coin、FiniteRV、Normal、Exponential 等暴露出来。这些函数构建适当的 SinglePSpaces 并返回相应的 RandomVariable。条件空间和乘积空间在 SymPy 表达式的自然构造中形成，并使用接口函数 E、Given、Density 等。
sympy.stats.Die()
sympy.stats.Normal()
还有一些可能有用的额外函数。它们主要用于内部使用。
sympy.stats.rv.random_symbols(expr)
返回 SymPy 表达式中的所有 RandomSymbol。
sympy.stats.rv.pspace(expr)
返回随机表达式的基础概率空间。
供内部使用。
示例
>>> from sympy.stats import pspace, Normal
>>> X = Normal('X', 0, 1)
>>> pspace(2*X + 1) == X.pspace
True
sympy.stats.rv.rs_swap(a, b)
构建一个字典，根据它们的基础符号来交换 RandomSymbol。
输出：将集合 a 中的随机变量映射到集合 b 中的随机变量的字典
输入：随机变量集合 a 和 b，它们共享相同的符号
浙公网安备 33010602011771号