基本类¶

class sympy.physics.vector.frame.CoordinateSym(name, frame, index)[源代码][源代码]¶

与参考系相关的坐标符号/基标量。

理想情况下，用户不应实例化此类。此类实例只能通过相应的帧访问，如 ‘frame[index]’。

具有相同框架和索引参数的 CoordinateSyms 是相等的（即使它们可能是单独实例化的）。

参数:

名称字符串: CoordinateSym 的显示名称
框架参考框架: 这个基本标量所属的参考系
索引0, 1 或 2: 此坐标变量所表示的维度的索引

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
binary_symbols: 从自身的原子中返回那些自由符号。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_free_symbols: 类似于 free_symbols，但仅在自由符号包含在表达式节点中时返回它们。
框架
free_symbols: 从自身的原子中返回那些自由符号。
func: 表达式中的顶级函数。
is_algebraic
is_antihermitian
is_commutative
is_complex
is_composite
is_even
is_extended_negative
is_extended_nonnegative
is_extended_nonpositive
is_extended_nonzero
is_extended_positive
is_extended_real
is_finite
is_hermitian
is_imaginary
is_infinite
is_integer
is_irrational
is_negative
is_noninteger
is_nonnegative
is_nonpositive
is_nonzero
is_odd
is_polar
is_positive
is_prime
is_rational
is_real
is_transcendental
is_zero
种类
名称

方法

`apart`([x])	请参阅 sympy.polys 中的 apart 函数。
`args_cnc`([cset, warn, split_1])	返回 [交换因子, 非交换因子] 的自身。
`as_coeff_Add`([rational])	高效地提取求和的系数。
`as_coeff_Mul`([rational])	高效地提取乘积的系数。
`as_coeff_add`(*deps)	返回元组 (c, args)，其中 self 被写成一个 Add，`a`。
`as_coeff_exponent`(x)	`cx*e -> c,e` 其中 x 可以是任何符号表达式。
`as_coeff_mul`(deps, *kwargs)	返回元组 (c, args)，其中 self 被写成一个 Mul，`m`。
`as_coefficient`(expr)	提取给定表达式中的符号系数。
`as_coefficients_dict`(*syms)	返回一个字典，将术语映射到它们的 Rational 系数。
`as_content_primitive`([radical, clear])	此方法应递归地从所有参数中移除一个 Rational，并返回该内容和新的 self（原始类型）。
`as_dummy`()
`as_expr`(*gens)	将多项式转换为 SymPy 表达式。
`as_independent`(deps, *hint)	将 Mul 或 Add 的大部分天真分离为不依赖于 deps 的参数。
`as_leading_term`(*symbols[, logx, cdir])	返回自身级数展开的主导（非零）项。
`as_numer_denom`()	返回一个表达式的分子和分母。
`as_ordered_factors`([order])	返回有序因子列表（如果是 Mul），否则返回 [self]。
`as_ordered_terms`([order, data])	将表达式转换为有序的项列表。
`as_poly`(gens, *args)	将 `self` 转换为多项式，或返回 `None`。
`as_powers_dict`()	将自身作为一个因子的字典返回，每个因子都被视为一个幂。
`as_real_imag`([deep])
`as_set`()
`as_terms`()	将一个表达式转换为项的列表。
`aseries`([x, n, bound, hir])	自变量的渐近级数展开
`atoms`(*types)	返回构成当前对象的原子。
`cancel`(gens, *args)	参见 sympy.polys 中的取消函数
`class_key`()
`coeff`(x[, n, right, _first])	返回包含 `x**n` 的项中的系数。
`collect`(syms[, func, evaluate, exact, ...])	请参阅 sympy.simplify 中的 collect 函数。
`combsimp`()	请参阅 sympy.simplify 中的 combsimp 函数。
`compare`(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
`compute_leading_term`(x[, logx])	已弃用的函数，用于计算级数的首项。
`conjugate`()	返回 'self' 的复数共轭。
`could_extract_minus_sign`()	如果 self 以 -1 作为前导因子，或在求和中有比正号更多的负号，则返回 True，否则返回 False。
`count`(query)	计算匹配的子表达式的数量。
`count_ops`([visual])
`doit`(**hints)
`dummy_eq`(other[, symbol])	比较两个表达式并处理哑符号。
`equals`(other[, failing_expression])	如果 self == other 则返回 True，如果不相等则返回 False，或者返回 None。
`evalf`([n, subs, maxn, chop, strict, quad, ...])	将给定的公式计算到 n 位精度。
`expand`([deep, modulus, power_base, ...])	使用提示扩展表达式。
`extract_additively`(c)	如果可以从自身减去 c 并且使所有匹配的系数趋向于零，则返回 self - c，否则返回 None。
`extract_branch_factor`([allow_half])	尝试以 `exp_polar(2piIn)z` 的方式优雅地表达自身。
`extract_multiplicatively`(c)	如果无法以一种良好的方式将 self 表示为 c * something，即保留 self 参数的属性，则返回 None。
`factor`(gens, *args)	参见 sympy.polys.polytools 中的 factor() 函数
`find`(query[, group])	查找所有匹配查询的子表达式。
`fourier_series`([limits])	计算自身的傅里叶正弦/余弦级数。
`fps`([x, x0, dir, hyper, order, rational, full])	计算自身的形式幂级数。
`fromiter`(args, **assumptions)	从可迭代对象创建一个新对象。
`gammasimp`()	参见 sympy.simplify 中的 gammasimp 函数
`getO`()	如果有加法 O(..) 符号，则返回该符号，否则返回 None。
`getn`()	返回表达式的顺序。
`has`(*patterns)	测试是否有任何子表达式匹配任何模式。
`has_free`(*patterns)	如果 self 包含对象 `x` 作为自由表达式，则返回 True，否则返回 False。
`has_xfree`(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
`integrate`(args, *kwargs)	请参阅 sympy.integrals 中的 integrate 函数。
`invert`(g, gens, *args)	返回 `self` 对 `g` 的乘法逆元，其中 self``（和 ``g）可以是符号表达式。
`is_algebraic_expr`(*syms)	此测试给定的表达式是否在给定的符号 syms 中是代数的。
`is_constant`(wrt, *flags)
`is_meromorphic`(x, a)	此测试表达式是否作为给定符号 `x` 的函数在点 `a` 处是亚纯的。
`is_polynomial`(*syms)	如果 self 是 syms 中的多项式，则返回 True，否则返回 False。
`is_rational_function`(*syms)	测试函数是否是给定符号 syms 中的两个多项式的比率。
`is_same`(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
`leadterm`(x[, logx, cdir])	返回前导项 ax*b 作为元组 (a, b)。
`limit`(x, xlim[, dir])	计算极限 x->xlim。
`lseries`([x, x0, dir, logx, cdir])	用于生成序列项的迭代器的包装器。
`match`(pattern[, old])	模式匹配。
`matches`(expr[, repl_dict, old])
`n`([n, subs, maxn, chop, strict, quad, verbose])	将给定的公式计算到 n 位精度。
`normal`()	返回表达式为分数形式。
`nseries`([x, x0, n, dir, logx, cdir])	如果假设允许，则包装到 _eval_nseries，否则包装到 series。
`nsimplify`([constants, tolerance, full])	参见 sympy.simplify 中的 nsimplify 函数
`powsimp`(args, *kwargs)	请参阅 sympy.simplify 中的 powsimp 函数
`primitive`()	返回可以从自身每个项中非递归提取的正有理数（即，将自身视为一个加法）。
`radsimp`(**kwargs)	参见 sympy.simplify 中的 radsimp 函数
`ratsimp`()	参见 sympy.simplify 中的 ratsimp 函数。
`rcall`(*args)	通过表达式树递归应用于参数。
`refine`([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
`removeO`()	如果存在，移除加性的 O(..) 符号
`replace`(query, value[, map, simultaneous, exact])	将 `self` 中匹配的子表达式替换为 `value`。
`rewrite`(*args[, deep])	使用定义的规则重写 self。
`round`([n])	返回 x 四舍五入到给定的十进制位数。
`separate`([deep, force])	参见 sympy.simplify 中的单独函数
`series`([x, x0, n, dir, logx, cdir])	在 `x = x0` 附近对 "self" 进行级数展开，当 n=None 时逐项给出级数项（即惰性级数），否则当 n != None 时一次性给出所有项。
`simplify`(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
`sort_key`([order])
`subs`(args, *kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
`taylor_term`(n, x, *previous_terms)	泰勒项的一般方法。
`together`(args, *kwargs)	请参阅 sympy.polys 中的 together 函数。
`trigsimp`(**args)	参见 sympy.simplify 中的 trigsimp 函数
`xreplace`(rule[, hack2])

伴随
as_base_exp
复制
差异
目录
is_hypergeometric
to_nnf
转置

示例

>>> from sympy.physics.vector import ReferenceFrame, CoordinateSym
>>> A = ReferenceFrame('A')
>>> A[1]
A_y
>>> type(A[0])
<class 'sympy.physics.vector.frame.CoordinateSym'>
>>> a_y = CoordinateSym('a_y', A, 1)
>>> a_y == A[1]
True

class sympy.physics.vector.frame.ReferenceFrame( name, indices=None, latexs=None, variables=None, )[源代码][源代码]¶

经典力学中的参考系。

ReferenceFrame 是一个用于表示经典力学中参考系的类。它有一个标准基，由参考系 x、y 和 z 方向上的三个单位向量组成。

它也可以相对于父坐标系进行旋转；这种旋转由一个方向余弦矩阵定义，该矩阵将此坐标系的基向量与父坐标系的基向量相关联。它还可以有一个在另一个坐标系中定义的角速度向量。

属性:

u: 参考系的单位并矢。
x: 参考框架在x方向上的基向量。
xx: 参考系中基向量 x 和 x 的单位二元组。
xy: 参考系中基向量 x 和 y 的单位对偶。
xz: 参考框架的基向量 x 和 z 的单位对偶。
y: 参考坐标系在 y 方向上的基向量。
yx: 参考系的基向量 y 和 x 的单位对偶。
yy: 参考系中基向量 y 和 y 的单位二元组。
yz: 参考系中基向量 y 和 z 的单位对偶。
z: 参考坐标系的基向量，在 z 方向上。
zx: 参考系中基向量 z 和 x 的单位对偶。
zy: 参考系中基向量 z 和 y 的单位对偶。
zz: 参考系中基向量 z 和 z 的单位二元组。

方法

`ang_acc_in`(otherframe)	返回参考系的角加速度向量。
`ang_vel_in`(otherframe)	返回 ReferenceFrame 的角速度向量。
`dcm`(otherframe)	返回此参考系相对于所提供参考系的方向余弦矩阵。
`orient`(parent, rot_type, amounts[, rot_order])	设置此参考系相对于另一个（父）参考系的方位。
`orient_axis`(parent, axis, angle)	通过围绕父参考系中固定轴旋转一个角度，设置此参考系相对于父参考系的方位。
`orient_body_fixed`(parent, angles, rotation_order)	通过右手旋转三个连续的固定在物体上的简单轴旋转，相对于父参考系旋转此参考系。
`orient_dcm`(parent, dcm)	使用描述从子参考系到父参考系的旋转的方向余弦矩阵，设置此参考系相对于另一个（父）参考系的方位。
`orient_quaternion`(parent, numbers)	通过方向四元数设置此参考系相对于父参考系的方向。
`orient_space_fixed`(parent, angles, ...)	通过右手旋转，相对于父参考系，依次绕三个固定的简单轴旋转，来旋转此参考系。
`orientnew`(newname, rot_type, amounts[, ...])	返回一个相对于此参考系定向的新参考系。
`partial_velocity`(frame, *gen_speeds)	返回此框架相对于一个或多个提供的广义速度在给定框架中的部分角速度。
`set_ang_acc`(otherframe, value)	在参考系中定义角加速度向量。
`set_ang_vel`(otherframe, value)	在参考系中定义角速度矢量。
`variable_map`(otherframe)	返回一个字典，该字典表示此框架的坐标变量在其他框架变量中的表达。

ang_acc_in(otherframe)[源代码][源代码]¶

返回参考系的角加速度向量。

有效地返回向量：

N_alpha_B

表示 B 在 N 中的角加速度，其中 B 是自身，N 是其他框架。

参数:

其他框架参考框架: 返回角加速度所参考的参考系。

示例

>>> from sympy.physics.vector import ReferenceFrame
>>> N = ReferenceFrame('N')
>>> A = ReferenceFrame('A')
>>> V = 10 * N.x
>>> A.set_ang_acc(N, V)
>>> A.ang_acc_in(N)
10*N.x

ang_vel_in(otherframe)[源代码][源代码]¶

返回 ReferenceFrame 的角速度向量。

有效地返回向量：

^N omega ^B

表示 B 在 N 中的角速度，其中 B 是自身，N 是其他框架。

参数:

其他框架参考框架: 返回角速度所参考的参考系。

示例

>>> from sympy.physics.vector import ReferenceFrame
>>> N = ReferenceFrame('N')
>>> A = ReferenceFrame('A')
>>> V = 10 * N.x
>>> A.set_ang_vel(N, V)
>>> A.ang_vel_in(N)
10*N.x

dcm(otherframe)[源代码][源代码]¶

返回此参考系相对于所提供参考系的方向余弦矩阵。

返回的矩阵可以用来表示这个坐标系的正交单位向量在 otherframe 的正交单位向量中的表达。

参数:

其他框架参考框架: 形成此帧的方向余弦矩阵所参考的参考系。

注释

了解返回的方向余弦矩阵的形式非常重要。如果调用 B.dcm(A)，这意味着“相对于A旋转的B的方向余弦矩阵”。这是以下关系中所示的矩阵 \({}^B\mathbf{C}^A\)：

\[\begin{split}\begin{bmatrix} \hat{\mathbf{b}}_1 \\ \hat{\mathbf{b}}_2 \\ \hat{\mathbf{b}}_3 \end{bmatrix} = {}^B\mathbf{C}^A \begin{bmatrix} \hat{\mathbf{a}}_1 \\ \hat{\mathbf{a}}_2 \\ \hat{\mathbf{a}}_3 \end{bmatrix}.\end{split}\]

\({}^B\mathbf{C}^A\) 是表示 B 单位向量在 A 单位向量中的矩阵。

示例

以下示例通过简单旋转将参考系 A 相对于 N 旋转，然后计算 N 相对于 A 的方向余弦矩阵。

>>> from sympy import symbols, sin, cos
>>> from sympy.physics.vector import ReferenceFrame
>>> q1 = symbols('q1')
>>> N = ReferenceFrame('N')
>>> A = ReferenceFrame('A')
>>> A.orient_axis(N, q1, N.x)
>>> N.dcm(A)
Matrix([
[1,       0,        0],
[0, cos(q1), -sin(q1)],
[0, sin(q1),  cos(q1)]])

上述方向余弦矩阵的第二行表示在A中表达的``N.y``单位向量。如下所示：

>>> Ny = 0*A.x + cos(q1)*A.y - sin(q1)*A.z

因此，在A中表达 N.y 应返回相同的结果：

>>> N.y.express(A)
cos(q1)*A.y - sin(q1)*A.z

orient( parent, rot_type, amounts, rot_order='', )[源代码][源代码]¶

设置此参考系相对于另一个（父）参考系的方位。

备注

现在推荐使用 .orient_axis, .orient_body_fixed, .orient_space_fixed, .orient_quaternion 方法来处理不同的旋转类型。

参数:

父级参考框架

此参考框架将相对于其旋转的参考框架。

rot_typestr

生成方向余弦矩阵所使用的方法。支持的方法有：

'Axis': 围绕单一公共轴的简单旋转
'DCM': 用于直接设置方向余弦矩阵
'Body': 关于新中间轴的三个连续旋转，也称为“欧拉和泰特-布莱恩角”
'Space': 关于父坐标系的单位矢量的三次连续旋转
'四元数': 由四个参数定义的旋转，结果是一个无奇异性的方向余弦矩阵

金额

定义旋转角度或方向余弦矩阵的表达式。这些必须与 rot_type 匹配。详情请参见下面的示例。输入类型如下：

'Axis': 2元组 (expr/sym/func, Vector)
'DCM': 矩阵, 形状(3,3)
'Body': 表达式、符号或函数的 3-tuple
'Space': 表达式、符号或函数的 3-tuple
'Quaternion': 表达式、符号或函数的 4 元组

rot_orderstr 或 int，可选

如果适用，旋转的连续顺序。例如，字符串 '123' 和整数 123 是等价的。对于 'Body' 和 'Space' 是必需的。

警告:

用户警告: 如果这种定向形成了一个运动回路。

orient_axis(parent, axis, angle)[源代码][源代码]¶

通过围绕父参考系中固定轴旋转一个角度，设置此参考系相对于父参考系的方位。

参数:

父级参考框架: 此参考框架将相对于其旋转的参考框架。
轴向量: 在父坐标系中固定的向量，围绕该向量旋转此坐标系。它不必是单位向量，旋转遵循右手定则。
角度sympifiable: 框架要旋转的弧度角。

警告:

用户警告: 如果这种定向形成了一个运动回路。

示例

设置示例的变量：

>>> from sympy import symbols
>>> from sympy.physics.vector import ReferenceFrame
>>> q1 = symbols('q1')
>>> N = ReferenceFrame('N')
>>> B = ReferenceFrame('B')
>>> B.orient_axis(N, N.x, q1)

orient_axis() 方法生成一个方向余弦矩阵及其转置，该矩阵定义了 B 相对于 N 的方向，反之亦然。一旦调用 orient，dcm() 将输出适当的方向余弦矩阵：

>>> B.dcm(N)
Matrix([
[1,       0,      0],
[0,  cos(q1), sin(q1)],
[0, -sin(q1), cos(q1)]])
>>> N.dcm(B)
Matrix([
[1,       0,        0],
[0, cos(q1), -sin(q1)],
[0, sin(q1),  cos(q1)]])

以下两行代码展示了旋转方向可以通过否定向量方向或角度来定义。两行代码产生相同的结果。

>>> B.orient_axis(N, -N.x, q1)
>>> B.orient_axis(N, N.x, -q1)

orient_body_fixed( parent, angles, rotation_order, )[源代码][源代码]¶

通过右手旋转，相对于父参考系旋转此参考系，经过三个连续的固定在物体上的简单轴旋转。每个后续的旋转轴都是关于一个新的中间参考系的“固定在物体上”的单位向量。这种类型的旋转也被称为通过欧拉和泰特-布莱恩角旋转。

该方法计算的角速度默认以子帧表示，因此最优选使用 u1 * child.x + u2 * child.y + u3 * child.z 作为广义速度。

参数:

父级参考框架: 此参考框架将相对于其旋转的参考框架。
角度可符号化的3元组: 用于连续旋转的三个弧度角。
rotation_order3 个字符的字符串或 3 位整数: 关于每个中间参考坐标系单位矢量的旋转顺序。关于X, Z’, X’’轴的欧拉旋转可以通过字符串``’XZX’``, ``’131’``或整数``131``来指定。有12种独特的有效旋转顺序（6种欧拉和6种Tait-Bryan）：zxz, xyx, yzy, zyz, xzx, yxy, xyz, yzx, zxy, xzy, zyx, 和 yxz。

警告:

用户警告: 如果这种定向形成了一个运动回路。

示例

设置示例的变量：

>>> from sympy import symbols
>>> from sympy.physics.vector import ReferenceFrame
>>> q1, q2, q3 = symbols('q1, q2, q3')
>>> N = ReferenceFrame('N')
>>> B = ReferenceFrame('B')
>>> B1 = ReferenceFrame('B1')
>>> B2 = ReferenceFrame('B2')
>>> B3 = ReferenceFrame('B3')

例如，经典的欧拉角旋转可以通过以下方式完成：

>>> B.orient_body_fixed(N, (q1, q2, q3), 'XYX')
>>> B.dcm(N)
Matrix([
[        cos(q2),                            sin(q1)*sin(q2),                           -sin(q2)*cos(q1)],
[sin(q2)*sin(q3), -sin(q1)*sin(q3)*cos(q2) + cos(q1)*cos(q3),  sin(q1)*cos(q3) + sin(q3)*cos(q1)*cos(q2)],
[sin(q2)*cos(q3), -sin(q1)*cos(q2)*cos(q3) - sin(q3)*cos(q1), -sin(q1)*sin(q3) + cos(q1)*cos(q2)*cos(q3)]])

这通过 q1 绕 N.x 旋转参考系 B 相对于参考系 N，然后再次通过 q2 绕 B.y 旋转 B，最后通过 q3 绕 B.x 旋转。它等效于三个连续的 orient_axis() 调用：

>>> B1.orient_axis(N, N.x, q1)
>>> B2.orient_axis(B1, B1.y, q2)
>>> B3.orient_axis(B2, B2.x, q3)
>>> B3.dcm(N)
Matrix([
[        cos(q2),                            sin(q1)*sin(q2),                           -sin(q2)*cos(q1)],
[sin(q2)*sin(q3), -sin(q1)*sin(q3)*cos(q2) + cos(q1)*cos(q3),  sin(q1)*cos(q3) + sin(q3)*cos(q1)*cos(q2)],
[sin(q2)*cos(q3), -sin(q1)*cos(q2)*cos(q3) - sin(q3)*cos(q1), -sin(q1)*sin(q3) + cos(q1)*cos(q2)*cos(q3)]])

可接受的旋转顺序长度为3，可以表示为字符串 'XYZ' 或 '123' 或整数 123。禁止在同一轴上连续旋转两次。

>>> B.orient_body_fixed(N, (q1, q2, 0), 'ZXZ')
>>> B.orient_body_fixed(N, (q1, q2, 0), '121')
>>> B.orient_body_fixed(N, (q1, q2, q3), 123)

orient_dcm(parent, dcm)[源代码][源代码]¶

使用描述从子参考系到父参考系的旋转的方向余弦矩阵，设置此参考系相对于另一个（父）参考系的方位。

参数:

父级参考框架: 此参考框架将相对于其旋转的参考框架。
dcm矩阵，形状(3, 3): 方向余弦矩阵，用于指定两个参考系之间的相对旋转。

警告:

用户警告: 如果这种定向形成了一个运动回路。

示例

设置示例的变量：

>>> from sympy import symbols, Matrix, sin, cos
>>> from sympy.physics.vector import ReferenceFrame
>>> q1 = symbols('q1')
>>> A = ReferenceFrame('A')
>>> B = ReferenceFrame('B')
>>> N = ReferenceFrame('N')

相对于 N 绕 N.x 轴的 A 的简单旋转由以下方向余弦矩阵定义：

>>> dcm = Matrix([[1, 0, 0],
...               [0,  cos(q1), sin(q1)],
...               [0, -sin(q1), cos(q1)]])
>>> A.orient_dcm(N, dcm)
>>> A.dcm(N)
Matrix([
[1,       0,      0],
[0,  cos(q1), sin(q1)],
[0, -sin(q1), cos(q1)]])

这等同于使用 orient_axis()：

>>> B.orient_axis(N, N.x, q1)
>>> B.dcm(N)
Matrix([
[1,       0,      0],
[0,  cos(q1), sin(q1)],
[0, -sin(q1), cos(q1)]])

orient_quaternion(parent, numbers)[源代码][源代码]¶

通过方向四元数设置此参考系相对于父参考系的方向。方向四元数定义为单位向量 (lambda_x, lambda_y, lambda_z) 绕角度 theta 的有限旋转。方向四元数由四个参数描述：

q0 = cos(theta/2)
q1 = lambda_x*sin(theta/2)
q2 = lambda_y*sin(theta/2)
q3 = lambda_z*sin(theta/2)

更多信息请参见维基百科上的四元数与空间旋转。

参数:

父级参考框架: 此参考框架将相对于其旋转的参考框架。
数字可符号化的 4-tuple: 如上定义的四元数标量数：q0, q1, q2, q3。

警告:

用户警告: 如果这种定向形成了一个运动回路。

示例

设置示例的变量：

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

设置方向：

>>> B.orient_quaternion(N, (q0, q1, q2, q3))
>>> B.dcm(N)
Matrix([
[q0**2 + q1**2 - q2**2 - q3**2,             2*q0*q3 + 2*q1*q2,            -2*q0*q2 + 2*q1*q3],
[           -2*q0*q3 + 2*q1*q2, q0**2 - q1**2 + q2**2 - q3**2,             2*q0*q1 + 2*q2*q3],
[            2*q0*q2 + 2*q1*q3,            -2*q0*q1 + 2*q2*q3, q0**2 - q1**2 - q2**2 + q3**2]])

orient_space_fixed( parent, angles, rotation_order, )[源代码][源代码]¶

通过右手旋转，相对于父参考系旋转此参考系，经过三个连续的空间固定简单轴旋转。每次后续的旋转轴都是关于父参考系“空间固定”单位向量的。

该方法计算的角速度默认以子帧表示，因此最优选使用 u1 * child.x + u2 * child.y + u3 * child.z 作为广义速度。

参数:

父级参考框架: 此参考框架将相对于其旋转的参考框架。
角度可符号化的3元组: 用于连续旋转的三个弧度角。
rotation_order3 个字符的字符串或 3 位整数: 关于父参考坐标系单位矢量的旋转顺序。顺序可以通过字符串 'XZX'、'131' 或整数 131 来指定。共有12种独特的有效旋转顺序。

警告:

用户警告: 如果这种定向形成了一个运动回路。

示例

设置示例的变量：

>>> from sympy import symbols
>>> from sympy.physics.vector import ReferenceFrame
>>> q1, q2, q3 = symbols('q1, q2, q3')
>>> N = ReferenceFrame('N')
>>> B = ReferenceFrame('B')
>>> B1 = ReferenceFrame('B1')
>>> B2 = ReferenceFrame('B2')
>>> B3 = ReferenceFrame('B3')

>>> B.orient_space_fixed(N, (q1, q2, q3), '312')
>>> B.dcm(N)
Matrix([
[ sin(q1)*sin(q2)*sin(q3) + cos(q1)*cos(q3), sin(q1)*cos(q2), sin(q1)*sin(q2)*cos(q3) - sin(q3)*cos(q1)],
[-sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1), cos(q1)*cos(q2), sin(q1)*sin(q3) + sin(q2)*cos(q1)*cos(q3)],
[                           sin(q3)*cos(q2),        -sin(q2),                           cos(q2)*cos(q3)]])

等同于：

>>> B1.orient_axis(N, N.z, q1)
>>> B2.orient_axis(B1, N.x, q2)
>>> B3.orient_axis(B2, N.y, q3)
>>> B3.dcm(N).simplify()
Matrix([
[ sin(q1)*sin(q2)*sin(q3) + cos(q1)*cos(q3), sin(q1)*cos(q2), sin(q1)*sin(q2)*cos(q3) - sin(q3)*cos(q1)],
[-sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1), cos(q1)*cos(q2), sin(q1)*sin(q3) + sin(q2)*cos(q1)*cos(q3)],
[                           sin(q3)*cos(q2),        -sin(q2),                           cos(q2)*cos(q3)]])

值得注意的是，空间固定和体固定旋转通过旋转顺序相关，即体固定的反序将给出空间固定，反之亦然。

>>> B.orient_space_fixed(N, (q1, q2, q3), '231')
>>> B.dcm(N)
Matrix([
[cos(q1)*cos(q2), sin(q1)*sin(q3) + sin(q2)*cos(q1)*cos(q3), -sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1)],
[       -sin(q2),                           cos(q2)*cos(q3),                            sin(q3)*cos(q2)],
[sin(q1)*cos(q2), sin(q1)*sin(q2)*cos(q3) - sin(q3)*cos(q1),  sin(q1)*sin(q2)*sin(q3) + cos(q1)*cos(q3)]])

>>> B.orient_body_fixed(N, (q3, q2, q1), '132')
>>> B.dcm(N)
Matrix([
[cos(q1)*cos(q2), sin(q1)*sin(q3) + sin(q2)*cos(q1)*cos(q3), -sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1)],
[       -sin(q2),                           cos(q2)*cos(q3),                            sin(q3)*cos(q2)],
[sin(q1)*cos(q2), sin(q1)*sin(q2)*cos(q3) - sin(q3)*cos(q1),  sin(q1)*sin(q2)*sin(q3) + cos(q1)*cos(q3)]])

orientnew( newname, rot_type, amounts, rot_order='', variables=None, indices=None, latexs=None, )[源代码][源代码]¶

返回一个相对于此参考系定向的新参考系。

有关如何定向参考系的详细示例，请参阅 ReferenceFrame.orient()。

参数:

newnamestr

新参考系的名称。

rot_typestr

生成方向余弦矩阵所使用的方法。支持的方法有：

'Axis': 围绕单一公共轴的简单旋转
'DCM': 用于直接设置方向余弦矩阵
'Body': 关于新中间轴的三个连续旋转，也称为“欧拉和泰特-布莱恩角”
'Space': 关于父坐标系的单位矢量的三次连续旋转
'四元数': 由四个参数定义的旋转，结果是一个无奇异性的方向余弦矩阵

金额

定义旋转角度或方向余弦矩阵的表达式。这些必须与 rot_type 匹配。详情请参见下面的示例。输入类型如下：

'Axis': 2元组 (expr/sym/func, Vector)
'DCM': 矩阵, 形状(3,3)
'Body': 表达式、符号或函数的 3-tuple
'Space': 表达式、符号或函数的 3-tuple
'Quaternion': 表达式、符号或函数的 4 元组

rot_orderstr 或 int，可选

如果适用，旋转的连续顺序。例如，字符串 '123' 和整数 123 是等价的。对于 'Body' 和 'Space' 是必需的。

索引字符串元组

启用参考坐标系的基向量可以通过Python的方括号索引表示法访问，使用提供的三个索引字符串，并更改单位向量的打印方式以反映此选择。

latexs字符串元组

将参考系的基向量的LaTeX打印更改为提供的三个有效的LaTeX字符串。

示例

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

创建一个相对于 N 通过简单旋转的新参考系 A。

>>> A = N.orientnew('A', 'Axis', (q0, N.x))

创建一个相对于 N 通过体固定旋转旋转的新参考系 B。

>>> B = N.orientnew('B', 'Body', (q1, q2, q3), '123')

创建一个新的参考系 C，相对于 N 进行简单的旋转，具有唯一的索引和 LaTeX 打印。

>>> C = N.orientnew('C', 'Axis', (q0, N.x), indices=('1', '2', '3'),
... latexs=(r'\hat{\mathbf{c}}_1',r'\hat{\mathbf{c}}_2',
... r'\hat{\mathbf{c}}_3'))
>>> C['1']
C['1']
>>> print(vlatex(C['1']))
\hat{\mathbf{c}}_1

partial_velocity( frame, *gen_speeds, )[源代码][源代码]¶

返回此框架相对于一个或多个提供的广义速度在给定框架中的部分角速度。

参数:

框架参考框架: 定义角速度所用的参考系。
gen_speeds时间的功能: 广义速度。

返回:

partial_velocitiesVector 的元组: 与提供的广义速度相对应的部分角速度矢量。

示例

>>> from sympy.physics.vector import ReferenceFrame, dynamicsymbols
>>> N = ReferenceFrame('N')
>>> A = ReferenceFrame('A')
>>> u1, u2 = dynamicsymbols('u1, u2')
>>> A.set_ang_vel(N, u1 * A.x + u2 * N.y)
>>> A.partial_velocity(N, u1)
A.x
>>> A.partial_velocity(N, u1, u2)
(A.x, N.y)

set_ang_acc(otherframe, value)[源代码][源代码]¶

在参考系中定义角加速度向量。

定义此 ReferenceFrame 在另一个 ReferenceFrame 中的角加速度。角加速度可以相对于多个不同的 ReferenceFrame 定义。必须注意不要创建不一致的循环。

参数:

其他框架参考框架: 一个用于定义角加速度的参考系
值向量: 表示角加速度的向量

示例

>>> from sympy.physics.vector import ReferenceFrame
>>> N = ReferenceFrame('N')
>>> A = ReferenceFrame('A')
>>> V = 10 * N.x
>>> A.set_ang_acc(N, V)
>>> A.ang_acc_in(N)
10*N.x

set_ang_vel(otherframe, value)[源代码][源代码]¶

在参考系中定义角速度矢量。

定义此 ReferenceFrame 在另一个 ReferenceFrame 中的角速度。角速度可以相对于多个不同的 ReferenceFrame 定义。必须注意不要创建不一致的循环。

参数:

其他框架参考框架: 一个 ReferenceFrame 用于定义角速度
值向量: 表示角速度的向量

示例

>>> from sympy.physics.vector import ReferenceFrame
>>> N = ReferenceFrame('N')
>>> A = ReferenceFrame('A')
>>> V = 10 * N.x
>>> A.set_ang_vel(N, V)
>>> A.ang_vel_in(N)
10*N.x

property u¶: 参考系的单位并矢。

variable_map(otherframe)[源代码][源代码]¶

返回一个字典，该字典表示此框架的坐标变量在其他框架变量中的表达。

如果 Vector.simp 为 True，则返回映射值的简化版本。否则，返回它们而不进行简化。

表达式的简化可能需要时间。

参数:

其他框架参考框架: 映射变量的另一个框架

示例

>>> from sympy.physics.vector import ReferenceFrame, dynamicsymbols
>>> A = ReferenceFrame('A')
>>> q = dynamicsymbols('q')
>>> B = A.orientnew('B', 'Axis', [q, A.z])
>>> A.variable_map(B)
{A_x: B_x*cos(q(t)) - B_y*sin(q(t)), A_y: B_x*sin(q(t)) + B_y*cos(q(t)), A_z: B_z}

property x¶: 参考框架在x方向上的基向量。

property xx¶: 参考系中基向量 x 和 x 的单位二元组。

property xy¶: 参考系中基向量 x 和 y 的单位对偶。

property xz¶: 参考框架的基向量 x 和 z 的单位对偶。

property y¶: 参考坐标系在 y 方向上的基向量。

property yx¶: 参考系的基向量 y 和 x 的单位对偶。

property yy¶: 参考系中基向量 y 和 y 的单位二元组。

property yz¶: 参考系中基向量 y 和 z 的单位对偶。

property z¶: 参考坐标系的基向量，在 z 方向上。

property zx¶: 参考系中基向量 z 和 x 的单位对偶。

property zy¶: 参考系中基向量 z 和 y 的单位对偶。

property zz¶: 参考系中基向量 z 和 z 的单位二元组。

class sympy.physics.vector.vector.Vector(inlist)[源代码][源代码]¶

用于定义向量的类。

它与 ReferenceFrame 一起是描述 PyDy 和 sympy.physics.vector 中经典力学系统的构建模块。

属性:

simp布尔值: 让某些方法在其输出上使用 trigsimp

方法

`angle_between`(vec)	返回向量 'vec' 和自身之间的最小角度。
`applyfunc`(f)	对向量的每个分量应用一个函数。
`cross`(other)	两个向量的叉积运算符。
`diff`(var, frame[, var_in_dcm])	返回向量相对于所提供参考系中变量的偏导数。
`doit`(**hints)	对 Vector 中的每个项调用 .doit() 方法
`dot`(other)	两个向量的点积。
`dt`(otherframe)	返回一个向量，该向量是自身向量在otherframe坐标系中的时间导数。
`evalf`([n, subs, maxn, chop, strict, quad, ...])	将给定的公式计算到 n 位精度。
`express`(otherframe[, variables])	返回一个与此向量等效的向量，表示在其他坐标系中。
`free_dynamicsymbols`(reference_frame)	返回在给定参考系中表示的向量的测量数中的自由动态符号（时间 `t` 的函数）。
`free_symbols`(reference_frame)	返回在给定参考系中表示的向量的度量数中的自由符号。
`magnitude`()	返回自身的大小（欧几里得范数）。
`n`([n, subs, maxn, chop, strict, quad, verbose])	将给定的公式计算到 n 位精度。
`normalize`()	返回一个大小为1的向量，与自身同方向。
`outer`(other)	两个向量之间的外积。
`separate`()	根据其定义，此向量在不同参考系中的组成部分。
`simplify`()	返回一个简化的向量。
`subs`(args, *kwargs)	向量上的替换。
`to_matrix`(reference_frame)	返回相对于给定框架的向量的矩阵形式。
`xreplace`(rule)	替换向量中测量编号内的对象出现。

angle_between(vec)[源代码][源代码]¶

返回向量 ‘vec’ 和自身之间的最小角度。

警告

Python 忽略了前导负号，这可能会导致错误的结果。-A.x.angle_between() 会被视为 -(A.x.angle_between())，而不是 (-A.x).angle_between()。

示例

>>> from sympy.physics.vector import ReferenceFrame
>>> A = ReferenceFrame("A")
>>> v1 = A.x
>>> v2 = A.y
>>> v1.angle_between(v2)
pi/2

>>> v3 = A.x + A.y + A.z
>>> v1.angle_between(v3)
acos(sqrt(3)/3)

applyfunc(f)[源代码][源代码]¶: 对向量的每个分量应用一个函数。

cross(other)[源代码][源代码]¶

两个向量的叉积运算符。

返回一个向量，以与自身相同的参考系表示。

参数:

其他向量: 我们正在与之叉乘的向量

示例

>>> from sympy import symbols
>>> from sympy.physics.vector import ReferenceFrame, cross
>>> q1 = symbols('q1')
>>> N = ReferenceFrame('N')
>>> cross(N.x, N.y)
N.z
>>> A = ReferenceFrame('A')
>>> A.orient_axis(N, q1, N.x)
>>> cross(A.x, N.y)
N.z
>>> cross(N.y, A.x)
- sin(q1)*A.y - cos(q1)*A.z

diff(var, frame, var_in_dcm=True)[源代码][源代码]¶

返回向量相对于所提供参考系中变量的偏导数。

参数:

变量符号: 对哪个变量求偏导数。
框架参考框架: 进行偏导数运算的参考系。
var_in_dcm布尔: 如果为真，微分算法假设变量可能存在于与向量任何分量的框架相关的方向余弦矩阵中的任何一个。但如果已知变量不存在于方向余弦矩阵中，可以设置为假以跳过在所需框架中的完全重表达。

示例

>>> from sympy import Symbol
>>> from sympy.physics.vector import dynamicsymbols, ReferenceFrame
>>> from sympy.physics.vector import init_vprinting
>>> init_vprinting(pretty_print=False)
>>> t = Symbol('t')
>>> q1 = dynamicsymbols('q1')
>>> N = ReferenceFrame('N')
>>> A = N.orientnew('A', 'Axis', [q1, N.y])
>>> A.x.diff(t, N)
- sin(q1)*q1'*N.x - cos(q1)*q1'*N.z
>>> A.x.diff(t, N).express(A).simplify()
- q1'*A.z
>>> B = ReferenceFrame('B')
>>> u1, u2 = dynamicsymbols('u1, u2')
>>> v = u1 * A.x + u2 * B.y
>>> v.diff(u2, N, var_in_dcm=False)
B.y

doit(**hints)[源代码][源代码]¶: 对 Vector 中的每个项调用 .doit() 方法

dot(other)[源代码][源代码]¶

两个向量的点积。

返回一个标量，即两个向量的点积

参数:

其他向量: 我们正在点积的向量

示例

>>> from sympy.physics.vector import ReferenceFrame, dot
>>> from sympy import symbols
>>> q1 = symbols('q1')
>>> N = ReferenceFrame('N')
>>> dot(N.x, N.x)
1
>>> dot(N.x, N.y)
0
>>> A = N.orientnew('A', 'Axis', [q1, N.x])
>>> dot(N.y, A.y)
cos(q1)

dt(otherframe)[源代码][源代码]¶

返回一个向量，该向量是自身向量在otherframe坐标系中的时间导数。

调用全局 time_derivative 方法

参数:

其他框架参考框架: 计算时间导数的框架

express(otherframe, variables=False)[源代码][源代码]¶

返回一个与此向量等效的向量，该向量在其他坐标系中表示。使用全局表达方法。

参数:

其他框架参考框架: 描述此向量的框架为
变量布尔: 如果为真，此向量中的坐标符号（如果存在）将重新表示为其他坐标系

示例

>>> from sympy.physics.vector import ReferenceFrame, dynamicsymbols
>>> from sympy.physics.vector import init_vprinting
>>> init_vprinting(pretty_print=False)
>>> q1 = dynamicsymbols('q1')
>>> N = ReferenceFrame('N')
>>> A = N.orientnew('A', 'Axis', [q1, N.y])
>>> A.x.express(N)
cos(q1)*N.x - sin(q1)*N.z

free_dynamicsymbols(reference_frame)[源代码][源代码]¶

返回在给定参考系中表示的向量的测量数中的自由动态符号（时间 t 的函数）。

参数:

参考框架参考框架: 用于确定给定向量的自由动态符号的参考系。

返回:

设置: 时间 t 的函数集合，例如 Function('f')(me.dynamicsymbols._t)。

free_symbols(reference_frame)[源代码][源代码]¶

返回在给定参考系中表示的向量的度量数中的自由符号。

参数:

参考框架参考框架: 用于确定给定向量的自由符号的框架。

返回:

符号集: reference_frame 的拍号中存在的符号集合。

property func¶: 返回类 Vector。

magnitude()[源代码][源代码]¶: 返回自身的大小（欧几里得范数）。

警告

Python 忽略了前导负号，这可能会导致错误的结果。-A.x.magnitude() 会被视为 -(A.x.magnitude())，而不是 (-A.x).magnitude()。

normalize()[源代码][源代码]¶: 返回一个大小为1的向量，与自身同方向。

outer(other)[源代码][源代码]¶

两个向量之间的外积。

一个秩增加操作，它返回两个向量的并矢。

参数:

其他向量: 要与之进行外积的向量

示例

>>> from sympy.physics.vector import ReferenceFrame, outer
>>> N = ReferenceFrame('N')
>>> outer(N.x, N.x)
(N.x|N.x)

separate()[源代码][源代码]¶

根据其定义，此向量在不同参考系中的组成部分。

返回一个字典，该字典将每个 ReferenceFrame 映射到相应的构成 Vector。

示例

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

simplify()[源代码][源代码]¶: 返回一个简化的向量。

subs(*args, **kwargs)[源代码][源代码]¶

向量上的替换。

示例

>>> from sympy.physics.vector import ReferenceFrame
>>> from sympy import Symbol
>>> N = ReferenceFrame('N')
>>> s = Symbol('s')
>>> a = N.x * s
>>> a.subs({s: 2})
2*N.x

to_matrix(reference_frame)[源代码][源代码]¶

返回相对于给定框架的向量的矩阵形式。

参数:

参考框架参考框架: 矩阵的行所对应的参考系。

返回:

矩阵ImmutableMatrix, 形状(3,1): 给出 1D 向量的矩阵。

示例

>>> from sympy import symbols
>>> from sympy.physics.vector import ReferenceFrame
>>> a, b, c = symbols('a, b, c')
>>> N = ReferenceFrame('N')
>>> vector = a * N.x + b * N.y + c * N.z
>>> vector.to_matrix(N)
Matrix([
[a],
[b],
[c]])
>>> beta = symbols('beta')
>>> A = N.orientnew('A', 'Axis', (beta, N.x))
>>> vector.to_matrix(A)
Matrix([
[                         a],
[ b*cos(beta) + c*sin(beta)],
[-b*sin(beta) + c*cos(beta)]])

xreplace(rule)[源代码][源代码]¶

替换向量中测量编号内的对象出现。

参数:

规则类似字典: 表达一个替换规则。

返回:

向量: 替换的结果。

示例

>>> from sympy import symbols, pi
>>> from sympy.physics.vector import ReferenceFrame
>>> A = ReferenceFrame('A')
>>> x, y, z = symbols('x y z')
>>> ((1 + x*y) * A.x).xreplace({x: pi})
(pi*y + 1)*A.x
>>> ((1 + x*y) * A.x).xreplace({x: pi, y: 2})
(1 + 2*pi)*A.x

只有在表达式树中的整个节点匹配时，才会发生替换：

>>> ((x*y + z) * A.x).xreplace({x*y: pi})
(z + pi)*A.x
>>> ((x*y*z) * A.x).xreplace({x*y: pi})
x*y*z*A.x

class sympy.physics.vector.dyadic.Dyadic(inlist)[源代码][源代码]¶

一个二元对象。

参见: https://en.wikipedia.org/wiki/Dyadic_tensor Kane, T., Levinson, D. 动力学理论与应用. 1985 McGraw-Hill

一种更强大的表示刚体惯性的方法。虽然它更复杂，但通过选择双基分量在体固定基向量中，得到的矩阵等价于惯性张量。

属性:

func: 返回类 Dyadic。

方法

`applyfunc`(f)	对 Dyadic 的每个组件应用一个函数。
`cross`(other)	返回由向量叉积产生的二元组：二元组 x 向量。
`doit`(**hints)	对 Dyadic 中的每个项调用 .doit()。
`dot`(other)	Dyadic 和 Dyadic 或 Vector 的内积运算符。
`dt`(frame)	在某个坐标系中对这个并矢取时间导数。
`evalf`([n, subs, maxn, chop, strict, quad, ...])	将给定的公式计算到 n 位精度。
`express`(frame1[, frame2])	在其他坐标系中表达此二元关系
`n`([n, subs, maxn, chop, strict, quad, verbose])	将给定的公式计算到 n 位精度。
`simplify`()	返回一个简化的二元组。
`subs`(args, *kwargs)	在二元上的替代。
`to_matrix`(reference_frame[, ...])	返回相对于一个或两个参考系的并矢的矩阵形式。
`xreplace`(rule)	替换Dyadic度量编号中的对象出现。

applyfunc(f)[源代码][源代码]¶: 对 Dyadic 的每个组件应用一个函数。

cross(other)[源代码][源代码]¶

返回由向量叉积产生的二元组：二元组 x 向量。

参数:

其他向量: 要与之叉乘的向量。

示例

>>> from sympy.physics.vector import ReferenceFrame, outer, cross
>>> N = ReferenceFrame('N')
>>> d = outer(N.x, N.x)
>>> cross(d, N.y)
(N.x|N.z)

doit(**hints)[源代码][源代码]¶: 对 Dyadic 中的每个项调用 .doit()。

dot(other)[源代码][源代码]¶

Dyadic 和 Dyadic 或 Vector 的内积运算符。

参数:

其他二元或向量: 另一个要与之进行内积的二元或向量

示例

>>> from sympy.physics.vector import ReferenceFrame, outer
>>> N = ReferenceFrame('N')
>>> D1 = outer(N.x, N.y)
>>> D2 = outer(N.y, N.y)
>>> D1.dot(D2)
(N.x|N.y)
>>> D1.dot(N.y)
N.x

dt(frame)[源代码][源代码]¶

在某个坐标系中对这个并矢取时间导数。

此函数调用全局 time_derivative 方法

参数:

框架参考框架: 在哪个框架中取时间导数

示例

>>> from sympy.physics.vector import ReferenceFrame, outer, dynamicsymbols
>>> from sympy.physics.vector import init_vprinting
>>> init_vprinting(pretty_print=False)
>>> N = ReferenceFrame('N')
>>> q = dynamicsymbols('q')
>>> B = N.orientnew('B', 'Axis', [q, N.z])
>>> d = outer(N.x, N.x)
>>> d.dt(B)
- q'*(N.y|N.x) - q'*(N.x|N.y)

express(frame1, frame2=None)[源代码][源代码]¶

在其他坐标系中表达此二元关系

第一个框架是列表侧表达式，第二个框架是右侧；如果 Dyadic 的形式是 A.x|B.y，你可以用两个不同的框架来表达它。如果没有给出第二个框架，Dyadic 只在一个框架中表达。

调用全局 express 函数

参数:

frame1参考框架: 表达Dyadic左侧的框架
frame2参考框架: 如果提供，用于表达Dyadic右侧的框架

示例

>>> from sympy.physics.vector import ReferenceFrame, outer, dynamicsymbols
>>> from sympy.physics.vector import init_vprinting
>>> init_vprinting(pretty_print=False)
>>> N = ReferenceFrame('N')
>>> q = dynamicsymbols('q')
>>> B = N.orientnew('B', 'Axis', [q, N.z])
>>> d = outer(N.x, N.x)
>>> d.express(B, N)
cos(q)*(B.x|N.x) - sin(q)*(B.y|N.x)

property func¶: 返回类 Dyadic。

simplify()[源代码][源代码]¶: 返回一个简化的二元组。

subs(*args, **kwargs)[源代码][源代码]¶

在二元上的替代。

示例

>>> from sympy.physics.vector import ReferenceFrame
>>> from sympy import Symbol
>>> N = ReferenceFrame('N')
>>> s = Symbol('s')
>>> a = s*(N.x|N.x)
>>> a.subs({s: 2})
2*(N.x|N.x)

to_matrix( reference_frame, second_reference_frame=None, )[源代码][源代码]¶

返回相对于一个或两个参考系的并矢的矩阵形式。

参数:

参考框架参考框架: 矩阵的行和列所对应的参考系。如果提供了第二个参考系，则这仅对应于矩阵的行。
第二个参考系ReferenceFrame, 可选, 默认=None: 矩阵列所对应的参考系。

返回:

矩阵ImmutableMatrix, 形状(3,3): 给出二维张量形式的矩阵。

示例

>>> from sympy import symbols, trigsimp
>>> from sympy.physics.vector import ReferenceFrame
>>> from sympy.physics.mechanics import inertia
>>> Ixx, Iyy, Izz, Ixy, Iyz, Ixz = symbols('Ixx, Iyy, Izz, Ixy, Iyz, Ixz')
>>> N = ReferenceFrame('N')
>>> inertia_dyadic = inertia(N, Ixx, Iyy, Izz, Ixy, Iyz, Ixz)
>>> inertia_dyadic.to_matrix(N)
Matrix([
[Ixx, Ixy, Ixz],
[Ixy, Iyy, Iyz],
[Ixz, Iyz, Izz]])
>>> beta = symbols('beta')
>>> A = N.orientnew('A', 'Axis', (beta, N.x))
>>> trigsimp(inertia_dyadic.to_matrix(A))
Matrix([
[                           Ixx,                                           Ixy*cos(beta) + Ixz*sin(beta),                                           -Ixy*sin(beta) + Ixz*cos(beta)],
[ Ixy*cos(beta) + Ixz*sin(beta), Iyy*cos(2*beta)/2 + Iyy/2 + Iyz*sin(2*beta) - Izz*cos(2*beta)/2 + Izz/2,                 -Iyy*sin(2*beta)/2 + Iyz*cos(2*beta) + Izz*sin(2*beta)/2],
[-Ixy*sin(beta) + Ixz*cos(beta),                -Iyy*sin(2*beta)/2 + Iyz*cos(2*beta) + Izz*sin(2*beta)/2, -Iyy*cos(2*beta)/2 + Iyy/2 - Iyz*sin(2*beta) + Izz*cos(2*beta)/2 + Izz/2]])

xreplace(rule)[源代码][源代码]¶

替换Dyadic度量编号中的对象出现。

参数:

规则类似字典: 表达一个替换规则。

返回:

二元的: 替换的结果。

示例

>>> from sympy import symbols, pi
>>> from sympy.physics.vector import ReferenceFrame, outer
>>> N = ReferenceFrame('N')
>>> D = outer(N.x, N.x)
>>> x, y, z = symbols('x y z')
>>> ((1 + x*y) * D).xreplace({x: pi})
(pi*y + 1)*(N.x|N.x)
>>> ((1 + x*y) * D).xreplace({x: pi, y: 2})
(1 + 2*pi)*(N.x|N.x)

只有在表达式树中的整个节点匹配时，才会发生替换：

>>> ((x*y + z) * D).xreplace({x*y: pi})
(z + pi)*(N.x|N.x)
>>> ((x*y*z) * D).xreplace({x*y: pi})
x*y*z*(N.x|N.x)