SymPy 1.13 中文文档（二十七）

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

标量和向量场功能

原文链接：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

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

另一方面，基本标量（或坐标变量）实现在一个称为 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

注意，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

值得注意的是，在表达式中有 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

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

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

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

在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

或者通过使用专用函数

>>> 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

散度

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

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

在 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

或者通过使用专用函数

>>> 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

梯度

考虑三维空间中的标量场(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

或者通过使用专用函数

>>> 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

方向导数

除了上述三种常见的 (\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

或者通过使用专用函数

>>> 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

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

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

保守场与无旋场

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

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

要检查在 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

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

要检查在 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

标量势函数

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

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

将非保守向量场作为参数提供给 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

如果提供的是标量表达式而不是矢量场，则 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')

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

>>> O = Sys.origin

以 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)

同样根据问题定义点 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)

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

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

同样根据问题定义点 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)

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

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

计算叉乘

>>> PQ.cross(SR)
0

由于叉乘是零向量，所以这两个向量必须是平行的，从而证明 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')

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

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

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)

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

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

同样，RHS 也将被定义。

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

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

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

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

矢量积分的应用

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

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

使用带有ParametricRegion的参数方程。
使用带有ImplicitRegion的隐式方程。
使用几何模块的对象。

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')

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

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

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

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

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

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

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

假设用户想要计算三角形的周长。确定三角形的参数表示可能很困难。相反，用户可以使用几何模块中 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

要定义一个实心球，我们需要使用三个参数（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

物体质量的计算

考虑一个三角形片段 𝑅，其顶点为 (0,0)，(0, 5)，(5,0)，密度为 (\rho(x, y) = xy:kg/m²)。找到总质量。

>>> triangle = ParametricRegion((x, y), (x, 0, 5), (y, 0, 5 - x))
>>> vector_integrate(C.x*C.y, triangle)
625/24

找到以 z 轴为中心的圆柱体的质量，其高度为 h，半径为 a，密度为 (\rho = x² + y²:kg/m²)。

>>> a, h = symbols('a h', positive=True)
>>> cylinder = ParametricRegion((r*cos(theta), r*sin(theta), z),
...                     (theta, 0, 2*pi), (z, 0, h), (r, 0, a))
>>> vector_integrate(C.x**2 + C.y**2, cylinder)
pi*a**4*h/2

通量的计算

1. 考虑空间中存在一个恒定向量场 (E(x, y, z) = a\mathbf{\hat{k}})。半径为 r 的半球位于 x-y 平面上。该场通过球体的通量是多少？

>>> semisphere = ParametricRegion((r*sin(phi)*cos(theta), r*sin(phi)*sin(theta), r*cos(phi)),\
...                             (phi, 0, pi/2), (theta, 0, 2*pi))
>>> flux = vector_integrate(a*C.k, semisphere)
>>> flux
pi*a*r**2

2. 考虑空间中存在向量场 (E(x, y, z) = x² \mathbf{\hat{k}}) 在 x-y 平面上方，并且在 x-y 平面下方存在一个场 (E(x, y, z) = y² \mathbf{\hat{k}})。该向量场穿过边长为 L 且中心在原点的立方体的通量是多少？

该场是沿着 z 轴平行的，因此只有箱子的顶部和底部会对通量有贡献。

>>> L = symbols('L', positive=True)
>>> top_face = ParametricRegion((x, y, L/2), (x, -L/2, L/2), (y, -L/2, L/2))
>>> bottom_face = ParametricRegion((x, y, -L/2), (x, -L/2, L/2), (y, -L/2, L/2))
>>> flux = vector_integrate(C.x**2*C.k, top_face) + vector_integrate(C.y**2*C.k, bottom_face)
>>> flux
L**4/6

验证斯托克斯定理

参见斯托克斯定理

示例 1

>>> from sympy.vector import curl
>>> curve = ParametricRegion((cos(theta), sin(theta)), (theta, 0, pi/2))
>>> surface = ParametricRegion((r*cos(theta), r*sin(theta)), (r, 0, 1), (theta, 0, pi/2))
>>> F = C.y*C.i + C.z*C.k + C.x*C.k
>>>
>>> vector_integrate(F, curve)
-pi/4
>>> vector_integrate(curl(F), surface)
-pi/4

示例 2

>>> circle = ParametricRegion((cos(theta), sin(theta), 1), (theta, 0, 2*pi))
>>> cone = ParametricRegion((r*cos(theta), r*sin(theta), r), (r, 0, 1), (theta, 0, 2*pi))
>>> cone = ParametricRegion((r*cos(theta), r*sin(theta), r), (r, 0, 1), (theta, 0, 2*pi))
>>> f = (-C.y**3/3 + sin(C.x))*C.i + (C.x**3/3 + cos(C.y))*C.j + C.x*C.y*C.z*C.k
>>> vector_integrate(f,  circle)
pi/2
>>> vector_integrate(curl(f),  cone)
pi/2

验证散度定理

参见散度定理

示例 1

>>> from sympy.vector import divergence
>>> sphere = ParametricRegion((4*sin(phi)*cos(theta),4*sin(phi)*sin(theta), 4*cos(phi)),
...                         (phi, 0, pi), (theta, 0, 2*pi))
>>> solidsphere = ParametricRegion((r*sin(phi)*cos(theta),r*sin(phi)*sin(theta), r*cos(phi)),
...     (r, 0, 4),(phi, 0, pi), (theta, 0, 2*pi))
>>> field = C.x**3*C.i + C.y**3*C.j + C.z**3*C.k
>>> vector_integrate(field, sphere)
12288*pi/5
>>> vector_integrate(divergence(field), solidsphere)
12288*pi/5

示例 2

>>> cube = ParametricRegion((x, y, z), (x, 0, 1), (y, 0, 1), (z, 0, 1))
>>> field = 2*C.x*C.y*C.i + 3*C.x*C.y*C.j + C.z*exp(C.x + C.y)*C.k
>>> vector_integrate(divergence(field), cube)
-E + 7/2 + E*(-1 + E)

向量 API

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

sympy.vector 中的关键类（文档字符串）
定向器类（文档字符串）
sympy.vector 中的关键函数（文档字符串）

sympy.vector 中的基本类（文档字符串）

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

class sympy.vector.coordsysrect.CoordSys3D(name, transformation=None, parent=None, location=None, rotation_matrix=None, vector_names=None, variable_names=None)

代表三维空间中的坐标系。

__init__(name, location=None, rotation_matrix=None, parent=None, vector_names=None, variable_names=None, latex_vects=None, pretty_vects=None, latex_scalars=None, pretty_scalars=None, transformation=None)

如果此系统在某个方向或位置相对于另一个定义，则方向/位置参数是必需的。

参数：

name : str

新 CoordSys3D 实例的名称。

transformation : Lambda, Tuple, str

根据变换方程定义的转换或从预定义的转换中选择的转换。

location : Vector

新系统原点相对于父实例的位置向量。

rotation_matrix : SymPy ImmutableMatrix

新坐标系的旋转矩阵，相对于父坐标系。换句话说，这是 new_system.rotation_matrix(parent) 的输出。

parent : CoordSys3D

相对于其方向/位置（或两者）正在定义的坐标系。

vector_names, variable_names : iterable(optional)

每个都是包含 3 个字符串的迭代器，分别用于新系统的基本向量和基本标量的自定义名称。用于简单的字符串打印。

create_new(name, transformation, variable_names=None, vector_names=None)

返回一个通过变换与自身连接的 CoordSys3D。

参数：

name : str

新 CoordSys3D 实例的名称。

transformation : Lambda, Tuple, str

根据变换方程定义的转换或从预定义的转换中选择的转换。

vector_names, variable_names : iterable(optional)

每个都是包含 3 个字符串的迭代器，分别用于新系统的基本向量和基本标量的自定义名称。用于简单的字符串打印。

示例

>>> from sympy.vector import CoordSys3D
>>> a = CoordSys3D('a')
>>> b = a.create_new('b', transformation='spherical')
>>> b.transformation_to_parent()
(b.r*sin(b.theta)*cos(b.phi), b.r*sin(b.phi)*sin(b.theta), b.r*cos(b.theta))
>>> b.transformation_from_parent()
(sqrt(a.x**2 + a.y**2 + a.z**2), acos(a.z/sqrt(a.x**2 + a.y**2 + a.z**2)), atan2(a.y, a.x))

locate_new(name, position, vector_names=None, variable_names=None)

返回一个 CoordSys3D，其原点位于给定位置相对于此坐标系原点的位置。

参数：

name : str

新 CoordSys3D 实例的名称。

position : Vector

相对于此系统原点的新系统原点的位置向量。

vector_names, variable_names : iterable(optional)

每个都是包含 3 个字符串的迭代器，分别用于新系统的基本向量和基本标量的自定义名称。用于简单的字符串打印。

示例

>>> from sympy.vector import CoordSys3D
>>> A = CoordSys3D('A')
>>> B = A.locate_new('B', 10 * A.i)
>>> B.origin.position_wrt(A.origin)
10*A.i

orient_new(name, orienters, location=None, vector_names=None, variable_names=None)

使用用户指定的方式创建一个与此系统相关的新 CoordSys3D。

请参阅有关定向程序的定向器类文档以获取更多信息。

参数：

name : str

新 CoordSys3D 实例的名称。

orienters : iterable/Orienter

一个 Orienter 或 Orienter 的迭代器，用于定向新坐标系。如果提供了一个 Orienter，则应用它以获得新系统。如果提供了一个可迭代对象，则按照它们出现的顺序应用定向器。

location : Vector(optional)

新坐标系原点相对于此系统原点的位置。如果未指定，则认为原点重合。

vector_names, variable_names : iterable(optional)

每个都是包含 3 个字符串的迭代器，分别用于新系统的基本向量和基本标量的自定义名称。用于简单的字符串打印。

示例

>>> from sympy.vector import CoordSys3D
>>> from sympy import symbols
>>> q0, q1, q2, q3 = symbols('q0 q1 q2 q3')
>>> N = CoordSys3D('N')

使用 AxisOrienter

>>> from sympy.vector import AxisOrienter
>>> axis_orienter = AxisOrienter(q1, N.i + 2 * N.j)
>>> A = N.orient_new('A', (axis_orienter, ))

使用 BodyOrienter

>>> from sympy.vector import BodyOrienter
>>> body_orienter = BodyOrienter(q1, q2, q3, '123')
>>> B = N.orient_new('B', (body_orienter, ))

使用 SpaceOrienter

>>> from sympy.vector import SpaceOrienter
>>> space_orienter = SpaceOrienter(q1, q2, q3, '312')
>>> C = N.orient_new('C', (space_orienter, ))

使用 QuaternionOrienter

>>> from sympy.vector import QuaternionOrienter
>>> q_orienter = QuaternionOrienter(q0, q1, q2, q3)
>>> D = N.orient_new('D', (q_orienter, ))

orient_new_axis(name, angle, axis, location=None, vector_names=None, variable_names=None)

轴旋转是围绕任意轴的旋转，旋转角度由 SymPy 表达式标量提供，轴由矢量提供。

参数：

name : 字符串

新坐标系的名称

angle : 表达式

新系统旋转的角度

axis : 矢量

执行旋转的轴

location : 矢量（可选）

新坐标系的原点位置相对于该系统的原点。如果未指定，则认为原点重合。

vector_names, variable_names : 可迭代对象（可选）

每个具有 3 个字符串的可迭代对象，分别为新系统的基向量和基标量的自定义名称。用于简单的字符串打印。

示例

>>> from sympy.vector import CoordSys3D
>>> from sympy import symbols
>>> q1 = symbols('q1')
>>> N = CoordSys3D('N')
>>> B = N.orient_new_axis('B', q1, N.i + 2 * N.j)

orient_new_body(name, angle1, angle2, angle3, rotation_order, location=None, vector_names=None, variable_names=None)

Body orientation 通过连续三个简单旋转带此坐标系。

Body fixed rotations 包括欧拉角和 Tait-Bryan 角，请参见 zh.wikipedia.org/wiki/欧拉角。

参数：

name : 字符串

新坐标系的名称

angle1, angle2, angle3 : 表达式

连续三个角度旋转坐标系

rotation_order : 字符串

定义旋转轴顺序的字符串

location : 矢量（可选）

新坐标系的原点位置相对于该系统的原点。如果未指定，则认为原点重合。

vector_names, variable_names : 可迭代对象（可选）

每个具有 3 个字符串的可迭代对象，分别为新系统的基向量和基标量的自定义名称。用于简单的字符串打印。

示例

>>> from sympy.vector import CoordSys3D
>>> from sympy import symbols
>>> q1, q2, q3 = symbols('q1 q2 q3')
>>> N = CoordSys3D('N')

'Body' 固定旋转由三个角度和三个固定于身体的旋转轴描述。为了将坐标系 D 相对于 N 定向，每个连续的旋转总是围绕固定在 D 上的正交单位向量进行的。例如，'123' 旋转将指定关于 N.i、然后 D.j、然后 D.k 的旋转。（最初，D.i 与 N.i 相同）因此，

>>> D = N.orient_new_body('D', q1, q2, q3, '123')

与之相同

>>> D = N.orient_new_axis('D', q1, N.i)
>>> D = D.orient_new_axis('D', q2, D.j)
>>> D = D.orient_new_axis('D', q3, D.k)

可接受的旋转顺序长度为 3，表达为 XYZ 或 123，并且不能连续两次围绕同一轴旋转。

>>> B = N.orient_new_body('B', q1, q2, q3, '123')
>>> B = N.orient_new_body('B', q1, q2, 0, 'ZXZ')
>>> B = N.orient_new_body('B', 0, 0, 0, 'XYX')

orient_new_quaternion(name, q0, q1, q2, q3, location=None, vector_names=None, variable_names=None)

四元数方向用四元数使新的 CoordSys3D 定向，由 lambda，一个单位向量，以某个量 theta 进行有限旋转定义。

此方向由四个参数描述：

q0 = cos(theta/2)

q1 = lambda_x sin(theta/2)

q2 = lambda_y sin(theta/2)

q3 = lambda_z sin(theta/2)

四元数不接受旋转顺序。

参数：

name : 字符串

新坐标系的名称

q0, q1, q2, q3 : 表达式

用于旋转坐标系的四元数

location : 矢量（可选）

新坐标系的原点位置相对于该系统的原点。如果未指定，则认为原点重合。

vector_names, variable_names : 可迭代对象（可选）

每个具有新系统的基向量和基标量的自定义名称的 3 个字符串的可迭代。用于简单的字符串打印。

示例

>>> from sympy.vector import CoordSys3D
>>> from sympy import symbols
>>> q0, q1, q2, q3 = symbols('q0 q1 q2 q3')
>>> N = CoordSys3D('N')
>>> B = N.orient_new_quaternion('B', q0, q1, q2, q3)

orient_new_space(name, angle1, angle2, angle3, rotation_order, location=None, vector_names=None, variable_names=None)

空间旋转类似于体旋转，但是旋转顺序相反。

参数：

name：字符串

新坐标系的名称

angle1, angle2, angle3：Expr

用于旋转坐标系的三个连续角度

rotation_order：字符串

定义旋转轴顺序的字符串

location：向量（可选）

新坐标系原点的位置相对于此系统原点的位置。如果未指定，则假定原点重合。

vector_names, variable_names：可迭代（可选）

每个具有新系统的基向量和基标量的自定义名称的 3 个字符串的可迭代。用于简单的字符串打印。

示例

>>> from sympy.vector import CoordSys3D
>>> from sympy import symbols
>>> q1, q2, q3 = symbols('q1 q2 q3')
>>> N = CoordSys3D('N')

要将坐标系 D 定向到 N，每个顺序旋转始终围绕 N 的正交单位向量进行。例如，'123'旋转将指定围绕 N.i，然后 N.j，然后 N.k 的旋转。因此，

>>> D = N.orient_new_space('D', q1, q2, q3, '312')

与...相同

>>> B = N.orient_new_axis('B', q1, N.i)
>>> C = B.orient_new_axis('C', q2, N.j)
>>> D = C.orient_new_axis('D', q3, N.k)

另请参阅

CoordSys3D.orient_new_body

通过欧拉角定向的方法

position_wrt(other)

返回此坐标系的原点位置向量与另一个点/CoordSys3D 的原点的位置向量之间的位置向量。

参数：

other：点/CoordSys3D

如果 other 是一个点，则返回此系统原点相对于其的位置。如果其是 CoordSyRect 的实例，则返回相对于其原点的位置。

示例

>>> from sympy.vector import CoordSys3D
>>> N = CoordSys3D('N')
>>> N1 = N.locate_new('N1', 10 * N.i)
>>> N.position_wrt(N1)
(-10)*N.i

rotation_matrix(other)

返回此坐标系与另一个系统之间的方向余弦矩阵（DCM），也称为‘旋转矩阵’。

如果 v_a 是在系统‘A’中定义的向量（以矩阵格式），v_b 是在系统‘B’中定义的相同向量，则 v_a = A.rotation_matrix(B) * v_b。

返回一个 SymPy 矩阵。

参数：

other：CoordSys3D

生成 DCM 的系统。

示例

>>> from sympy.vector import CoordSys3D
>>> from sympy import symbols
>>> q1 = symbols('q1')
>>> N = CoordSys3D('N')
>>> A = N.orient_new_axis('A', q1, N.i)
>>> N.rotation_matrix(A)
Matrix([
[1,       0,        0],
[0, cos(q1), -sin(q1)],
[0, sin(q1),  cos(q1)]])

scalar_map(other)

返回一个表达此框架的坐标变量（基标量）与 otherframe 的变量相关的字典。

参数：

otherframe：CoordSys3D

映射变量到其他系统。

示例

>>> from sympy.vector import CoordSys3D
>>> from sympy import Symbol
>>> A = CoordSys3D('A')
>>> q = Symbol('q')
>>> B = A.orient_new_axis('B', q, A.k)
>>> A.scalar_map(B)
{A.x: B.x*cos(q) - B.y*sin(q), A.y: B.x*sin(q) + B.y*cos(q), A.z: B.z}

class sympy.vector.vector.Vector(*args)

所有向量类的超类。理想情况下，用户不应该实例化此类或其任何子类。

property components

返回此向量的分量，以 Python 字典形式将 BaseVector 实例映射到相应的测量数。

示例

>>> from sympy.vector import CoordSys3D
>>> C = CoordSys3D('C')
>>> v = 3*C.i + 4*C.j + 5*C.k
>>> v.components
{C.i: 3, C.j: 4, C.k: 5}

cross(other)

返回此向量与另一个向量或二重实例的叉积。如果‘other’是向量，则叉积是一个向量。如果‘other’是二重，这将返回一个二重实例。

参数：

other：向量/二重

我们正在交叉的向量或二重的。

示例

>>> from sympy.vector import CoordSys3D
>>> C = CoordSys3D('C')
>>> C.i.cross(C.j)
C.k
>>> C.i ^ C.i
0
>>> v = 3*C.i + 4*C.j + 5*C.k
>>> v ^ C.i
5*C.j + (-4)*C.k
>>> d = C.i.outer(C.i)
>>> C.j.cross(d)
(-1)*(C.k|C.i)

dot(other)

返回此向量与另一个向量、二阶张量或梯度算子的点积。如果‘other’是一个向量，则返回点积标量（SymPy 表达式）。如果‘other’是一个二阶张量，则返回点积作为一个向量。如果‘other’是 Del 的实例，则返回 Python 函数形式的方向导数算子。如果将此函数应用于标量表达式，则返回标量场相对于此向量的方向导数。

参数：

other: 向量/二阶张量/梯度算子

我们正在与之点乘的向量或二阶张量，或者是一个梯度算子。

示例

>>> from sympy.vector import CoordSys3D, Del
>>> C = CoordSys3D('C')
>>> delop = Del()
>>> C.i.dot(C.j)
0
>>> C.i & C.i
1
>>> v = 3*C.i + 4*C.j + 5*C.k
>>> v.dot(C.k)
5
>>> (C.i & delop)(C.x*C.y*C.z)
C.y*C.z
>>> d = C.i.outer(C.i)
>>> C.i.dot(d)
C.i

magnitude()

返回此向量的大小。

normalize()

返回此向量的归一化版本。

outer(other)

返回此向量与另一个向量的外积，以一个二阶张量实例的形式。

参数：

other : 向量

与之进行外积计算的向量。

示例

>>> from sympy.vector import CoordSys3D
>>> N = CoordSys3D('N')
>>> N.i.outer(N.j)
(N.i|N.j)

projection(other, scalar=False)

返回‘self’上‘other’的向量或标量投影。

示例

>>> from sympy.vector.coordsysrect import CoordSys3D
>>> C = CoordSys3D('C')
>>> i, j, k = C.base_vectors()
>>> v1 = i + j + k
>>> v2 = 3*i + 4*j
>>> v1.projection(v2)
7/3*C.i + 7/3*C.j + 7/3*C.k
>>> v1.projection(v2, scalar=True)
7/3

separate()

这个向量在不同坐标系中的成分，根据其定义。

返回一个字典，将每个 CoordSys3D 映射到相应的成分向量。

示例

>>> from sympy.vector import CoordSys3D
>>> R1 = CoordSys3D('R1')
>>> R2 = CoordSys3D('R2')
>>> v = R1.i + R2.i
>>> v.separate() == {R1: R1.i, R2: R2.i}
True

to_matrix(system)

返回此向量相对于指定坐标系的矩阵形式。

参数：

system : 三维坐标系

计算矩阵形式的系统

示例

>>> from sympy.vector import CoordSys3D
>>> C = CoordSys3D('C')
>>> from sympy.abc import a, b, c
>>> v = a*C.i + b*C.j + c*C.k
>>> v.to_matrix(C)
Matrix([
[a],
[b],
[c]])

class sympy.vector.dyadic.Dyadic(*args)

所有二阶张量类的超类。

参考文献

[R1074]

zh.wikipedia.org/wiki/二阶张量

[R1075]

Kane, T., Levinson, D. 动力学理论与应用. 1985 McGraw-Hill

property components

返回此二阶张量的分量，以 Python 字典形式映射 BaseDyadic 实例到相应的测量数。

cross(other)

返回此二阶张量与一个向量的叉乘，作为一个向量实例。

参数：

other : 向量

我们正在与此二阶张量进行叉乘的向量。

示例

>>> from sympy.vector import CoordSys3D
>>> N = CoordSys3D('N')
>>> d = N.i.outer(N.i)
>>> d.cross(N.j)
(N.i|N.k)

dot(other)

返回此二阶张量与另一个二阶张量或向量的点积（也称为内积）。如果‘other’是一个二阶张量，则返回一个二阶张量。否则，返回一个向量（除非出现错误）。

参数：

other : 二阶张量/向量

与之进行内积运算的其他二阶张量或向量

示例

>>> from sympy.vector import CoordSys3D
>>> N = CoordSys3D('N')
>>> D1 = N.i.outer(N.j)
>>> D2 = N.j.outer(N.j)
>>> D1.dot(D2)
(N.i|N.j)
>>> D1.dot(N.j)
N.i

to_matrix(system, second_system=None)

返回与一个或两个坐标系相关的二阶张量的矩阵形式。

参数：

system : 三维坐标系

矩阵的行和列对应的坐标系。如果提供第二个系统，则仅对应矩阵的行。

second_system : 三维坐标系，可选，默认为 None

矩阵列对应的坐标系。

示例

>>> from sympy.vector import CoordSys3D
>>> N = CoordSys3D('N')
>>> v = N.i + 2*N.j
>>> d = v.outer(N.i)
>>> d.to_matrix(N)
Matrix([
[1, 0, 0],
[2, 0, 0],
[0, 0, 0]])
>>> from sympy import Symbol
>>> q = Symbol('q')
>>> P = N.orient_new_axis('P', q, N.k)
>>> d.to_matrix(N, P)
Matrix([
[  cos(q),   -sin(q), 0],
[2*cos(q), -2*sin(q), 0],
[       0,         0, 0]])

class sympy.vector.deloperator.Del

表示向量微分算子，通常在数学表达式中表示为‘nabla’符号。

cross(vect, doit=False)

表示此算子与给定向量的叉乘 - 等同于向量场的旋度。

参数：

vect : 向量

要计算其旋度的向量。

doit : 布尔值

如果为 True，则在调用每个分量的.doit()后返回结果。否则，返回的表达式包含 Derivative 实例。

示例

>>> from sympy.vector import CoordSys3D, Del
>>> C = CoordSys3D('C')
>>> delop = Del()
>>> v = C.x*C.y*C.z * (C.i + C.j + C.k)
>>> delop.cross(v, doit = True)
(-C.x*C.y + C.x*C.z)*C.i + (C.x*C.y - C.y*C.z)*C.j +
 (-C.x*C.z + C.y*C.z)*C.k
>>> (delop ^ C.i).doit()
0

dot(vect, doit=False)

表示该运算符与给定向量的点积，等于向量场的散度。

参数：

vect : 向量

要计算其散度的向量。

doit : bool

如果为 True，则在调用每个分量的.doit()后返回结果。否则，返回的表达式包含 Derivative 实例。

示例

>>> from sympy.vector import CoordSys3D, Del
>>> delop = Del()
>>> C = CoordSys3D('C')
>>> delop.dot(C.x*C.i)
Derivative(C.x, C.x)
>>> v = C.x*C.y*C.z * (C.i + C.j + C.k)
>>> (delop & v).doit()
C.x*C.y + C.x*C.z + C.y*C.z

gradient(scalar_field, doit=False)

返回给定标量场的梯度，作为 Vector 实例。

参数：

scalar_field : SymPy 表达式

要计算其梯度的标量场。

doit : bool

如果为 True，则在调用每个分量的.doit()后返回结果。否则，返回的表达式包含 Derivative 实例。

示例

>>> from sympy.vector import CoordSys3D, Del
>>> C = CoordSys3D('C')
>>> delop = Del()
>>> delop.gradient(9)
0
>>> 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

class sympy.vector.parametricregion.ParametricRegion(definition, *bounds)

表示空间中的参数区域。

参数：

definition : 用于根据参数定义基础标量的元组。

bounds : 用于定义参数及其相应下限和上限的参数或长度为 3 的元组。

示例

>>> from sympy import cos, sin, pi
>>> from sympy.abc import r, theta, t, a, b, x, y
>>> from sympy.vector import ParametricRegion

>>> ParametricRegion((t, t**2), (t, -1, 2))
ParametricRegion((t, t**2), (t, -1, 2))
>>> ParametricRegion((x, y), (x, 3, 4), (y, 5, 6))
ParametricRegion((x, y), (x, 3, 4), (y, 5, 6))
>>> ParametricRegion((r*cos(theta), r*sin(theta)), (r, -2, 2), (theta, 0, pi))
ParametricRegion((r*cos(theta), r*sin(theta)), (r, -2, 2), (theta, 0, pi))
>>> ParametricRegion((a*cos(t), b*sin(t)), t)
ParametricRegion((a*cos(t), b*sin(t)), t)

>>> circle = ParametricRegion((r*cos(theta), r*sin(theta)), r, (theta, 0, pi))
>>> circle.parameters
(r, theta)
>>> circle.definition
(r*cos(theta), r*sin(theta))
>>> circle.limits
{theta: (0, pi)}

参数化区域的维数确定区域是曲线、曲面还是体积区域。它不表示空间中的维数。

>>> circle.dimensions
1

class sympy.vector.implicitregion.ImplicitRegion(variables, equation)

表示空间中的隐式区域。

参数：

variables : 用于将隐式方程中的变量映射到基础标量的元组。

equation : 表示区域隐式方程的表达式或等式。

示例

>>> from sympy import Eq
>>> from sympy.abc import x, y, z, t
>>> from sympy.vector import ImplicitRegion

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

>>> parabola = ImplicitRegion((x, y), y**2 - 4*x)
>>> parabola.degree
2
>>> parabola.equation
-4*x + y**2
>>> parabola.rational_parametrization(t)
(4/t**2, 4/t)

>>> r = ImplicitRegion((x, y, z), Eq(z, x**2 + y**2))
>>> r.variables
(x, y, z)
>>> r.singular_points()
EmptySet
>>> r.regular_point()
(-10, -10, 200)

multiplicity(point)

返回区域上奇点的多重性。

区域的奇点(x,y)如果所有 m-1 阶偏导数在此处为零，则称其为多重性 m。

示例

>>> from sympy.abc import x, y, z
>>> from sympy.vector import ImplicitRegion
>>> I = ImplicitRegion((x, y, z), x**2 + y**3 - z**4)
>>> I.singular_points()
{(0, 0, 0)}
>>> I.multiplicity((0, 0, 0))
2

rational_parametrization(parameters=('t', 's'), reg_point=None)

返回隐式区域的有理参数化。

示例

>>> from sympy import Eq
>>> from sympy.abc import x, y, z, s, t
>>> from sympy.vector import ImplicitRegion

>>> parabola = ImplicitRegion((x, y), y**2 - 4*x)
>>> parabola.rational_parametrization()
(4/t**2, 4/t)

>>> circle = ImplicitRegion((x, y), Eq(x**2 + y**2, 4))
>>> circle.rational_parametrization()
(4*t/(t**2 + 1), 4*t**2/(t**2 + 1) - 2)

>>> I = ImplicitRegion((x, y), x**3 + x**2 - y**2)
>>> I.rational_parametrization()
(t**2 - 1, t*(t**2 - 1))

>>> cubic_curve = ImplicitRegion((x, y), x**3 + x**2 - y**2)
>>> cubic_curve.rational_parametrization(parameters=(t))
(t**2 - 1, t*(t**2 - 1))

>>> sphere = ImplicitRegion((x, y, z), x**2 + y**2 + z**2 - 4)
>>> sphere.rational_parametrization(parameters=(t, s))
(-2 + 4/(s**2 + t**2 + 1), 4*s/(s**2 + t**2 + 1), 4*t/(s**2 + t**2 + 1))

对于某些圆锥曲线，regular_points()无法找到曲线上的点。在这种情况下，用户需要确定区域上的一个点，并使用 reg_point 传递它以计算参数化表示。

>>> c = ImplicitRegion((x, y), (x  - 1/2)**2 + (y)**2 - (1/4)**2)
>>> c.rational_parametrization(reg_point=(3/4, 0))
(0.75 - 0.5/(t**2 + 1), -0.5*t/(t**2 + 1))

参考文献

Christoph M. Hoffmann，“参数曲线和曲面之间的转换方法”，普渡大学 e-Pubs，1990 年。可查看：docs.lib.purdue.edu/cgi/viewcontent.cgi?article=1827&context=cstech

regular_point()

返回隐式区域上的一个点。

示例

>>> from sympy.abc import x, y, z
>>> from sympy.vector import ImplicitRegion
>>> circle = ImplicitRegion((x, y), (x + 2)**2 + (y - 3)**2 - 16)
>>> circle.regular_point()
(-2, -1)
>>> parabola = ImplicitRegion((x, y), x**2 - 4*y)
>>> parabola.regular_point()
(0, 0)
>>> r = ImplicitRegion((x, y, z), (x + y + z)**4)
>>> r.regular_point()
(-10, -10, 20)

参考文献

Erik Hillgarter，“圆锥曲线上的有理点”，学位论文，RISC-Linz，约翰·开普勒林茨大学，1996 年。可查看：www3.risc.jku.at/publications/download/risc_1355/Rational%20Points%20on%20Conics.pdf

singular_points()

返回区域的奇点集合。

区域上的奇点是区域上所有偏导数均为零的点。

示例

>>> from sympy.abc import x, y
>>> from sympy.vector import ImplicitRegion
>>> I = ImplicitRegion((x, y), (y-1)**2 -x**3 + 2*x**2 -x)
>>> I.singular_points()
{(1, 1)}

class sympy.vector.integrals.ParametricIntegral(field, parametricregion)

表示标量或矢量场在参数区域上的积分。

示例

>>> from sympy import cos, sin, pi
>>> from sympy.vector import CoordSys3D, ParametricRegion, ParametricIntegral
>>> from sympy.abc import r, t, theta, phi

>>> C = CoordSys3D('C')
>>> curve = ParametricRegion((3*t - 2, t + 1), (t, 1, 2))
>>> ParametricIntegral(C.x, curve)
5*sqrt(10)/2
>>> length = ParametricIntegral(1, curve)
>>> length
sqrt(10)
>>> semisphere = ParametricRegion((2*sin(phi)*cos(theta), 2*sin(phi)*sin(theta), 2*cos(phi)),                            (theta, 0, 2*pi), (phi, 0, pi/2))
>>> ParametricIntegral(C.z, semisphere)
8*pi

>>> ParametricIntegral(C.j + C.k, ParametricRegion((r*cos(theta), r*sin(theta)), r, theta))
0

定向器类（文档字符串）

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

class sympy.vector.orienters.Orienter(*args)

所有定向器类的超类。

rotation_matrix()

与此定向器实例对应的旋转矩阵。

class sympy.vector.orienters.AxisOrienter(angle, axis)

表示轴定向器的类。

__init__(angle, axis)

轴旋转是围绕任意轴的旋转，角度由 SymPy 表达式标量提供，轴由向量提供。

参数：

角度：Expr

用于旋转顺序的角度

轴：向量

需要执行旋转的轴

示例

>>> from sympy.vector import CoordSys3D
>>> from sympy import symbols
>>> q1 = symbols('q1')
>>> N = CoordSys3D('N')
>>> from sympy.vector import AxisOrienter
>>> orienter = AxisOrienter(q1, N.i + 2 * N.j)
>>> B = N.orient_new('B', (orienter, ))

rotation_matrix(system)

与此定向器实例对应的旋转矩阵。

参数：

系统：CoordSys3D

计算旋转矩阵的坐标系

class sympy.vector.orienters.BodyOrienter(angle1, angle2, angle3, rot_order)

表示体定向器的类。

__init__(angle1, angle2, angle3, rot_order)

体定向将此坐标系通过三个连续的简单旋转。

'Body'固定旋转包括欧拉角和泰特-布莱恩角，参见en.wikipedia.org/wiki/Euler_angles。

参数：

角度 1，角度 2，角度 3：Expr

三个连续角度来旋转坐标系

旋转顺序：字符串

定义旋转轴顺序的字符串

示例

>>> from sympy.vector import CoordSys3D, BodyOrienter
>>> from sympy import symbols
>>> q1, q2, q3 = symbols('q1 q2 q3')
>>> N = CoordSys3D('N')

'Body'固定旋转由三个角度和三个固定于 D 的体旋转轴描述。为了将坐标系 D 定向到 N，每次连续旋转都是关于固定于 D 的正交单位向量。例如，'123'旋转将指定关于 N.i、然后 D.j、然后 D.k 的旋转。（最初，D.i 与 N.i 相同）因此，

>>> body_orienter = BodyOrienter(q1, q2, q3, '123')
>>> D = N.orient_new('D', (body_orienter, ))

同上

>>> from sympy.vector import AxisOrienter
>>> axis_orienter1 = AxisOrienter(q1, N.i)
>>> D = N.orient_new('D', (axis_orienter1, ))
>>> axis_orienter2 = AxisOrienter(q2, D.j)
>>> D = D.orient_new('D', (axis_orienter2, ))
>>> axis_orienter3 = AxisOrienter(q3, D.k)
>>> D = D.orient_new('D', (axis_orienter3, ))

可接受的旋转顺序长度为 3，表示为 XYZ 或 123，并且不能连续两次围绕同一轴旋转。

>>> body_orienter1 = BodyOrienter(q1, q2, q3, '123')
>>> body_orienter2 = BodyOrienter(q1, q2, 0, 'ZXZ')
>>> body_orienter3 = BodyOrienter(0, 0, 0, 'XYX')

class sympy.vector.orienters.SpaceOrienter(angle1, angle2, angle3, rot_order)

表示空间定向器的类。

__init__(angle1, angle2, angle3, rot_order)

空间旋转类似于体旋转，但是旋转的顺序相反。

参数：

角度 1，角度 2，角度 3：Expr

三个连续角度来旋转坐标系

旋转顺序：字符串

定义旋转轴顺序的字符串

示例

>>> from sympy.vector import CoordSys3D, SpaceOrienter
>>> from sympy import symbols
>>> q1, q2, q3 = symbols('q1 q2 q3')
>>> N = CoordSys3D('N')

为了将坐标系 D 定向到 N，每次连续旋转都是关于 N 的正交单位向量。例如，'123'旋转将指定关于 N.i、然后 N.j、然后 N.k 的旋转。因此，

>>> space_orienter = SpaceOrienter(q1, q2, q3, '312')
>>> D = N.orient_new('D', (space_orienter, ))

同上

>>> from sympy.vector import AxisOrienter
>>> axis_orienter1 = AxisOrienter(q1, N.i)
>>> B = N.orient_new('B', (axis_orienter1, ))
>>> axis_orienter2 = AxisOrienter(q2, N.j)
>>> C = B.orient_new('C', (axis_orienter2, ))
>>> axis_orienter3 = AxisOrienter(q3, N.k)
>>> D = C.orient_new('C', (axis_orienter3, ))

另请参阅

BodyOrienter

相对于欧拉角定向系统的定向器。

class sympy.vector.orienters.QuaternionOrienter(q0, q1, q2, q3)

表示四元数定向器的类。

__init__(angle1, angle2, angle3, rot_order)

四元数定向使用四元数将新的 CoordSys3D 定向，定义为围绕单位向量 lambda 的有限旋转，旋转量为 theta。

这个方向由四个参数描述：

q0 = cos(theta/2)

q1 = lambda_x sin(theta/2)

q2 = lambda_y sin(theta/2)

q3 = lambda_z sin(theta/2)

四元数不接受旋转顺序。

参数：

q0, q1, q2, q3：Expr

用于旋转坐标系的四元数

示例

>>> from sympy.vector import CoordSys3D
>>> from sympy import symbols
>>> q0, q1, q2, q3 = symbols('q0 q1 q2 q3')
>>> N = CoordSys3D('N')
>>> from sympy.vector import QuaternionOrienter
>>> q_orienter = QuaternionOrienter(q0, q1, q2, q3)
>>> B = N.orient_new('B', (q_orienter, ))

SymPy-1-13-中文文档-二十七-

SymPy 1.13 中文文档（二十七）

更多关于坐标系的内容

定位新系统

初始化新系统

直接使用 CoordSys3D 方法

使用Orienter和orient_new方法

定位和定向新系统

转换新系统

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

向量和二元向量

坐标变量

其他依赖表达式的方法

标量和向量场功能

在 sympy.vector 中的实现

标量和向量场

Del 算子

场算子和相关函数

旋度

散度

梯度

方向导数

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

保守场与无旋场

标量势函数

使用范例

四边形问题

问题

解决方案

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

看见

问题

解决方案

矢量积分的应用

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

物体质量的计算

通量的计算

验证斯托克斯定理

验证散度定理

向量 API

sympy.vector 中的基本类（文档字符串）

定向器类（文档字符串）

使用`Orienter`和`orient_new`方法