基本课程同向矢量（文档字符串）#

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 ：结构

新CoordSys3D实例的名称。

转型：Lambda，元组，str

由变换方程定义的变换或从预定义的变换方程中选择的变换。

位置：矢量

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

rotation_matrix ：SymPy不可变矩阵

新坐标系相对于父坐标系的旋转矩阵。换句话说，新的_系统旋转矩阵（母公司）。

起源：CoordSys3D

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

vector_names, variable_names ：iterable（可选）

它由3个字符串组成，分别为新系统的基向量和基标量提供自定义名称。用于简单的str打印。

create_new(name, transformation, variable_names=None, vector_names=None)[源代码]#

返回通过转换连接到self的CoordSys3D。

参数:

name ：结构

新CoordSys3D实例的名称。

转型：Lambda，元组，str

由变换方程定义的变换或从预定义的变换方程中选择的变换。

vector_names, variable_names ：iterable（可选）

它由3个字符串组成，分别为新系统的基向量和基标量提供自定义名称。用于简单的str打印。

实例

>>> 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 ：结构

新CoordSys3D实例的名称。

位置：矢量

新系统原点的位置矢量与这个坐标系一致。

vector_names, variable_names ：iterable（可选）

它由3个字符串组成，分别为新系统的基向量和基标量提供自定义名称。用于简单的str打印。

实例

>>> 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，该CoordSys3D以用户指定的方式指向该系统。

有关定向程序的更多信息，请参阅orienter类的文档。

参数:

name ：结构

新CoordSys3D实例的名称。

定向仪 ：i可缩放/定向

定向器一个或多个定向器，用于确定新坐标系的方向。如果提供了定向器，则应用它来获取新系统。如果提供了iterable，则将按照它们在iterable中出现的顺序应用orienter。

位置：Vector（可选）

新坐标系原点的位置与此坐标系的原点相对应。如果未指定，原点将被视为重合。

vector_names, variable_names ：iterable（可选）

它由3个字符串组成，分别为新系统的基向量和基标量提供自定义名称。用于简单的str打印。

实例

>>> 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 AxisOrienter
>>> axis_orienter = AxisOrienter(q1, N.i + 2 * N.j)
>>> A = N.orient_new('A', (axis_orienter, ))

使用车身定位仪

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

使用空间定向仪

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

使用四元数方向器

>>> 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 expr标量提供，轴作为向量提供。

参数:

name ：字符串

新坐标系的名称

角：表达式

新系统旋转的角度

axis ：矢量

必须绕其旋转的轴

位置：Vector（可选）

新坐标系原点的位置与此坐标系的原点相对应。如果未指定，原点将被视为重合。

vector_names, variable_names ：iterable（可选）

它由3个字符串组成，分别为新系统的基向量和基标量提供自定义名称。用于简单的str打印。

实例

>>> 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)[源代码]#

身体方向通过三个连续的简单旋转来获得这个坐标系。

身体固定旋转包括欧拉角和泰特布莱恩角，请参见https://en.wikipedia.org/wiki/Euler_角度。

参数:

name ：字符串

新坐标系的名称

角度1，角度2，角度3 ：表达式

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

rotation_order ：字符串

定义旋转轴顺序的字符串

位置：Vector（可选）

新坐标系原点的位置与此坐标系的原点相对应。如果未指定，原点将被视为重合。

vector_names, variable_names ：iterable（可选）

它由3个字符串组成，分别为新系统的基向量和基标量提供自定义名称。用于简单的str打印。

实例

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

“物体”的固定旋转由三个角度和三个物体固定旋转轴来描述。为了确定坐标系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的有限旋转，以一定量θ。

此方向由四个参数描述：

q0=cos（θ/2）

q1=λx sin（θ/2）

q2=λy sin（θ/2）

q3=λz sin（θ/2）

四元数不接受旋转顺序。

参数:

name ：字符串

新坐标系的名称

问题0、问题1、问题2、问题3 ：表达式

要旋转坐标系的四元数

位置：Vector（可选）

新坐标系原点的位置与此坐标系的原点相对应。如果未指定，原点将被视为重合。

vector_names, variable_names ：iterable（可选）

它由3个字符串组成，分别为新系统的基向量和基标量提供自定义名称。用于简单的str打印。

实例

>>> 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 ：字符串

新坐标系的名称

角度1，角度2，角度3 ：表达式

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

rotation_order ：字符串

定义旋转轴顺序的字符串

位置：Vector（可选）

新坐标系原点的位置与此坐标系的原点相对应。如果未指定，原点将被视为重合。

vector_names, variable_names ：iterable（可选）

它由3个字符串组成，分别为新系统的基向量和基标量提供自定义名称。用于简单的str打印。

实例

>>> 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)[源代码]#

返回此坐标系原点相对于另一个点/坐标sys3d的位置矢量。

参数:: 其他：点/CoordSys3D

如果另一个点是一个点，则返回该系统原点的位置。如果它是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.旋转_矩阵（b）*v_b。

返回一个SymPy矩阵。

参数:: 其他：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的变量表示此帧的坐标变量（基标量）。

参数:: 其他帧 ：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: Vector/Dyadic

我们要穿越的向量或并矢。

实例

>>> 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)[源代码]#

Returns the dot product of this Vector, either with another Vector, or a Dyadic, or a Del operator. If 'other' is a Vector, returns the dot product scalar (SymPy expression). If 'other' is a Dyadic, the dot product is returned as a Vector. If 'other' is an instance of Del, returns the directional derivative operator as a Python function. If this function is applied to a scalar expression, it returns the directional derivative of the scalar field wrt this Vector.

参数:: other: Vector/Dyadic/Del

我们使用的向量或并矢，或者Del运算符。

实例

>>> 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)[源代码]#

以并元实例的形式返回此向量与另一个向量的外积。

参数:: 其他：矢量

要计算外积的向量。

实例

>>> 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映射到相应的组成向量的dict。

实例

>>> 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)[源代码]#

返回这个坐标系的矩阵。

参数:: 系统：CoordSys3D

要计算矩阵形式的系统

实例

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

https://en.wikipedia.org/wiki/Dyadic_tensor

[R1075]

Kane，T.，Levinson，D.动力学理论与应用。1985年麦格劳希尔

property components#: 以Python字典的形式返回此并元的组件，将BaseDyadic实例映射到相应的度量值号。

cross(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”是并矢，则返回并矢。否则，它返回一个向量（除非遇到错误）。

参数:: 其他：并矢/矢量

取内积的另一个并矢或向量

实例

>>> 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)[源代码]#

返回关于一个或两个坐标系的并矢矩阵形式。

参数:

系统：CoordSys3D

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

second_system ：CoordSys3D，可选，默认值=无

对应于该坐标系的矩阵。

实例

>>> 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（）之后返回结果。否则，返回的表达式包含派生实例

实例

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

如果为True，则在对每个组件调用.doit（）之后返回结果。否则，返回的表达式包含派生实例

实例

>>> 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)[源代码]#

返回给定标量字段的渐变，作为向量实例。

参数:

scalar_field ：SymPy表达式

要计算其梯度的标量字段。

doit 布尔

如果为True，则在对每个组件调用.doit（）之后返回结果。否则，返回的表达式包含派生实例

实例

>>> 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)[源代码]#

表示空间中的参数化区域。

参数:

定义：tuple根据参数定义基本标量。

界限：参数或长度为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)[源代码]#

表示空间中的隐式区域。

参数:

变量：元组将隐式表达式中的变量映射到基标量。

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

实例

>>> 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)[源代码]#

返回区域上奇点的重数。

如果所有到m-1阶的偏导数都在那里消失，则区域的一个奇点（x，y）称为重数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)[源代码]#

Returns the rational parametrization of implicit region.

实例

>>> 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，“参数曲线和隐式曲线曲面之间的转换方法”，Purdue e-Pubs，1990年。可用：https://docs.lib.purdue.edu/cgi/viewcontent.cgi？文章=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, "Rational Points on Conics", Diploma Thesis, RISC-Linz, J. Kepler Universitat Linz, 1996. Available: https://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