SymPy 1.13 中文文档（四十八）

原文：docs.sympy.org/latest/index.html

平面

原文链接：docs.sympy.org/latest/modules/geometry/plane.html

class sympy.geometry.plane.Plane(p1, a=None, b=None, **kwargs)

平面是一个平坦的二维表面。平面是点（零维）、线（一维）和立体（三维）的二维模拟。平面通常可以通过两种类型的输入构造。它们是：- 三个非共线点 - 一个点和平面的法向量

示例

>>> from sympy import Plane, Point3D
>>> Plane(Point3D(1, 1, 1), Point3D(2, 3, 4), Point3D(2, 2, 2))
Plane(Point3D(1, 1, 1), (-1, 2, -1))
>>> Plane((1, 1, 1), (2, 3, 4), (2, 2, 2))
Plane(Point3D(1, 1, 1), (-1, 2, -1))
>>> Plane(Point3D(1, 1, 1), normal_vector=(1,4,7))
Plane(Point3D(1, 1, 1), (1, 4, 7))

属性

p1
normal_vector

angle_between(o)

平面与其他几何实体之间的夹角。

参数：

LinearEntity3D, Plane.

角度：弧度角

注意事项

该方法只接受 3D 实体作为其参数，但如果要计算二维实体与平面之间的角度，应首先将其投影到所需的平面上转换为 3D 实体，然后再计算角度。

示例

>>> from sympy import Point3D, Line3D, Plane
>>> a = Plane(Point3D(1, 2, 2), normal_vector=(1, 2, 3))
>>> b = Line3D(Point3D(1, 3, 4), Point3D(2, 2, 2))
>>> a.angle_between(b)
-asin(sqrt(21)/6)

arbitrary_point(u=None, v=None)

返回平面上的任意点。如果给定两个参数，则该点在整个平面上变化。如果给定 1 个或没有参数，则返回一个点，其中一个参数在从 0 到 2*pi 变化时在平面的 p1 处以半径 1 的圆上移动。

Point3D

示例

>>> from sympy import Plane, Ray
>>> from sympy.abc import u, v, t, r
>>> p = Plane((1, 1, 1), normal_vector=(1, 0, 0))
>>> p.arbitrary_point(u, v)
Point3D(1, u + 1, v + 1)
>>> p.arbitrary_point(t)
Point3D(1, cos(t) + 1, sin(t) + 1)

尽管参数 u 和 v 的任意值可以将点移动到平面上的任何位置，但单参数点可以用来构造射线，其任意点可以位于以角度 t 和半径 r 从 p.p1 开始的圆上：

>>> Ray(p.p1, _).arbitrary_point(r)
Point3D(1, r*cos(t) + 1, r*sin(t) + 1)

static are_concurrent(*planes)

一系列平面是否共线？

如果它们的交点是一条公共线，则两个或更多个平面是共线的。

参数：

planes: list

布尔值

示例

>>> from sympy import Plane, Point3D
>>> a = Plane(Point3D(5, 0, 0), normal_vector=(1, -1, 1))
>>> b = Plane(Point3D(0, -2, 0), normal_vector=(3, 1, 1))
>>> c = Plane(Point3D(0, -1, 0), normal_vector=(5, -1, 9))
>>> Plane.are_concurrent(a, b)
True
>>> Plane.are_concurrent(a, b, c)
False

distance(o)

平面与另一个几何实体之间的距离。

参数：

Point3D, LinearEntity3D, Plane.

距离

注意事项

该方法只接受 3D 实体作为其参数，但如果要计算二维实体与平面之间的距离，应首先将其投影到所需的平面上转换为 3D 实体，然后再计算距离。

示例

>>> from sympy import Point3D, Line3D, Plane
>>> a = Plane(Point3D(1, 1, 1), normal_vector=(1, 1, 1))
>>> b = Point3D(1, 2, 3)
>>> a.distance(b)
sqrt(3)
>>> c = Line3D(Point3D(2, 3, 1), Point3D(1, 2, 2))
>>> a.distance(c)
0

equals(o)

如果 self 和 o 是相同的数学实体，则返回 True。

示例

>>> from sympy import Plane, Point3D
>>> a = Plane(Point3D(1, 2, 3), normal_vector=(1, 1, 1))
>>> b = Plane(Point3D(1, 2, 3), normal_vector=(2, 2, 2))
>>> c = Plane(Point3D(1, 2, 3), normal_vector=(-1, 4, 6))
>>> a.equals(a)
True
>>> a.equals(b)
True
>>> a.equals(c)
False

equation(x=None, y=None, z=None)

平面的方程式。

示例

>>> from sympy import Point3D, Plane
>>> a = Plane(Point3D(1, 1, 2), Point3D(2, 4, 7), Point3D(3, 5, 1))
>>> a.equation()
-23*x + 11*y - 2*z + 16
>>> a = Plane(Point3D(1, 4, 2), normal_vector=(6, 6, 6))
>>> a.equation()
6*x + 6*y + 6*z - 42

intersection(o)

与其他几何实体的交点。

参数：

Point, Point3D, LinearEntity, LinearEntity3D, Plane

列表

示例

>>> from sympy import Point3D, Line3D, Plane
>>> a = Plane(Point3D(1, 2, 3), normal_vector=(1, 1, 1))
>>> b = Point3D(1, 2, 3)
>>> a.intersection(b)
[Point3D(1, 2, 3)]
>>> c = Line3D(Point3D(1, 4, 7), Point3D(2, 2, 2))
>>> a.intersection(c)
[Point3D(2, 2, 2)]
>>> d = Plane(Point3D(6, 0, 0), normal_vector=(2, -5, 3))
>>> e = Plane(Point3D(2, 0, 0), normal_vector=(3, 4, -3))
>>> d.intersection(e)
[Line3D(Point3D(78/23, -24/23, 0), Point3D(147/23, 321/23, 23))]

is_coplanar(o)

如果 (o) 与自身共面，则返回 True，否则返回 False。

示例

>>> from sympy import Plane
>>> o = (0, 0, 0)
>>> p = Plane(o, (1, 1, 1))
>>> p2 = Plane(o, (2, 2, 2))
>>> p == p2
False
>>> p.is_coplanar(p2)
True

is_parallel(l)

给定的几何实体是否与该平面平行？

参数：

LinearEntity3D 或 Plane

布尔值

示例

>>> from sympy import Plane, Point3D
>>> a = Plane(Point3D(1,4,6), normal_vector=(2, 4, 6))
>>> b = Plane(Point3D(3,1,3), normal_vector=(4, 8, 12))
>>> a.is_parallel(b)
True

is_perpendicular(l)

给定的几何实体是否与给定的平面垂直？

参数：

LinearEntity3D 或 Plane

布尔值

示例

>>> from sympy import Plane, Point3D
>>> a = Plane(Point3D(1,4,6), normal_vector=(2, 4, 6))
>>> b = Plane(Point3D(2, 2, 2), normal_vector=(-1, 2, -1))
>>> a.is_perpendicular(b)
True

property normal_vector

给定平面的法向量。

示例

>>> from sympy import Point3D, Plane
>>> a = Plane(Point3D(1, 1, 1), Point3D(2, 3, 4), Point3D(2, 2, 2))
>>> a.normal_vector
(-1, 2, -1)
>>> a = Plane(Point3D(1, 1, 1), normal_vector=(1, 4, 7))
>>> a.normal_vector
(1, 4, 7)

property p1

平面的唯一定义点。其他点可以从 arbitrary_point 方法获取。

示例

>>> from sympy import Point3D, Plane
>>> a = Plane(Point3D(1, 1, 1), Point3D(2, 3, 4), Point3D(2, 2, 2))
>>> a.p1
Point3D(1, 1, 1)

另请参阅

sympy.geometry.point.Point3D

parallel_plane(pt)

平行于给定平面并通过点 pt 的平面。

参数：

pt: Point3D

平面

示例

>>> from sympy import Plane, Point3D
>>> a = Plane(Point3D(1, 4, 6), normal_vector=(2, 4, 6))
>>> a.parallel_plane(Point3D(2, 3, 5))
Plane(Point3D(2, 3, 5), (2, 4, 6))

parameter_value(other, u, v=None)

返回与给定点对应的参数（s）。

示例

>>> from sympy import pi, Plane
>>> from sympy.abc import t, u, v
>>> p = Plane((2, 0, 0), (0, 0, 1), (0, 1, 0))

默认情况下，返回的参数值定义了一个距离平面 p1 值 1 的点，并且与给定点在一条直线上：

>>> on_circle = p.arbitrary_point(t).subs(t, pi/4)
>>> on_circle.distance(p.p1)
1
>>> p.parameter_value(on_circle, t)
{t: pi/4}

将点从 p1 移动两倍，不会改变参数值：

>>> off_circle = p.p1 + (on_circle - p.p1)*2
>>> off_circle.distance(p.p1)
2
>>> p.parameter_value(off_circle, t)
{t: pi/4}

如果需要 2 个值的参数，请提供两个参数符号，并返回替换字典：

>>> p.parameter_value(on_circle, u, v)
{u: sqrt(10)/10, v: sqrt(10)/30}
>>> p.parameter_value(off_circle, u, v)
{u: sqrt(10)/5, v: sqrt(10)/15}

perpendicular_line(pt)

垂直于给定平面的直线。

参数：

pt：Point3D

Line3D

示例

>>> from sympy import Plane, Point3D
>>> a = Plane(Point3D(1,4,6), normal_vector=(2, 4, 6))
>>> a.perpendicular_line(Point3D(9, 8, 7))
Line3D(Point3D(9, 8, 7), Point3D(11, 12, 13))

perpendicular_plane(*pts)

返回通过给定点的垂直线。如果点之间的方向比平面的法线向量相同，则为了从无数可能的平面中选择，将在 z 轴上选择第三个点（如果法线不已经平行于 z 轴，则在平行于 y 轴的线上）。如果给出少于两个点，则将如下提供：如果没有给出点，则 pt1 将是 self.p1；如果没有给出第二个点，则它将是一条通过 pt1 的线，平行于 z 轴（如果法线不已经是 z 轴，则平行于 y 轴的线）。

参数：

pts：0、1 或 2 个 Point3D

平面

示例

>>> from sympy import Plane, Point3D
>>> a, b = Point3D(0, 0, 0), Point3D(0, 1, 0)
>>> Z = (0, 0, 1)
>>> p = Plane(a, normal_vector=Z)
>>> p.perpendicular_plane(a, b)
Plane(Point3D(0, 0, 0), (1, 0, 0))

projection(pt)

将给定点沿平面法线投影到平面上。

参数：

点或 Point3D

Point3D

示例

>>> from sympy import Plane, Point3D
>>> A = Plane(Point3D(1, 1, 2), normal_vector=(1, 1, 1))

投影沿法线向量方向进行，而不是沿 z 轴，因此(1, 1)在平面 A 上不投影到(1, 1, 2)：

>>> b = Point3D(1, 1)
>>> A.projection(b)
Point3D(5/3, 5/3, 2/3)
>>> _ in A
True

但是点(1, 1, 2)在 XY 平面上投影到(1, 1)：

>>> XY = Plane((0, 0, 0), (0, 0, 1))
>>> XY.projection((1, 1, 2))
Point3D(1, 1, 0)

projection_line(line)

将给定的直线投影到包含该直线的法线平面上。

参数：

LinearEntity 或 LinearEntity3D

Point3D、Line3D、Ray3D 或 Segment3D

注意事项

对于 2D 和 3D 线段（射线、线段）之间的交互，应通过使用此方法将线段转换为 3D。例如，要找到 2D 和 3D 线之间的交点，请通过将 2D 线段投影到所需平面上将其转换为 3D 线段，然后继续查找这些线之间的交点。

示例

>>> from sympy import Plane, Line, Line3D, Point3D
>>> a = Plane(Point3D(1, 1, 1), normal_vector=(1, 1, 1))
>>> b = Line(Point3D(1, 1), Point3D(2, 2))
>>> a.projection_line(b)
Line3D(Point3D(4/3, 4/3, 1/3), Point3D(5/3, 5/3, -1/3))
>>> c = Line3D(Point3D(1, 1, 1), Point3D(2, 2, 2))
>>> a.projection_line(c)
Point3D(1, 1, 1)

random_point(seed=None)

返回平面上的随机点。

Point3D

示例

>>> from sympy import Plane
>>> p = Plane((1, 0, 0), normal_vector=(0, 1, 0))
>>> r = p.random_point(seed=42)  # seed value is optional
>>> r.n(3)
Point3D(2.29, 0, -1.35)

可以将随机点移动到以 p1 为中心、半径为 1 的圆上：

>>> c = p.p1 + (r - p.p1).unit
>>> c.distance(p.p1).equals(1)
True

全息函数

原文：docs.sympy.org/latest/modules/holonomic/index.html

holonomic 模块旨在处理全息函数及其诸如加法、乘法、组合、积分和微分等各种操作。该模块还实现了各种类型的转换，例如将全息函数转换为不同形式及其逆操作。

内容

关于全息函数
SymPy 中的全息函数表示
全息函数的操作
将其他表示形式转换为全息函数
用途和当前限制
内部 API

关于全纯函数

原文链接：docs.sympy.org/latest/modules/holonomic/about.html

本文旨在解释全纯函数。我们假设您对微分方程和抽象代数有基本的了解。

定义

全纯函数是特殊函数的一种非常普遍的类型，包括许多简单的已知函数作为其特殊情况。事实上，更为知名的超几何函数和 Meijer G 函数也是它的特殊情况之一。

如果一个函数是多项式系数的常微分方程的解，则称其为全纯函数。由于常微分方程的一般解由一组函数而不是单个函数组成，全纯函数通常由初始条件和微分方程定义。

设 (K) 是一个特征为 0 的域。例如，(K) 可以是 QQ 或 RR。如果存在多项式 (p_0, p_1, p_2, ... p_r \in K[x])，使得

[p_0 \cdot f(x) + p_1 \cdot f^{(1)}(x) + p_2 \cdot f^{(2)}(x) + ... + p_r \cdot f^{(r)}(x) = 0]

这个微分方程也可以写成 (L \cdot f(x) = 0) 其中

[L = p_0 + p_1 \cdot D + p_2 \cdot D² + ... p_r \cdot D^r]

这里 (D) 是微分算子，(L) 被称为函数的湮灭算子。

从湮灭算子和一组初始条件可以定义出一个唯一的全纯函数。例如：

[ \begin{align}\begin{aligned}f(x) = \exp(x): L = D - 1,: f(0) = 1\f(x) = \sin(x): L = D² + 1,: f(0) = 0, f'(0) = 1\end{aligned}\end{align} ]

其他基础函数如 (\cos(x)), (\log(x)), 贝塞尔函数等也是全纯函数。

全纯函数的族在加法、乘法、积分、组合下封闭。这意味着如果两个函数是全纯函数，那么对它们进行这些运算得到的函数也将是全纯函数。

参考文献

zh.wikipedia.org/wiki/全纯函数

SymPy 中全纯函数的表示

原文链接：docs.sympy.org/latest/modules/holonomic/represent.html

类DifferentialOperator 用于表示湮灭子，但我们可以使用函数DifferentialOperators() 轻松创建微分算子。类HolonomicFunction 表示一个全纯函数。

让我们通过一个例子来解释这一点：

以 (\sin(x)) 为例，它满足的微分方程是 (y^{(2)}(x) + y(x) = 0)。根据定义，我们得出它是一个全纯函数。该常微分方程的一般解为 (C_{1} \cdot \sin(x) + C_{2} \cdot \cos(x))，但要得到 (\sin(x))，我们需要提供初始条件，即 (y(0) = 0, y^{(1)}(0) = 1)。

要在该模块中表示相同的内容，需要将微分方程以湮灭子的形式提供。基本上，微分算子是作用于函数的操作符，对其进行微分。因此，(D^{n} \cdot y(x) = y^{(n)}(x))，其中 (y^{(n)}(x)) 表示 (y(x)) 关于 (x) 的第 (n) 次导数。

因此，微分方程也可以写作 (D^{2} \cdot y(x) + y(x) = 0) 或者 ((D^{2} + 1) \cdot y(x) = 0)。方程左侧的部分是湮灭子，即 (D^{2}+1)。

这就是如何将 (\sin(x)) 表示为全纯函数的方式：

>>> from sympy.holonomic import DifferentialOperators, HolonomicFunction
>>> from sympy.abc import x
>>> from sympy import ZZ
>>> R, D = DifferentialOperators(ZZ.old_poly_ring(x), 'D')
>>> HolonomicFunction(D**2 + 1, x, 0, [0, 1])
HolonomicFunction((1) + (1)*D**2, x, 0, [0, 1])

在示例中，多项式系数将成为环 ZZ[x] 的成员。通过函数DifferentialOperators() 返回的 D 算子可以像 SymPy 表达式一样用于创建湮灭子。我们目前使用 SymPy 中较旧的环实现优先机制。

class sympy.holonomic.holonomic.HolonomicFunction(annihilator, x, x0=0, y0=None)

全纯函数是线性齐次常微分方程 (L.f = 0) 的解，其系数为多项式。此微分方程也可以用湮灭子表示，即微分算子 L。为了确保这些函数的唯一性，可以提供初始条件和湮灭子。

解释

全纯函数具有封闭性质，因此形成一个环。给定两个全纯函数 (f) 和 (g)，它们的和、积、积分和导数也是全纯函数。

对于普通点，初始条件应为导数值的向量，即 ([y(x_0), y'(x_0), y''(x_0) ... ])。

对于常规奇异点，还可以按照此格式提供初值条件：({s0: [C_0, C_1, ...], s1: [C¹_0, C¹_1, ...], ...})，其中 s0, s1, …是指标方程的根，向量([C_0, C_1, ...], [C⁰_0, C⁰_1, ...], ...)是相关幂级数的初始项。请参见下面的示例。

示例

>>> from sympy.holonomic.holonomic import HolonomicFunction, DifferentialOperators
>>> from sympy import QQ
>>> from sympy import symbols, S
>>> x = symbols('x')
>>> R, Dx = DifferentialOperators(QQ.old_poly_ring(x),'Dx')

>>> p = HolonomicFunction(Dx - 1, x, 0, [1])  # e^x
>>> q = HolonomicFunction(Dx**2 + 1, x, 0, [0, 1])  # sin(x)

>>> p + q  # annihilator of e^x + sin(x)
HolonomicFunction((-1) + (1)*Dx + (-1)*Dx**2 + (1)*Dx**3, x, 0, [1, 2, 1])

>>> p * q  # annihilator of e^x * sin(x)
HolonomicFunction((2) + (-2)*Dx + (1)*Dx**2, x, 0, [0, 1])

对于常规奇异点的初值条件示例，指标方程只有一个根(1/2)。

>>> HolonomicFunction(-S(1)/2 + x*Dx, x, 0, {S(1)/2: [1]})
HolonomicFunction((-1/2) + (x)*Dx, x, 0, {1/2: [1]})

>>> HolonomicFunction(-S(1)/2 + x*Dx, x, 0, {S(1)/2: [1]}).to_expr()
sqrt(x)

要绘制 Holonomic 函数，可以使用.evalf()进行数值计算。以下是使用 numpy 和 matplotlib 绘制(sin(x)**2/x)的示例。

>>> import sympy.holonomic 
>>> from sympy import var, sin 
>>> import matplotlib.pyplot as plt 
>>> import numpy as np 
>>> var("x") 
>>> r = np.linspace(1, 5, 100) 
>>> y = sympy.holonomic.expr_to_holonomic(sin(x)**2/x, x0=1).evalf(r) 
>>> plt.plot(r, y, label="holonomic function") 
>>> plt.show()

class sympy.holonomic.holonomic.DifferentialOperator(list_of_poly, parent)

微分算子是 Weyl 代数的元素。这些运算符由基础环中的多项式列表和运算符所属的父环定义，即它所属的代数。

解释

接受每个Dx幂级别的多项式列表和必须是 DifferentialOperatorAlgebra 实例的父环的列表。

使用运算符Dx可以轻松创建微分算子。请参见下面的示例。

示例

>>> from sympy.holonomic.holonomic import DifferentialOperator, DifferentialOperators
>>> from sympy import ZZ
>>> from sympy import symbols
>>> x = symbols('x')
>>> R, Dx = DifferentialOperators(ZZ.old_poly_ring(x),'Dx')

>>> DifferentialOperator([0, 1, x**2], R)
(1)*Dx + (x**2)*Dx**2

>>> (x*Dx*x + 1 - Dx**2)**2
(2*x**2 + 2*x + 1) + (4*x**3 + 2*x**2 - 4)*Dx + (x**4 - 6*x - 2)*Dx**2 + (-2*x**2)*Dx**3 + (1)*Dx**4

另请参阅

DifferentialOperatorAlgebra

is_singular(x0)

检查微分方程在 x0 处是否奇异。

sympy.holonomic.holonomic.DifferentialOperators(base, generator)

此函数用于使用Dx创建湮灭算子。

参数：

基础：

代数的基础多项式环。基础多项式环是在运算符中出现的 x 的多项式环，这些运算符将作为运算符的系数。

生成器：

代数的生成器可以是非交换的Symbol或字符串。例如，“Dx”或“D”。

解释

返回微分算子的代数，也称为 Weyl 代数，以及区分运算的操作符，即Dx运算符。

示例

>>> from sympy import ZZ
>>> from sympy.abc import x
>>> from sympy.holonomic.holonomic import DifferentialOperators
>>> R, Dx = DifferentialOperators(ZZ.old_poly_ring(x), 'Dx')
>>> R
Univariate Differential Operator Algebra in intermediate Dx over the base ring ZZ[x]
>>> Dx*x
(1) + (x)*Dx

class sympy.holonomic.holonomic.DifferentialOperatorAlgebra(base, generator)

Ore 代数是中间Dx中的非交换多项式集合和基础多项式环(A)中的系数。它遵循交换规则：

[Dxa = \sigma(a)Dx + \delta(a)]

对于(a \subset A)。

其中(\sigma: A \Rightarrow A)是一个自同态，而(\delta: A \rightarrow A)是一个斜导数，即(\delta(ab) = \delta(a) b + \sigma(a) \delta(b))。

如果将 sigma 视为恒等映射，将 delta 视为标准导数，那么它变成了微分算子的代数，也称为 Weyl 代数，即其元素为微分算子的代数。

该类代表一个 Weyl 代数，并作为微分算子的父环。

示例

>>> from sympy import ZZ
>>> from sympy import symbols
>>> from sympy.holonomic.holonomic import DifferentialOperators
>>> x = symbols('x')
>>> R, Dx = DifferentialOperators(ZZ.old_poly_ring(x), 'Dx')
>>> R
Univariate Differential Operator Algebra in intermediate Dx over the base ring
ZZ[x]

另请参阅

DifferentialOperator

全息函数的运算

原文链接：docs.sympy.org/latest/modules/holonomic/operations.html

加法和乘法

两个全息函数可以相加或相乘，结果也是全息函数。

>>> from sympy.holonomic.holonomic import HolonomicFunction, DifferentialOperators

>>> from sympy.polys.domains import QQ

>>> from sympy import symbols

>>> x = symbols('x')

>>> R, Dx = DifferentialOperators(QQ.old_poly_ring(x),'Dx')

这里的 p 和 q 是 (e^x) 和 (\sin(x)) 的全息表示。

>>> p = HolonomicFunction(Dx - 1, x, 0, [1])

>>> q = HolonomicFunction(Dx**2 + 1, x, 0, [0, 1])

(e^x+\sin(x)) 的完全表示

>>> p + q

HolonomicFunction((-1) + (1)*Dx + (-1)*Dx**2 + (1)*Dx**3, x, 0, [1, 2, 1])

(e^x \cdot \sin(x)) 的完全表示

>>> p * q

HolonomicFunction((2) + (-2)*Dx + (1)*Dx**2, x, 0, [0, 1])

积分和微分

HolonomicFunction.integrate(limits, initcond=False)

对给定的全息函数进行积分。

示例

>>> from sympy.holonomic.holonomic import HolonomicFunction, DifferentialOperators
>>> from sympy import QQ
>>> from sympy import symbols
>>> x = symbols('x')
>>> R, Dx = DifferentialOperators(QQ.old_poly_ring(x),'Dx')
>>> HolonomicFunction(Dx - 1, x, 0, [1]).integrate((x, 0, x))  # e^x - 1
HolonomicFunction((-1)*Dx + (1)*Dx**2, x, 0, [0, 1])
>>> HolonomicFunction(Dx**2 + 1, x, 0, [1, 0]).integrate((x, 0, x))
HolonomicFunction((1)*Dx + (1)*Dx**3, x, 0, [0, 1, 0])

HolonomicFunction.diff(*args, **kwargs)

对给定的全息函数进行微分。

示例

>>> from sympy.holonomic.holonomic import HolonomicFunction, DifferentialOperators
>>> from sympy import ZZ
>>> from sympy import symbols
>>> x = symbols('x')
>>> R, Dx = DifferentialOperators(ZZ.old_poly_ring(x),'Dx')
>>> HolonomicFunction(Dx**2 + 1, x, 0, [0, 1]).diff().to_expr()
cos(x)
>>> HolonomicFunction(Dx - 2, x, 0, [1]).diff().to_expr()
2*exp(2*x)

另见

integrate

与多项式的组合

HolonomicFunction.composition(expr, *args, **kwargs)

返回全息函数与代数函数的组合后的函数。该方法不能单独计算结果的初始条件，因此也可以提供它们。

示例

>>> from sympy.holonomic.holonomic import HolonomicFunction, DifferentialOperators
>>> from sympy import QQ
>>> from sympy import symbols
>>> x = symbols('x')
>>> R, Dx = DifferentialOperators(QQ.old_poly_ring(x),'Dx')
>>> HolonomicFunction(Dx - 1, x).composition(x**2, 0, [1])  # e^(x**2)
HolonomicFunction((-2*x) + (1)*Dx, x, 0, [1])
>>> HolonomicFunction(Dx**2 + 1, x).composition(x**2 - 1, 1, [1, 0])
HolonomicFunction((4*x**3) + (-1)*Dx + (x)*Dx**2, x, 1, [1, 0])

另见

from_hyper

转换为完全序列

HolonomicFunction.to_sequence(lb=True)

在关于 (x_0) 的函数的级数展开中找到系数的递归关系，其中 (x_0) 是存储初始条件的点。

解释

如果点 (x_0) 是普通的，将返回形式为 ([(R, n_0)]) 的解。其中 (R) 是递归关系，(n_0) 是满足递归的最小 n。

如果点 (x_0) 是正则奇异的，将返回格式为 ((R, p, n_0)) 的解列表。即 ([(R, p, n_0), ... ])。在这种情况下，还可以提供不同格式的条件，请参阅 HolonomicFunction 类的文档字符串。

如果无法数值计算初始条件，则将其作为符号 (C_j) 返回，表示关于 (x_0) 的幂级数中 ((x - x_0)^j) 的系数。

示例

>>> from sympy.holonomic.holonomic import HolonomicFunction, DifferentialOperators
>>> from sympy import QQ
>>> from sympy import symbols, S
>>> x = symbols('x')
>>> R, Dx = DifferentialOperators(QQ.old_poly_ring(x),'Dx')
>>> HolonomicFunction(Dx - 1, x, 0, [1]).to_sequence()
[(HolonomicSequence((-1) + (n + 1)Sn, n), u(0) = 1, 0)]
>>> HolonomicFunction((1 + x)*Dx**2 + Dx, x, 0, [0, 1]).to_sequence()
[(HolonomicSequence((n**2) + (n**2 + n)Sn, n), u(0) = 0, u(1) = 1, u(2) = -1/2, 2)]
>>> HolonomicFunction(-S(1)/2 + x*Dx, x, 0, {S(1)/2: [1]}).to_sequence()
[(HolonomicSequence((n), n), u(0) = 1, 1/2, 1)]

另见

HolonomicFunction.series

参考文献

[R565]

hal.inria.fr/inria-00070025/document

[R566]

www3.risc.jku.at/publications/download/risc_2244/DIPLFORM.pdf

级数展开

HolonomicFunction.series(n=6, coefficient=False, order=True, _recur=None)

找到给定的全息函数关于 (x_0) 的幂级数展开。

解释

如果 (x_0) 是指标方程具有多个根的正则点，则可能返回系列列表。

示例

>>> from sympy.holonomic.holonomic import HolonomicFunction, DifferentialOperators
>>> from sympy import QQ
>>> from sympy import symbols
>>> x = symbols('x')
>>> R, Dx = DifferentialOperators(QQ.old_poly_ring(x),'Dx')
>>> HolonomicFunction(Dx - 1, x, 0, [1]).series()  # e^x
1 + x + x**2/2 + x**3/6 + x**4/24 + x**5/120 + O(x**6)
>>> HolonomicFunction(Dx**2 + 1, x, 0, [0, 1]).series(n=8)  # sin(x)
x - x**3/6 + x**5/120 - x**7/5040 + O(x**8)

另见

HolonomicFunction.to_sequence

数值评估

HolonomicFunction.evalf(points, method='RK4', h=0.05, derivatives=False)

使用数值方法找到霍洛莫尼克函数的数值。（默认使用 RK4）。必须提供一组点（实数或复数），这将是数值积分的路径。

解释

路径应以列表形式给出 ([x_1, x_2, \dots x_n])。将按此顺序计算每个点的数值 (x_1 \rightarrow x_2 \rightarrow x_3 \dots \rightarrow x_n)。

返回在列表中 (x_1, x_2, \dots x_n) 处函数的值。

示例

>>> from sympy.holonomic.holonomic import HolonomicFunction, DifferentialOperators
>>> from sympy import QQ
>>> from sympy import symbols
>>> x = symbols('x')
>>> R, Dx = DifferentialOperators(QQ.old_poly_ring(x),'Dx')

实轴上从 (0 到 1) 的直线

>>> r = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1]

从 0.1 到 1 上的 (e^x) 的四阶龙格-库塔法。在 1 处的精确解为 2.71828182845905

>>> HolonomicFunction(Dx - 1, x, 0, [1]).evalf(r)
[1.10517083333333, 1.22140257085069, 1.34985849706254, 1.49182424008069,
1.64872063859684, 1.82211796209193, 2.01375162659678, 2.22553956329232,
2.45960141378007, 2.71827974413517]

欧拉法的相同

>>> HolonomicFunction(Dx - 1, x, 0, [1]).evalf(r, method='Euler')
[1.1, 1.21, 1.331, 1.4641, 1.61051, 1.771561, 1.9487171, 2.14358881,
2.357947691, 2.5937424601]

人们还可以观察到，使用四阶龙格-库塔法获得的值比欧拉法更精确。

转换为超几何函数的线性组合

HolonomicFunction.to_hyper(as_list=False, _recur=None)

返回表示给定霍洛莫尼克函数的超几何函数（或其线性组合）。

解释

返回形式为：(a_1 \cdot x^{b_1} \cdot{hyper()} + a_2 \cdot x^{b_2} \cdot{hyper()} \dots) 的答案。

这非常有用，因为现在可以使用 hyperexpand 找到符号表达式/函数。

示例

>>> from sympy.holonomic.holonomic import HolonomicFunction, DifferentialOperators
>>> from sympy import ZZ
>>> from sympy import symbols
>>> x = symbols('x')
>>> R, Dx = DifferentialOperators(ZZ.old_poly_ring(x),'Dx')
>>> # sin(x)
>>> HolonomicFunction(Dx**2 + 1, x, 0, [0, 1]).to_hyper()
x*hyper((), (3/2,), -x**2/4)
>>> # exp(x)
>>> HolonomicFunction(Dx - 1, x, 0, [1]).to_hyper()
hyper((), (), x)

请参见

from_hyper, from_meijerg

转换为 Meijer G 函数的线性组合

HolonomicFunction.to_meijerg()

返回 Meijer G 函数的线性组合。

示例

>>> from sympy.holonomic import expr_to_holonomic
>>> from sympy import sin, cos, hyperexpand, log, symbols
>>> x = symbols('x')
>>> hyperexpand(expr_to_holonomic(cos(x) + sin(x)).to_meijerg())
sin(x) + cos(x)
>>> hyperexpand(expr_to_holonomic(log(x)).to_meijerg()).simplify()
log(x)

请参见

to_hyper

转换为表达式

HolonomicFunction.to_expr()

将霍洛莫尼克函数转换回初等函数。

示例

>>> from sympy.holonomic.holonomic import HolonomicFunction, DifferentialOperators
>>> from sympy import ZZ
>>> from sympy import symbols, S
>>> x = symbols('x')
>>> R, Dx = DifferentialOperators(ZZ.old_poly_ring(x),'Dx')
>>> HolonomicFunction(x**2*Dx**2 + x*Dx + (x**2 - 1), x, 0, [0, S(1)/2]).to_expr()
besselj(1, x)
>>> HolonomicFunction((1 + x)*Dx**3 + Dx**2, x, 0, [1, 1, 1]).to_expr()
x*log(x + 1) + log(x + 1) + 1

将其他表示转换为全局函数

原文链接：docs.sympy.org/latest/modules/holonomic/convert.html

转换超几何函数

sympy.holonomic.holonomic.from_hyper(func, x0=0, evalf=False)

将超几何函数转换为全局函数。func 是超几何函数，x0 是需要初始条件的点。

示例

>>> from sympy.holonomic.holonomic import from_hyper
>>> from sympy import symbols, hyper, S
>>> x = symbols('x')
>>> from_hyper(hyper([], [S(3)/2], x**2/4))
HolonomicFunction((-x) + (2)*Dx + (x)*Dx**2, x, 1, [sinh(1), -sinh(1) + cosh(1)])

转换 Meijer G-函数

sympy.holonomic.holonomic.from_meijerg(func, x0=0, evalf=False, initcond=True, domain=QQ)

将 Meijer G-函数转换为全局函数。func 是 G-函数，x0 是需要初始条件的点。

示例

>>> from sympy.holonomic.holonomic import from_meijerg
>>> from sympy import symbols, meijerg, S
>>> x = symbols('x')
>>> from_meijerg(meijerg(([], []), ([S(1)/2], [0]), x**2/4))
HolonomicFunction((1) + (1)*Dx**2, x, 0, [0, 1/sqrt(pi)])

转换符号表达式

sympy.holonomic.holonomic.expr_to_holonomic(func, x=None, x0=0, y0=None, lenics=None, domain=None, initcond=True)

将函数或表达式转换为全局函数。

参数：

func:

待转换的表达式。

函数的变量。

x0:

必须计算初始条件的点。

y0:

如果方法无法自动执行，可以选择提供初始条件。

lenics:

初始条件中的项数。默认情况下等于湮灭子的阶数。

domain:

在湮灭子中作为系数出现的多项式 x 的基本域。

initcond:

如果不想计算初始条件，请将其设置为 false。

示例

>>> from sympy.holonomic.holonomic import expr_to_holonomic
>>> from sympy import sin, exp, symbols
>>> x = symbols('x')
>>> expr_to_holonomic(sin(x))
HolonomicFunction((1) + (1)*Dx**2, x, 0, [0, 1])
>>> expr_to_holonomic(exp(x))
HolonomicFunction((-1) + (1)*Dx, x, 0, [1])

另请参阅

sympy.integrals.meijerint._rewrite1, _convert_poly_rat_alg, _create_table

用途和当前的限制

原文链接：docs.sympy.org/latest/modules/holonomic/uses.html

积分

可以按照以下步骤使用全局函数执行积分：

将被积函数转换为全局函数。
现在整合函数的全局表达式。
将积分再转换为表达式。

示例

>>> from sympy.abc import x, a
>>> from sympy import sin
>>> from sympy.holonomic import expr_to_holonomic
>>> expr_to_holonomic(1/(x**2+a), x).integrate(x).to_expr()
atan(x/sqrt(a))/sqrt(a)
>>> expr_to_holonomic(sin(x)/x).integrate(x).to_expr()
Si(x)

正如您在第一个示例中看到的，我们将函数转换为全局函数，对结果进行积分，然后再转换回符号表达式。

局限性

1. 并非总是可以转换为表达式。全局函数应该在 x0 处具有超几何级数。

2. 当解需要具有 (\log) 项时，当前转换为全局序列的实现不支持 Frobenius method。当指标方程的至少一个根对之间差一个整数时，以及 Frobenius 方法产生线性相关的级数解时，这种情况就会发生。由于我们在转换为表达式时使用这个方法，有时 to_expr() 会失败。

3. 似乎没有计算不定积分的方法，所以 integrate() 基本上计算的是 (\int_{x_0}^{x} f(x)dx)，如果没有给出限制条件，则 (x_0) 是存储被积函数初始条件的点。有时结果会多出一个常数。例如：

>>> expr_to_holonomic(sin(x)).integrate(x).to_expr()
1 - cos(x)
>>> sin(x).integrate(x)
-cos(x)

(\sin(x)) 的不定积分是 (-\cos(x))。但输出为 (-\cos(x) + 1)，即 (\int_{0}^{x} sin(x)dx)。虽然两者都被认为是正确的，但 (-\cos(x)) 更简单。

内部 API

原文：docs.sympy.org/latest/modules/holonomic/internal.html

sympy.holonomic.holonomic._create_table(table, domain=QQ)

创建查找表。有关类似实现，请参见 meijerint._create_lookup_table。

sympy.holonomic.holonomic._convert_poly_rat_alg(func, x, x0=0, y0=None, lenics=None, domain=QQ, initcond=True)

将多项式、有理数和代数函数转换为全局性函数。

李代数

原文：docs.sympy.org/latest/modules/liealgebras/index.html

class sympy.liealgebras.root_system.RootSystem(cartantype)

表示简单李代数的根系

每个简单李代数都有一个唯一的根系。要找到根系，我们首先考虑 g 的 Cartan 子代数，即最大的阿贝尔子代数，并考虑 g 对该子代数的伴随作用。与此作用相关联的是一个根系。现在，一个向量空间 V 上的根系是一组有限向量 Phi（称为根），满足：

根跨越 V
Phi 中 x 的唯一标量倍数是 x 和-x
对于 Phi 中的每个 x，Phi 集合在通过 x 的垂直超平面的反射下是封闭的。
如果 x 和 y 是 Phi 中的根，则 y 在通过 x 的线上的投影是 x 的半整数倍。

现在，有 Phi 的一个子集 Delta，我们称之为 Delta，满足：1. Delta 是 V 的一个基础 2. Phi 中的每个根 x 可以写成 x = sum k_y y，其中 y 在 Delta 中

Delta 的元素被称为简单根。因此，我们可以看到简单根跨越了给定简单李代数的根空间。

参考文献

[R598]

en.wikipedia.org/wiki/Root_system

[R599]

李代数与表示论 - Humphreys

add_as_roots(root1, root2)

只有它们的和也是一个根时才将两个根相加

它以两个应该是根的向量作为输入。然后计算它们的和，并检查它是否在所有可能根的列表中。如果是，则返回总和。否则，返回一个字符串，说明总和不是一个根。

例子

>>> from sympy.liealgebras.root_system import RootSystem
>>> c = RootSystem("A3")
>>> c.add_as_roots([1, 0, -1, 0], [0, 0, 1, -1])
[1, 0, 0, -1]
>>> c.add_as_roots([1, -1, 0, 0], [0, 0, -1, 1])
'The sum of these two roots is not a root'

add_simple_roots(root1, root2)

将两个简单根相加

此函数将两个整数 root1 和 root2 作为输入。然后，它将这些整数用作简单根字典中的键，并获取相应的简单根，然后将它们相加。

例子

>>> from sympy.liealgebras.root_system import RootSystem
>>> c = RootSystem("A3")
>>> newroot = c.add_simple_roots(1, 2)
>>> newroot
[1, 0, -1, 0]

all_roots()

生成给定根系的所有根。

结果是一个字典，其键是整数。它通过从基类获取所有正根的字典，然后取每个根，乘以-1 并加入字典来生成根。通过这种方式生成所有负根。

cartan_matrix()

与此根系相关联的李代数的 Cartan 矩阵

例子

>>> from sympy.liealgebras.root_system import RootSystem
>>> c = RootSystem("A3")
>>> c.cartan_matrix()
Matrix([
 [ 2, -1,  0],
 [-1,  2, -1],
 [ 0, -1,  2]])

dynkin_diagram()

与此根系相关联的李代数的 Dynkin 图

例子

>>> from sympy.liealgebras.root_system import RootSystem
>>> c = RootSystem("A3")
>>> print(c.dynkin_diagram())
0---0---0
1   2   3

root_space()

返回简单根的跨度

根空间是由简单根张成的向量空间，即具有显著基础的向量空间，即简单根。该方法返回一个表示根空间的字符串，作为简单根 alpha[1]，...，alpha[n]的张量。

例子

>>> from sympy.liealgebras.root_system import RootSystem
>>> c = RootSystem("A3")
>>> c.root_space()
'alpha[1] + alpha[2] + alpha[3]'

simple_roots()

生成李代数的简单根

李代数的秩决定了它具有的简单根数量。该方法获取李代数的秩，然后使用李代数类中的 simple_root 方法生成所有简单根。

例子

>>> from sympy.liealgebras.root_system import RootSystem
>>> c = RootSystem("A3")
>>> roots = c.simple_roots()
>>> roots
{1: [1, -1, 0, 0], 2: [0, 1, -1, 0], 3: [0, 0, 1, -1]}

class sympy.liealgebras.type_a.TypeA(n)

此类包含有关简单 Lie 代数 A 系列的信息。 ====

basic_root(i, j)

这是一种仅生成具有第 i 个位置为 1 和第 j 个位置为-1 的根的方法。

basis()

返回 A_n 的独立生成器数目

cartan_matrix()

返回 A_n 的 Cartan 矩阵。Lie 代数的 Cartan 矩阵是通过对简单根(alpha[1], …., alpha[l])进行排序生成的。然后 Cartan 矩阵的 ij 项是(<alpha[i],alpha[j]>).

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType('A4')
>>> c.cartan_matrix()
Matrix([
[ 2, -1,  0,  0],
[-1,  2, -1,  0],
[ 0, -1,  2, -1],
[ 0,  0, -1,  2]])

dimension()

Lie 代数 V 空间的向量维数

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("A4")
>>> c.dimension()
5

highest_root()

返回 A_n 的最高权根

lie_algebra()

返回与 A_n 相关联的 Lie 代数

positive_roots()

这种方法生成 A_n 的所有正根。这是 A_n 所有根的一半；通过将所有正根乘以-1，我们得到负根。

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("A3")
>>> c.positive_roots()
{1: [1, -1, 0, 0], 2: [1, 0, -1, 0], 3: [1, 0, 0, -1], 4: [0, 1, -1, 0],
 5: [0, 1, 0, -1], 6: [0, 0, 1, -1]}

roots()

返回 A_n 的总根数

simple_root(i)

每个李代数都有一个唯一的根系。给定一个根系 Q，存在一个子集合根使得 Q 的元素称为简单根，如果它不能被写成 Q 中两个元素的和。如果我们让 D 表示简单根的集合，那么很明显，Q 的每个元素都可以写成 D 的元素的线性组合，所有系数都是非负的。

在 A_n 中，第 i 个简单根是具有第 i 个位置为 1，在(i+1)位置为-1，其他位置为零的根。

此方法返回 A 系列的第 i 个简单根。

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("A4")
>>> c.simple_root(1)
[1, -1, 0, 0, 0]

class sympy.liealgebras.type_b.TypeB(n)

basic_root(i, j)

这是一种仅生成具有第 i 个位置为 1 和第 j 个位置为-1 的根的方法。

basis()

返回 B_n 的独立生成器数目

cartan_matrix()

返回 B_n 的 Cartan 矩阵。Lie 代数的 Cartan 矩阵是通过对简单根(alpha[1], …., alpha[l])进行排序生成的。然后 Cartan 矩阵的 ij 项是(<alpha[i],alpha[j]>).

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType('B4')
>>> c.cartan_matrix()
Matrix([
[ 2, -1,  0,  0],
[-1,  2, -1,  0],
[ 0, -1,  2, -2],
[ 0,  0, -1,  2]])

dimension()

Lie 代数 V 空间的向量维数

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("B3")
>>> c.dimension()
3

lie_algebra()

返回与 B_n 相关联的 Lie 代数

positive_roots()

此方法生成 A_n 的所有正根。这是 B_n 所有根的一半；通过将所有正根乘以-1，我们得到负根。

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("A3")
>>> c.positive_roots()
{1: [1, -1, 0, 0], 2: [1, 0, -1, 0], 3: [1, 0, 0, -1], 4: [0, 1, -1, 0],
 5: [0, 1, 0, -1], 6: [0, 0, 1, -1]}

roots()

返回 B_n 的总根数”

simple_root(i)

在 B_n 中，前 n-1 个简单根与 A_(n-1)中的根相同（第 i 个位置为 1，(i+1)位置为-1，其他位置为零）。第 n 个简单根是在第 n 个位置为 1，其他位置为零的根。

此方法返回 B 系列的第 i 个简单根。

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("B3")
>>> c.simple_root(2)
[0, 1, -1]

class sympy.liealgebras.type_c.TypeC(n)

basic_root(i, j)

生成具有第 i 个位置为 1 和第 j 个位置为-1 的根

basis()

返回 C_n 的独立生成器数目

cartan_matrix()

C_n 的 Cartan 矩阵

李代数的 Cartan 矩阵由简单根（alpha[1], …, alpha[l]）的顺序分配生成。然后 Cartan 矩阵的 ij 项是(<alpha[i],alpha[j]>).

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType('C4')
>>> c.cartan_matrix()
Matrix([
[ 2, -1,  0,  0],
[-1,  2, -1,  0],
[ 0, -1,  2, -1],
[ 0,  0, -2,  2]])

dimension()

李代数 V 的基础空间 V 的维数

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("C3")
>>> c.dimension()
3

lie_algebra()

返回与 C_n 相关联的李代数”

positive_roots()

生成 A_n 的所有正根

这是 C_n 所有根的一半；通过将所有正根乘以-1 我们得到负根。

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("A3")
>>> c.positive_roots()
{1: [1, -1, 0, 0], 2: [1, 0, -1, 0], 3: [1, 0, 0, -1], 4: [0, 1, -1, 0],
 5: [0, 1, 0, -1], 6: [0, 0, 1, -1]}

roots()

返回 C_n 的总根数”

simple_root(i)

C 系列的第 i 个简单根

每个李代数都有一个独特的根系。给定一个根系 Q，存在根的子集，称为简单根，如果它不能被写成 Q 中两个元素的和。如果我们让 D 表示简单根集合，则显然 Q 中的每个元素都可以被 D 的元素的非负系数线性组合表示。

在 C_n 中，前 n-1 个简单根与 A_(n-1)中的根相同（第 i 个位置为 1，第(i+1)个位置为-1，其他位置为零）。第 n 个简单根是第 n 位置为 2，其他位置为零的根。

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("C3")
>>> c.simple_root(2)
[0, 1, -1]

class sympy.liealgebras.type_d.TypeD(n)

basic_root(i, j)

这是一种只生成第 i 个位置为 1，第 j 个位置为-1 的根的方法。

basis()

返回 D_n 的独立生成元的数量。

cartan_matrix()

返回 D_n 的 Cartan 矩阵。李代数的 Cartan 矩阵由简单根（alpha[1], …, alpha[l]）的顺序分配生成。然后 Cartan 矩阵的 ij 项是(<alpha[i],alpha[j]>).

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType('D4')
>>> c.cartan_matrix()
 Matrix([
 [ 2, -1,  0,  0],
 [-1,  2, -1, -1],
 [ 0, -1,  2,  0],
 [ 0, -1,  0,  2]])

dimension()

李代数 V 的基础空间 V 的维数

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("D4")
>>> c.dimension()
4

lie_algebra()

返回与 D_n 相关联的李代数”

positive_roots()

这种方法生成 A_n 的所有正根。这是 D_n 所有根的一半，通过将所有正根乘以-1 我们得到负根。

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("A3")
>>> c.positive_roots()
{1: [1, -1, 0, 0], 2: [1, 0, -1, 0], 3: [1, 0, 0, -1], 4: [0, 1, -1, 0],
 5: [0, 1, 0, -1], 6: [0, 0, 1, -1]}

roots()

返回 D_n 的总根数”

simple_root(i)

在 D_n 中，前 n-1 个简单根与 A_(n-1)中的根相同（第 i 个位置为 1，第(i+1)个位置为-1，其他位置为零）。第 n 个简单根是第 n 和(n-1)位置为 1，其他位置为零的根。

这种方法返回 D 系列的第 i 个简单根。

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("D4")
>>> c.simple_root(2)
[0, 1, -1, 0]

class sympy.liealgebras.type_e.TypeE(n)

basic_root(i, j)

这是一种只生成第 i 个位置为-1，第 j 个位置为 1 的根的方法。

basis()

返回 E_n 的独立生成元的数量。

cartan_matrix()

返回 G_2 的 Cartan 矩阵。李代数的 Cartan 矩阵由简单根（alpha[1], …, alpha[l]）的顺序分配生成。然后 Cartan 矩阵的 ij 项是(<alpha[i],alpha[j]>).

例子

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType('A4')
>>> c.cartan_matrix()
Matrix([
[ 2, -1,  0,  0],
[-1,  2, -1,  0],
[ 0, -1,  2, -1],
[ 0,  0, -1,  2]])

dimension()

向量空间 V 的维数作为李代数的基础

例子

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("E6")
>>> c.dimension()
8

positive_roots()

此方法生成 A_n 的所有正根。这是 E_n 所有根的一半；通过将所有正根乘以 -1，我们得到负根。

例子

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("A3")
>>> c.positive_roots()
{1: [1, -1, 0, 0], 2: [1, 0, -1, 0], 3: [1, 0, 0, -1], 4: [0, 1, -1, 0],
 5: [0, 1, 0, -1], 6: [0, 0, 1, -1]}

roots()

返回 E_n 的根的总数

simple_root(i)

每个李代数都有一个唯一的根系。给定一个根系 Q，存在一个子集合使得 Q 中的一个元素被称为简单根，如果它不能被 Q 中的两个元素之和表示。如果我们让 D 表示简单根的集合，则很明显 Q 中的每个元素都可以用 D 中元素的线性组合表示，而且所有系数都是非负的。

此方法返回 E_n 的第 i 个简单根。

例子

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("E6")
>>> c.simple_root(2)
[1, 1, 0, 0, 0, 0, 0, 0]

class sympy.liealgebras.type_f.TypeF(n)

basic_root(i, j)

在第 i 个位置为 1 和第 j 个位置为 -1 的根

basis()

返回 F_4 的独立生成器数目

cartan_matrix()

F_4 的 Cartan 矩阵

对于一个李代数的 Cartan 矩阵是通过为简单根分配一个顺序生成的，(alpha[1], …., alpha[l])。然后 Cartan 矩阵的 ij 元素是 (<alpha[i],alpha[j]>).

例子

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType('A4')
>>> c.cartan_matrix()
Matrix([
[ 2, -1,  0,  0],
[-1,  2, -1,  0],
[ 0, -1,  2, -1],
[ 0,  0, -1,  2]])

dimension()

向量空间 V 的维数作为李代数的基础

例子

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("F4")
>>> c.dimension()
4

positive_roots()

生成 A_n 的所有正根

这是 F_4 所有根的一半；通过将所有正根乘以 -1，我们得到负根。

例子

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("A3")
>>> c.positive_roots()
{1: [1, -1, 0, 0], 2: [1, 0, -1, 0], 3: [1, 0, 0, -1], 4: [0, 1, -1, 0],
 5: [0, 1, 0, -1], 6: [0, 0, 1, -1]}

roots()

返回 F_4 的根的总数

simple_root(i)

F_4 的第 i 个简单根

例子

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("F4")
>>> c.simple_root(3)
[0, 0, 0, 1]

class sympy.liealgebras.type_g.TypeG(n)

basis()

返回 G_2 的独立生成器数目

cartan_matrix()

G_2 的 Cartan 矩阵

对于一个李代数的 Cartan 矩阵是通过为简单根分配一个顺序生成的，(alpha[1], …., alpha[l])。然后 Cartan 矩阵的 ij 元素是 (<alpha[i],alpha[j]>).

例子

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("G2")
>>> c.cartan_matrix()
Matrix([
 [ 2, -1],
 [-3,  2]])

dimension()

向量空间 V 的维数作为李代数的基础

例子

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("G2")
>>> c.dimension()
3

positive_roots()

生成 A_n 的所有正根

这是 A_n 所有根的一半；通过将所有正根乘以 -1，我们得到负根。

例子

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("A3")
>>> c.positive_roots()
{1: [1, -1, 0, 0], 2: [1, 0, -1, 0], 3: [1, 0, 0, -1], 4: [0, 1, -1, 0],
 5: [0, 1, 0, -1], 6: [0, 0, 1, -1]}

roots()

返回 G_2 的根的总数”

simple_root(i)

G_2 的第 i 个简单根

例子

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("G2")
>>> c.simple_root(1)
[0, 1, -1]

class sympy.liealgebras.weyl_group.WeylGroup(cartantype)

对于每个半单 Lie 群，我们有一个 Weyl 群。它是根系的等距群的子群。具体而言，它是通过与根正交的超平面的反射生成的子群。因此，Weyl 群是反射群，因此 Weyl 群是有限 Coxeter 群的一种。

coxeter_diagram()

此方法返回与 Weyl 群对应的 Coxeter 图。通过从李代数的 Dynkin 图中删除所有箭头可以获得 Coxeter 图；Coxeter 图是无向图。Coxeter 图的顶点表示 Weyl 群的生成反射，(s_i)。如果(s_i)和(s_j)的顺序(m(i, j))大于 2，则两者之间会有一条边。如果有一条边，则顺序(m(i, j))为 3。如果有两条边，则顺序(m(i, j))为 4，如果有三条边，则顺序(m(i, j))为 6。

例子

>>> from sympy.liealgebras.weyl_group import WeylGroup
>>> c = WeylGroup("B3")
>>> print(c.coxeter_diagram())
0---0===0
1   2   3

delete_doubles(reflections)

这是确定 G2 的 Weyl 群中元素顺序的辅助方法。它接受一个 Weyl 元素，并删除其中的重复简单反射。

element_order(weylelt)

此方法返回给定 Weyl 群元素的顺序，用户应以生成反射的形式指定，即形如 r1*r2 等。

对于类型 A-F，此方法当前通过获取指定元素的矩阵形式，并找到该矩阵的幂等于单位矩阵。然后返回这个幂。

例子

>>> from sympy.liealgebras.weyl_group import WeylGroup
>>> b = WeylGroup("B4")
>>> b.element_order('r1*r4*r2')
4

generators()

此方法为给定李代数创建 Weyl 群的生成反射。对于秩为 n 的李代数，有 n 个不同的生成反射。此函数将它们作为列表返回。

例子

>>> from sympy.liealgebras.weyl_group import WeylGroup
>>> c = WeylGroup("F4")
>>> c.generators()
['r1', 'r2', 'r3', 'r4']

group_name()

此方法返回给定李代数的 Weyl 群的一些一般信息。它返回群的名称及其作用的元素（如果相关）。

group_order()

此方法返回 Weyl 群的顺序。对于类型 A、B、C、D 和 E，顺序取决于李代数的秩。对于类型 F 和 G，顺序是固定的。

例子

>>> from sympy.liealgebras.weyl_group import WeylGroup
>>> c = WeylGroup("D4")
>>> c.group_order()
192.0

matrix_form(weylelt)

此方法接受用户以生成反射的形式的输入，并返回对应于 Weyl 群元素的矩阵。由于 Weyl 群的每个元素都是某种类型的反射，因此有对应的矩阵表示。此方法使用所有生成反射的标准表示。

例子

>>> from sympy.liealgebras.weyl_group import WeylGroup
>>> f = WeylGroup("F4")
>>> f.matrix_form('r2*r3')
Matrix([
[1, 0, 0,  0],
[0, 1, 0,  0],
[0, 0, 0, -1],
[0, 0, 1,  0]])

class sympy.liealgebras.cartan_type.CartanType_generator

实际创建事物的构造函数

class sympy.liealgebras.cartan_type.Standard_Cartan(series, n)

Cartan 类型的具体基类，如 A4 等

rank()

返回李代数的秩

series()

返回李代数的类型

sympy.liealgebras.dynkin_diagram.DynkinDiagram(t)

显示给定李代数的 Dynkin 图

通过生成输入 t 的 CartanType 来工作，然后从各个类中返回 Dynkin 图方法。

例子

>>> from sympy.liealgebras.dynkin_diagram import DynkinDiagram
>>> print(DynkinDiagram("A3"))
0---0---0
1   2   3

>>> print(DynkinDiagram("B4"))
0---0---0=>=0
1   2   3   4

sympy.liealgebras.cartan_matrix.CartanMatrix(ct)

访问特定李代数的 Cartan 矩阵

例子

>>> from sympy.liealgebras.cartan_matrix import CartanMatrix
>>> CartanMatrix("A2")
Matrix([
[ 2, -1],
[-1,  2]])

>>> CartanMatrix(['C', 3])
Matrix([
[ 2, -1,  0],
[-1,  2, -1],
[ 0, -2,  2]])

此方法通过返回对应于 Cartan 类型 t 的 Cartan 矩阵来工作。

SymPy-1-13-中文文档-四十八-

SymPy 1.13 中文文档（四十八）

平面

全息函数

内容

关于全纯函数

定义

参考文献

SymPy 中全纯函数的表示

全息函数的运算

加法和乘法

积分和微分

与多项式的组合

转换为完全序列

级数展开

数值评估

转换为超几何函数的线性组合

转换为 Meijer G 函数的线性组合

转换为表达式

将其他表示转换为全局函数

转换超几何函数

转换 Meijer G-函数

转换符号表达式

用途和当前的限制

积分

示例

局限性

内部 API

李代数