SymPy 1.13 中文文档（二十七）_sympy 中文手册

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

更多关于坐标系的内容

原文链接：docs.sympy.org/latest/modules/vector/coordsys.html

现在我们来看看如何在 sympy.vector 中初始化新的坐标系，通过用户定义的方式相对于已有系统进行变换。

定位新系统

我们已经知道 CoordSys3D 的 origin 属性对应于表示其原点参考点的 Point 实例。

考虑一个坐标系 (N)。假设我们想定义一个新系统 (M)，其原点相对于 (N) 的原点位于 (\mathbf{3\hat{i} + 4\hat{j} + 5\hat{k}}) 处。换句话说，从 (N) 的角度看，(M) 的原点坐标是 ((3, 4, 5))。此外，这也意味着从 (M) 的角度看，(N) 的原点坐标是 ((-3, -4, -5))。

这可以通过编程方式实现如下 -

>>> from sympy.vector import CoordSys3D
>>> N = CoordSys3D('N')
>>> M = N.locate_new('M', 3*N.i + 4*N.j + 5*N.k)
>>> M.position_wrt(N)
3*N.i + 4*N.j + 5*N.k
>>> N.origin.express_coordinates(M)
(-3, -4, -5) 
1
2
3
4
5
6
7

值得注意的是，(M) 的方向与 (N) 的方向相同。这意味着：(N) 相对于 (M) 的旋转矩阵，以及反过来，都等于维度为 3x3 的单位矩阵。locate_new 方法初始化一个 CoordSys3D，它在空间中只是平移，而不重新定向，相对于“父”系统。

初始化新系统

与‘定位’新系统类似，sympy.vector 还允许初始化新的 CoordSys3D 实例，这些实例以用户定义的方式相对于现有系统定向。

假设您有一个坐标系 (A)。

>>> from sympy.vector import CoordSys3D
>>> A = CoordSys3D('A') 
1
2

您希望初始化一个新的坐标系 (B)，该坐标系相对于 (A) 的 Z 轴旋转了一个角度 (\theta)。

>>> from sympy import Symbol
>>> theta = Symbol('theta') 
1
2

方向如下图所示：

有两种方法可以实现这一点。

直接使用 CoordSys3D 方法

这是最简单、最干净且推荐的方法。

>>> B = A.orient_new_axis('B', theta, A.k) 
1

这使用所需的方位信息初始化(B)，相对于(A)。

CoordSys3D在其 API 中提供了以下直接定向方法-

1. orient_new_axis

2. orient_new_body

3. orient_new_space

4. orient_new_quaternion

请查看本模块文档中给出的CoordSys3D类 API，以详细了解它们的功能和所需的参数。

使用Orienter和orient_new方法

您首先需要初始化一个AxisOrienter实例来存储旋转信息。

>>> from sympy.vector import AxisOrienter
>>> axis_orienter = AxisOrienter(theta, A.k) 
1
2

然后使用orient_new方法应用它，以获得(B)。

>>> B = A.orient_new('B', axis_orienter) 
1

orient_new还允许您使用多个Orienter实例定向新系统，这些实例以可迭代形式提供。旋转/定向按照Orienter实例在可迭代中出现的顺序应用于新系统。

>>> from sympy.vector import BodyOrienter
>>> from sympy.abc import a, b, c
>>> body_orienter = BodyOrienter(a, b, c, 'XYZ')
>>> C = A.orient_new('C', (axis_orienter, body_orienter)) 
1
2
3
4

sympy.vector API 为定向目的提供以下四个Orienter类：

1. AxisOrienter

2. BodyOrienter

3. SpaceOrienter

4. QuaternionOrienter

请参考本模块文档中各类的 API，了解更多信息。

在上述每个示例中，新坐标系的原点与“父”系统的原点重合。

>>> B.position_wrt(A)
0 
1
2

要计算任何坐标系相对于另一个坐标系的旋转矩阵，请使用rotation_matrix方法。

>>> B = A.orient_new_axis('B', a, A.k)
>>> B.rotation_matrix(A)
Matrix([
[ cos(a), sin(a), 0],
[-sin(a), cos(a), 0],
[      0,      0, 1]])
>>> B.rotation_matrix(B)
Matrix([
[1, 0, 0],
[0, 1, 0],
[0, 0, 1]]) 
1
2
3
4
5
6
7
8
9
10
11

定位和定向新系统

如果您想要初始化一个不仅在预定义方式下定向的新系统，还在父系统中进行了平移，该怎么办？

每个orient_new_<定向方法>方法以及orient_new方法都支持location关键字参数。

如果将Vector作为此kwarg的值提供，那么新系统的原点将自动定义为相对于父坐标系的该位置向量。

因此，定向方法也作为支持新系统定向+定位的方法。

>>> C = A.orient_new_axis('C', a, A.k, location=2*A.j)
>>> C.position_wrt(A)
2*A.j
>>> from sympy.vector import express
>>> express(A.position_wrt(C), C)
(-2*sin(a))*C.i + (-2*cos(a))*C.j 
1
2
3
4
5
6

后面详述express函数。

转换新系统

创建用户定义系统的最一般方法是在CoordSys3D中使用transformation参数。在这里，我们可以定义任何转换方程。如果我们对某些不同于笛卡尔坐标系的典型曲线坐标系感兴趣，我们也可以使用一些预定义的坐标系。也可以通过设置适当的转换方程来平移或旋转系统。

>>> from sympy.vector import CoordSys3D
>>> from sympy import sin, cos
>>> A = CoordSys3D('A', transformation='spherical')
>>> B = CoordSys3D('A', transformation=lambda x,y,z: (x*sin(y), x*cos(y), z)) 
1
2
3
4

在CoordSys3D中还有专用方法create_new，其工作方式类似于locate_new、orient_new_axis等方法。

>>> from sympy.vector import CoordSys3D
>>> A = CoordSys3D('A')
>>> B = A.create_new('B', transformation='spherical') 
1
2
3

在不同坐标系中的量的表达式

向量和二元向量

正如前面提到的，同一向量在不同坐标系中具有不同的表达式。通常，标量表达式和二阶张量也是如此。

sympy.vector 支持使用 express 函数在不同的坐标系中表达向量/标量量。

在本节中，假定以下初始化：

>>> from sympy.vector import CoordSys3D, express
>>> from sympy.abc import a, b, c
>>> N = CoordSys3D('N')
>>> M = N.orient_new_axis('M', a, N.k) 
1
2
3
4

用户可以使用 express 将 Vector 实例表示为用户定义的系统。

>>> v1 = N.i + N.j + N.k
>>> express(v1, M)
(sin(a) + cos(a))*M.i + (-sin(a) + cos(a))*M.j + M.k
>>> v2 = N.i + M.j
>>> express(v2, N)
(1 - sin(a))*N.i + (cos(a))*N.j 
1
2
3
4
5
6

除了 Vector 实例外，express 还支持重新表达标量（一般的 SymPy Expr）和 Dyadic 对象。

express 还接受第二个坐标系，用于重新表达 Dyadic 实例。

>>> d = 2*(M.i | N.j) + 3* (M.j | N.k)
>>> express(d, M)
(2*sin(a))*(M.i|M.i) + (2*cos(a))*(M.i|M.j) + 3*(M.j|M.k)
>>> express(d, M, N)
2*(M.i|N.j) + 3*(M.j|N.k) 
1
2
3
4
5

坐标变量

坐标系的原点位置不影响 BaseVector 实例的重新表达。但它确实影响了在不同系统中表达 BaseScalar 实例的方式。

BaseScalar 实例是坐标‘符号’，用于表示 sympy.vector 中向量/标量场的定义中使用的变量。

例如，考虑在系统 (N) 中定义的标量场 (\mathbf{{T}{N}(x, y, z) = x + y + z})。因此，在坐标为 ((a, b, c)) 的点处，该场的值为 (a + b + c)。现在考虑系统 (R)，其原点相对于 (N) 位于 ((1, 2, 3))（无方向变化）。在 (R) 中坐标为 ((a, b, c)) 的点，在 (N) 中的坐标为 ((a + 1, b + 2, c + 3))。因此，在系统 (R) 中，(\mathbf{{T}{N}}) 的表达式变为 (\mathbf{{T}_{R}}(x, y, z) = x + y + z + 6)。

如果向量/标量/二态表达式中存在坐标变量，则可以通过将 express 的 variables 关键字参数设置为 True 来在给定坐标系中重新表达它们。

上述示例，以编程方式完成，看起来像这样 -

>>> R = N.locate_new('R', N.i + 2*N.j + 3*N.k)
>>> T_N = N.x + N.y + N.z
>>> express(T_N, R, variables=True)
R.x + R.y + R.z + 6 
1
2
3
4

其他依赖表达式的方法

Vector 的 to_matrix 方法和 Point 的 express_coordinates 方法在提供不同坐标系时返回不同结果。

>>> P = R.origin.locate_new('P', a*R.i + b*R.j + c*R.k)
>>> P.express_coordinates(N)
(a + 1, b + 2, c + 3)
>>> P.express_coordinates(R)
(a, b, c)
>>> v = N.i + N.j + N.k
>>> v.to_matrix(M)
Matrix([
[ sin(a) + cos(a)],
[-sin(a) + cos(a)],
[               1]])
>>> v.to_matrix(N)
Matrix([
[1],
[1],
[1]]) 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

标量和向量场功能

原文链接：docs.sympy.org/latest/modules/vector/fields.html

在 sympy.vector 中的实现

标量和向量场

在 sympy.vector 中，每个 CoordSys3D 实例都分配了与 (X)、(Y) 和 (Z) 轴对应的基向量。这些可以分别通过名为 i、j 和 k 的属性访问。因此，要定义相对于给定框架 (\mathbf{R}) 的形式为 (3\mathbf{\hat{i}} + 4\mathbf{\hat{j}} + 5\mathbf{\hat{k}}) 的向量 (\mathbf{v})，您需要执行

>>> from sympy.vector import CoordSys3D
>>> R = CoordSys3D('R')
>>> v = 3*R.i + 4*R.j + 5*R.k 
1
2
3

向量数学和与向量相关的基本微积分运算已经在本模块文档的早期部分详细说明。

另一方面，基本标量（或坐标变量）实现在一个称为 BaseScalar 的特殊类中，并且为每个坐标系分配一个，从 (X)、(Y) 到 (Z) 的每个轴。这些坐标变量用于在三维空间中形成向量或标量场的表达式。对于系统 R，(X)、(Y) 和 (Z) 的 BaseScalars 实例可以分别使用 R.x、R.y 和 R.z 表达式访问。

因此，要生成前述电势场 (2{x}^{2}y) 的表达式，您需要执行

>>> from sympy.vector import CoordSys3D
>>> R = CoordSys3D('R')
>>> electric_potential = 2*R.x**2*R.y
>>> electric_potential
2*R.x**2*R.y 
1
2
3
4
5

注意，BaseScalar 实例可以像任何其他 SymPy Symbol 一样使用，只是它们存储与其对应的坐标系和轴的信息。

标量场可以像任何其他 SymPy 表达式一样处理，适用于任何数学/微积分功能。因此，要针对 (x)（即 R.x）不同电势，您将使用 diff 方法。

>>> from sympy.vector import CoordSys3D
>>> R = CoordSys3D('R')
>>> electric_potential = 2*R.x**2*R.y
>>> from sympy import diff
>>> diff(electric_potential, R.x)
4*R.x*R.y 
1
2
3
4
5
6

值得注意的是，在表达式中有 BaseScalar 意味着‘场’随位置（在三维空间中）变化。严格来说，一个简单的 Expr 没有 BaseScalar 仍然是一个场，尽管是常量。

类似于标量场，随位置变化的向量场也可以使用测量数字表达式中的 BaseScalar 构造。

>>> from sympy.vector import CoordSys3D
>>> R = CoordSys3D('R')
>>> v = R.x**2*R.i + 2*R.x*R.z*R.k 
1
2
3

Del 算子

Del 或 ‘Nabla’ 算子 - 写作 (\mathbf{\nabla})，通常称为向量微分算子。根据其在数学表达式中的用法，它可以表示标量场的梯度、向量场的散度或向量场的旋度。

本质上，(\mathbf{\nabla}) 在技术上不是一个‘算子’，而是一个便捷的数学符号，用于表示前述任一场操作。

在 sympy.vector 中，(\mathbf{\nabla}) 已经实现为 Del() 类。此类的实例独立于坐标系。因此，(\mathbf{\nabla}) 算子可以作为 Del() 访问。

下面是使用 Del() 类的一个示例。

>>> from sympy.vector import CoordSys3D, Del
>>> C = CoordSys3D('C')
>>> delop = Del()
>>> gradient_field = delop(C.x*C.y*C.z)
>>> gradient_field
(Derivative(C.x*C.y*C.z, C.x))*C.i + (Derivative(C.x*C.y*C.z, C.y))*C.j
+ (Derivative(C.x*C.y*C.z, C.z))*C.k 
1
2
3
4
5
6
7

可以使用 SymPy 的doit()例程计算上述表达式。

>>> gradient_field.doit()
C.y*C.z*C.i + C.x*C.z*C.j + C.x*C.y*C.k 
1
2

在sympy.vector中详细描述了使用(\mathbf{\nabla})符号的方法。

场算子和相关函数

这里我们描述了实现在sympy.vector中的一些基本场相关功能。

旋度

一个旋度是描述三维空间中矢量微小旋转的数学算子。方向由右手法则（沿着旋转轴）确定，大小由旋转的大小确定。

在 3D 笛卡尔坐标系中，三维矢量(\mathbf{F})的旋度，表示为(\nabla \times \mathbf{F})，由以下给出：

(\nabla \times \mathbf{F} = \left(\frac{\partial F_z}{\partial y} - \frac{\partial F_y}{\partial z}\right) \mathbf{\hat{i}} + \left(\frac{\partial F_x}{\partial z} - \frac{\partial F_z}{\partial x}\right) \mathbf{\hat{j}} + \left(\frac{\partial F_y}{\partial x} - \frac{\partial F_x}{\partial y}\right) \mathbf{\hat{k}})

其中(F_x)表示矢量(\mathbf{F})的(X)分量。

可以通过两种方式在sympy.vector中计算矢量场的旋度。

通过使用Del()类之一

>>> from sympy.vector import CoordSys3D, Del
>>> C = CoordSys3D('C')
>>> delop = Del()
>>> delop.cross(C.x*C.y*C.z*C.i).doit()
C.x*C.y*C.j + (-C.x*C.z)*C.k
>>> (delop ^ C.x*C.y*C.z*C.i).doit()
C.x*C.y*C.j + (-C.x*C.z)*C.k 
1
2
3
4
5
6
7

或者通过使用专用函数

>>> from sympy.vector import curl
>>> curl(C.x*C.y*C.z*C.i)
C.x*C.y*C.j + (-C.x*C.z)*C.k 
1
2
3

散度

散度是一个矢量算子，用于测量矢量场在给定点的源或汇的大小，用带符号的标量表示。

散度算子在对矢量进行操作后总是返回一个标量。

在 3D 笛卡尔坐标系中，三维矢量(\mathbf{F})的散度，表示为(\nabla\cdot\mathbf{F})，由以下给出：

(\nabla\cdot\mathbf{F} = \frac{\partial U}{\partial x} + \frac{\partial V}{\partial y} + \frac{\partial W}{\partial z })

其中(U)、(V)和(W)分别表示(\mathbf{F})的(X)、(Y)和(Z)分量。

可以通过两种方式在sympy.vector中计算矢量场的散度。

通过使用Del()类之一

>>> from sympy.vector import CoordSys3D, Del
>>> C = CoordSys3D('C')
>>> delop = Del()
>>> delop.dot(C.x*C.y*C.z*(C.i + C.j + C.k)).doit()
C.x*C.y + C.x*C.z + C.y*C.z
>>> (delop & C.x*C.y*C.z*(C.i + C.j + C.k)).doit()
C.x*C.y + C.x*C.z + C.y*C.z 
1
2
3
4
5
6
7

或者通过使用专用函数

>>> from sympy.vector import divergence
>>> divergence(C.x*C.y*C.z*(C.i + C.j + C.k))
C.x*C.y + C.x*C.z + C.y*C.z 
1
2
3

梯度

考虑三维空间中的标量场(f(x, y, z))。该场的梯度定义为相对于(X)、(Y)和(Z)轴的(f)的 3 个偏导数的矢量。

在 3D 笛卡尔坐标系中，标量场(f)的散度(\nabla f)由以下给出 -

(\nabla f = \frac{\partial f}{\partial x} \mathbf{\hat{i}} + \frac{\partial f}{\partial y} \mathbf{\hat{j}} + \frac{\partial f}{\partial z} \mathbf{\hat{k}})

可以通过两种方式在sympy.vector中计算矢量场的散度。

通过使用Del()类之一

>>> from sympy.vector import CoordSys3D, Del
>>> C = CoordSys3D('C')
>>> delop = Del()
>>> delop.gradient(C.x*C.y*C.z).doit()
C.y*C.z*C.i + C.x*C.z*C.j + C.x*C.y*C.k
>>> delop(C.x*C.y*C.z).doit()
C.y*C.z*C.i + C.x*C.z*C.j + C.x*C.y*C.k 
1
2
3
4
5
6
7

或者通过使用专用函数

>>> from sympy.vector import gradient
>>> gradient(C.x*C.y*C.z)
C.y*C.z*C.i + C.x*C.z*C.j + C.x*C.y*C.k 
1
2
3

方向导数

除了上述三种常见的 (\mathbf{\nabla}) 应用外，在 sympy.vector 中还可以计算相对于 Vector 的场的方向导数。

按定义，场 (\mathbf{F}) 沿着向量 (v) 在点 (x) 处的方向导数表示 (\mathbf{F}) 在速度 (v) 下通过 (x) 移动的瞬时变化率。数学上表示为：((\vec{v} \cdot \nabla) , \mathbf{F}(x))。

可以使用 Del() 类在 sympy.vector 中计算矢量和标量场的方向导数。

>>> from sympy.vector import CoordSys3D, Del
>>> C = CoordSys3D('C')
>>> delop = Del()
>>> vel = C.i + C.j + C.k
>>> scalar_field = C.x*C.y*C.z
>>> vector_field = C.x*C.y*C.z*C.i
>>> (vel.dot(delop))(scalar_field)
C.x*C.y + C.x*C.z + C.y*C.z
>>> (vel & delop)(vector_field)
(C.x*C.y + C.x*C.z + C.y*C.z)*C.i 
1
2
3
4
5
6
7
8
9
10

或者通过使用专用函数

>>> from sympy.vector import directional_derivative
>>> directional_derivative(C.x*C.y*C.z, 3*C.i + 4*C.j + C.k)
C.x*C.y + 4*C.x*C.z + 3*C.y*C.z 
1
2
3

正交曲线坐标系中的场算子

vector 包支持在不同类型的正交曲线坐标系中进行计算。为了实现这一点，使用缩放因子（也称为拉梅系数）来表达在所需类型的坐标系中计算 curl、divergence 或 gradient。

例如，如果我们想在柱坐标系中计算 gradient，我们只需创建适当的坐标系。

>>> from sympy.vector import CoordSys3D
>>> c = CoordSys3D('c', transformation='cylindrical', variable_names=("r", "theta", "z"))
>>> gradient(c.r*c.theta*c.z)
 c.theta*c.z*c.i + c.z*c.j + c.r*c.theta*c.k 
1
2
3
4

保守场与无旋场

在矢量微积分中，保守场是某些标量场的梯度的场。保守场具有其沿任意路径的线积分仅依赖于端点，并且与所走路径无关的特性。保守向量场也被称为‘无旋场’，因为保守场的旋度始终为零。

在物理学中，保守场代表在能量守恒的物理系统中的力。

要检查在 sympy.vector 中矢量场是否为保守场，可以使用 is_conservative 函数。

>>> from sympy.vector import CoordSys3D, is_conservative
>>> R = CoordSys3D('R')
>>> field = R.y*R.z*R.i + R.x*R.z*R.j + R.x*R.y*R.k
>>> is_conservative(field)
True
>>> curl(field)
0 
1
2
3
4
5
6
7

另一方面，一个无旋场是一个矢量场，在空间中所有点的散度都为零。

要检查在 sympy.vector 中矢量场是否为无旋场，可以使用 is_solenoidal 函数。

>>> from sympy.vector import CoordSys3D, is_solenoidal
>>> R = CoordSys3D('R')
>>> field = R.y*R.z*R.i + R.x*R.z*R.j + R.x*R.y*R.k
>>> is_solenoidal(field)
True
>>> divergence(field)
0 
1
2
3
4
5
6
7

标量势函数

我们先前提到，每个保守场可以定义为某些标量场的梯度。这个标量场也称为与前述保守场对应的‘标量势场’。

sympy.vector 中的 scalar_potential 函数计算给定三维空间中保守向量场对应的标量势场 - 当然要减去额外的积分常数。

使用示例 -

>>> from sympy.vector import CoordSys3D, scalar_potential
>>> R = CoordSys3D('R')
>>> conservative_field = 4*R.x*R.y*R.z*R.i + 2*R.x**2*R.z*R.j + 2*R.x**2*R.y*R.k
>>> scalar_potential(conservative_field, R)
2*R.x**2*R.y*R.z 
1
2
3
4
5

将非保守向量场作为参数提供给 scalar_potential 会引发 ValueError。

与保守矢量场对应的标量势差，或简称为“势差”，可以定义为其标量势函数在空间中两点处值的差异。这在计算与保守函数相关的线积分中非常有用，因为它仅取决于路径的端点。

在 sympy.vector 中，这种计算是如何执行的。

>>> from sympy.vector import CoordSys3D, Point
>>> from sympy.vector import scalar_potential_difference
>>> R = CoordSys3D('R')
>>> P = R.origin.locate_new('P', 1*R.i + 2*R.j + 3*R.k)
>>> vectfield = 4*R.x*R.y*R.i + 2*R.x**2*R.j
>>> scalar_potential_difference(vectfield, R, R.origin, P)
4 
1
2
3
4
5
6
7

如果提供的是标量表达式而不是矢量场，则 scalar_potential_difference 返回空间中两个给定点处标量场值的差异。

使用范例

原文链接：docs.sympy.org/latest/modules/vector/examples.html

本节详细说明了使用 sympy.vector 包解决向量数学/微积分中的两个基本问题。

四边形问题

问题

OABC 是三维空间中的任意四边形。P 是 OA 的中点，Q 是 AB 的中点，R 是 BC 的中点，S 是 OC 的中点。证明 PQ 平行于 SR

解决方案

此问题的解决方法展示了Point的使用，以及Vector的基本操作。

定义一个坐标系

>>> from sympy.vector import CoordSys3D
>>> Sys = CoordSys3D('Sys') 
1
2

将点 O 定义为 Sys 的原点。我们可以毫不失误地这样做。

>>> O = Sys.origin 
1

以 O 为基础定义点 A

>>> from sympy import symbols
>>> a1, a2, a3 = symbols('a1 a2 a3')
>>> A = O.locate_new('A', a1*Sys.i + a2*Sys.j + a3*Sys.k) 
1
2
3

同样根据问题定义点 B 和 C

>>> b1, b2, b3 = symbols('b1 b2 b3')
>>> B = O.locate_new('B', b1*Sys.i + b2*Sys.j + b3*Sys.k)
>>> c1, c2, c3 = symbols('c1 c2 c3')
>>> C = O.locate_new('C', c1*Sys.i + c2*Sys.j + c3*Sys.k) 
1
2
3
4

P 是 OA 的中点。让我们相对于 O 定位它（你也可以相对于 A 定义它）。

>>> P = O.locate_new('P', A.position_wrt(O) + (O.position_wrt(A) / 2)) 
1

同样根据问题定义点 Q、R 和 S。

>>> Q = A.locate_new('Q', B.position_wrt(A) / 2)
>>> R = B.locate_new('R', C.position_wrt(B) / 2)
>>> S = O.locate_new('R', C.position_wrt(O) / 2) 
1
2
3

现在计算以 PQ 和 SR 指定的方向的向量。

>>> PQ = Q.position_wrt(P)
>>> SR = R.position_wrt(S) 
1
2

计算叉乘

>>> PQ.cross(SR)
0 
1
2

由于叉乘是零向量，所以这两个向量必须是平行的，从而证明 PQ || SR。

Del 操作符的第三个乘积法则

看见

[WikiDel]

en.wikipedia.org/wiki/Del

问题

证明第三条规则 - (\nabla \cdot (f \vec v) = f (\nabla \cdot \vec v) + \vec v \cdot (\nabla f))

解决方案

从一个坐标系开始

>>> from sympy.vector import CoordSys3D, Del
>>> delop = Del()
>>> C = CoordSys3D('C') 
1
2
3

标量场 (f) 和向量场 (\vec v) 的测量数都是一般坐标系统的坐标变量的函数。因此，以这种方式定义 SymPy 函数。

>>> from sympy import symbols, Function
>>> v1, v2, v3, f = symbols('v1 v2 v3 f', cls=Function) 
1
2

v1、v2 和 v3 分别是向量场的 (X)、(Y) 和 (Z) 分量。

将向量场定义为vfield，标量场定义为sfield。

>>> vfield = v1(C.x, C.y, C.z)*C.i + v2(C.x, C.y, C.z)*C.j + v3(C.x, C.y, C.z)*C.k
>>> ffield = f(C.x, C.y, C.z) 
1
2

使用 Del() 构建方程左侧的表达式。

>>> lhs = (delop.dot(ffield * vfield)).doit() 
1

同样，RHS 也将被定义。

>>> rhs = ((vfield.dot(delop(ffield))) + (ffield * (delop.dot(vfield)))).doit() 
1

现在，为了证明乘积法则，我们只需要使左手边和右手边的展开和简化版本相等，这样 SymPy 表达式就匹配了。

>>> lhs.expand().simplify() == rhs.expand().doit().simplify()
True 
1
2

因此，可以使用 sympy.vector 来证明上述第三个乘积法则的一般形式。

矢量积分的应用

原文：docs.sympy.org/latest/modules/vector/vector_integration.html

要在区域上积分一个标量或矢量场，我们必须首先定义一个区域。SymPy 提供了三种定义区域的方法：

1. 使用带有ParametricRegion的参数方程。

2. 使用带有ImplicitRegion的隐式方程。

3. 使用几何模块的对象。

vector_integrate() 函数用于在任何类型的区域上积分标量或矢量场。它根据对象的性质自动确定积分的类型（线、面或体）。

我们定义一个坐标系并为示例做必要的导入。

>>> from sympy import sin, cos, exp, pi, symbols
>>> from sympy.vector import CoordSys3D, ParametricRegion, ImplicitRegion, vector_integrate
>>> from sympy.abc import r, x, y, z, theta, phi
>>> C = CoordSys3D('C') 
1
2
3
4

周长、表面积和体积的计算

要计算圆的周长，我们需要定义它。让我们使用其参数方程定义它。

>>> param_circle = ParametricRegion((4*cos(theta), 4*sin(theta)), (theta, 0, 2*pi)) 
1

我们也可以使用其隐式方程定义一个圆。

>>> implicit_circle = ImplicitRegion((x, y), x**2 + y**2 - 4) 
1

图形的周长等于它在单位标量场上的积分的绝对值。

>>> vector_integrate(1, param_circle)
8*pi
>>> vector_integrate(1, implicit_circle)
4*pi 
1
2
3
4

假设用户想要计算三角形的周长。确定三角形的参数表示可能很困难。相反，用户可以使用几何模块中 Polygon 类的对象。

>>> from sympy.geometry import Point, Polygon
>>> triangle = Polygon(Point(1, 2), (3, 5), (1,6))
>>> vector_integrate(1, triangle)
sqrt(5) + sqrt(13) + 4 
1
2
3
4

要定义一个实心球，我们需要使用三个参数（r，theta 和 phi）。对于ParametricRegion对象来说，限制的顺序决定积分的符号。

>>> solidsphere = ParametricRegion((r*sin(phi)*cos(theta),r*sin(phi)*sin(theta), r*cos(phi)),
...                             (phi, 0, pi), (theta, 0, 2*pi), (r, 0, 3))
>>> vector_integrate(1, solidsphere)
36*pi 
1
2
3
4

物体质量的计算

考虑一个三角形片段