代数¶

介绍¶

SymPy 的 Algebras 模块为四元数的基本代数运算提供支持。

四元数参考¶

本节列出了由 Algebras 模块实现的类。

class sympy.algebras.Quaternion( a=0, b=0, c=0, d=0, real_field=True, norm=None, )[源代码][源代码]¶

提供基本的四元数操作。四元数对象可以通过 Quaternion(a, b, c, d) 实例化，如 $q = a + bi + cj + dk$。

参数:

规范无或数字: 预定义的四元数范数。如果给定一个值，Quaternion.norm 将返回这个预定义的值，而不是计算范数。

属性:

a
args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 $type$ 假设。
b
c
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
d
expr_free_symbols: 类似于 free_symbols，但仅在自由符号包含在表达式节点中时返回它们。
free_symbols: 从自身的原子中返回那些自由符号。
func: 表达式中的顶级函数。
is_antihermitian
is_comparable: 如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
is_finite
is_hermitian
is_infinite
is_number: 如果 self 没有自由符号且没有未定义的函数（确切地说，是 AppliedUndef），则返回 True。
is_polar
product_matrix_left: 返回一个等效于从左侧进行的 Hamilton 乘积的 4 x 4 矩阵。
product_matrix_right: 返回一个从右侧等效于Hamilton乘积的4 x 4矩阵。
实数域

方法

`add`(other)	添加四元数。
`angle`()	返回四元数在实轴平面上的角度。
`apart`([x])	请参阅 sympy.polys 中的 apart 函数。
`arc_coplanar`(other)	如果输入的四元数表示的变换弧在同一平面上，则返回 True。
`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，并返回该内容和新的自身（原始类型）。
`as_dummy`()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
`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])	对 'self' 执行复杂的扩展，并返回一个包含收集到的实部和虚部的元组。
`as_terms`()	将一个表达式转换为项的列表。
`aseries`([x, n, bound, hir])	自变量的渐近级数展开
`atoms`(*types)	返回构成当前对象的原子。
`axis`()	返回 $mathbf{Ax}(q)$，即四元数 $q$ 的轴。
`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 位精度。
`exp`()	返回 $q$ 的指数，由 $e^q$ 给出。
`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])	计算自身的形式幂级数。
`from_Matrix`(elements)	从列向量的元素返回四元数`.
`from_axis_angle`(vector, angle)	返回一个给定旋转轴和旋转角度的旋转四元数。
`from_euler`(angles, seq)	返回与由 `seq` 定义的序列中的欧拉角表示的旋转等效的四元数。
`from_rotation_matrix`(M)	返回矩阵的等效四元数。
`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。
`index_vector`()	返回四元数的索引向量。
`integrate`(*args)	计算四元数的积分。
`inverse`()	返回四元数的逆。
`invert`(g, gens, *args)	返回 `self` 对 `g` 的乘法逆元，其中 self``（和 ``g）可以是符号表达式。
`is_algebraic_expr`(*syms)	此测试给定的表达式是否在给定的符号 syms 中是代数的。
`is_constant`(wrt, *flags)	如果 self 是常量则返回 True，如果不是则返回 False，如果无法明确确定常量性则返回 None。
`is_meromorphic`(x, a)	此测试表达式是否作为给定符号 `x` 的函数在点 `a` 处是亚纯的。
`is_polynomial`(*syms)	如果 self 是 syms 中的多项式，则返回 True，否则返回 False。
`is_pure`()	如果四元数是纯的则返回真，如果四元数不是纯的则返回假，如果未知则返回无。
`is_rational_function`(*syms)	测试函数是否为给定符号 syms 中的两个多项式的比率。
`is_same`(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
`is_zero_quaternion`()	如果四元数是零四元数则返回 true，如果不是零四元数则返回 false，如果值未知则返回 None。
`leadterm`(x[, logx, cdir])	返回前导项 ax*b 作为元组 (a, b)。
`limit`(x, xlim[, dir])	计算极限 x->xlim。
`log`()	返回四元数的对数，由 $log q$ 给出。
`lseries`([x, x0, dir, logx, cdir])	用于生成序列项的迭代器的包装器。
`match`(pattern[, old])	模式匹配。
`matches`(expr[, repl_dict, old])	用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
`mensor`()	返回四元数的范数（模）的自然对数。
`mul`(other)	四元数相乘。
`n`([n, subs, maxn, chop, strict, quad, verbose])	将给定的公式计算到 n 位精度。
`norm`()	返回四元数的范数。
`normal`()	返回表达式为分数形式。
`normalize`()	返回四元数的归一化形式。
`nseries`([x, x0, n, dir, logx, cdir])	如果假设允许，则包装到 _eval_nseries，否则包装到 series。
`nsimplify`([constants, tolerance, full])	参见 sympy.simplify 中的 nsimplify 函数
`orthogonal`(other)	返回两个四元数的正交性。
`parallel`(other)	如果两个纯四元数被视为3D向量时是平行的，则返回True。
`pow`(p)	找到四元数的 p 次幂。
`pow_cos_sin`(p)	计算余弦-正弦形式中的p次幂。
`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。
`rotate_point`(pin, r)	返回旋转后的点针（一个三元组）的坐标。
`round`([n])	返回 x 四舍五入到给定的十进制位数。
`scalar_part`()	返回四元数 q 的标量部分($mathbf{S}(q)$)。
`separate`([deep, force])	参见 sympy.simplify 中的单独函数
`series`([x, x0, n, dir, logx, cdir])	在 `x = x0` 附近对 "self" 进行级数展开，当 n=None 时逐项给出级数项（即惰性级数），否则当 n != None 时一次性给出所有项。
`set_norm`(norm)	设置已实例化的四元数的范数。
`simplify`(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
`sort_key`([order])
`subs`(args, *kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
`taylor_term`(n, x, *previous_terms)	泰勒项的一般方法。
`to_Matrix`([vector_only])	返回四元数的元素作为一个列向量。
`to_axis_angle`()	返回四元数的旋转轴和角度。
`to_euler`(seq[, angle_addition, ...])	返回表示与四元数相同旋转的欧拉角，按 `seq` 给定的顺序。
`to_rotation_matrix`([v, homogeneous])	如果未传递 `v` ，则返回表示围绕原点旋转的四元数的等效旋转变换矩阵。
`together`(args, *kwargs)	请参阅 sympy.polys 中的 together 函数。
`trigsimp`(**args)	参见 sympy.simplify 中的 trigsimp 函数
`vector_coplanar`(q1, q2, q3)	如果将纯四元数视为3D向量的 `q1`、`q2` 和 `q3` 的轴共面，则返回 True。
`vector_part`()	返回四元数 $q$ 的向量部分 $mathbf{V}(q)$。
`xreplace`(rule)	替换表达式中对象的出现。

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

参考文献

[1]

https://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/

[2]

https://zh.wikipedia.org/wiki/四元数

示例

>>> from sympy import Quaternion
>>> q = Quaternion(1, 2, 3, 4)
>>> q
1 + 2*i + 3*j + 4*k

复数域上的四元数可以定义为：

>>> from sympy import Quaternion
>>> from sympy import symbols, I
>>> x = symbols('x')
>>> q1 = Quaternion(x, x**3, x, x**2, real_field = False)
>>> q2 = Quaternion(3 + 4*I, 2 + 5*I, 0, 7 + 8*I, real_field = False)
>>> q1
x + x**3*i + x*j + x**2*k
>>> q2
(3 + 4*I) + (2 + 5*I)*i + 0*j + (7 + 8*I)*k

定义符号单位四元数：

>>> from sympy import Quaternion
>>> from sympy.abc import w, x, y, z
>>> q = Quaternion(w, x, y, z, norm=1)
>>> q
w + x*i + y*j + z*k
>>> q.norm()
1

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

添加四元数。

参数:

其他四元数: 要添加到当前（自身）四元数的四元数。

返回:

四元数: 将自身与另一个四元数相加后的结果四元数

示例

>>> from sympy import Quaternion
>>> from sympy import symbols
>>> q1 = Quaternion(1, 2, 3, 4)
>>> q2 = Quaternion(5, 6, 7, 8)
>>> q1.add(q2)
6 + 8*i + 10*j + 12*k
>>> q1 + 5
6 + 2*i + 3*j + 4*k
>>> x = symbols('x', real = True)
>>> q1.add(x)
(x + 1) + 2*i + 3*j + 4*k

复数域上的四元数：

>>> from sympy import Quaternion
>>> from sympy import I
>>> q3 = Quaternion(3 + 4*I, 2 + 5*I, 0, 7 + 8*I, real_field = False)
>>> q3.add(2 + 3*I)
(5 + 7*I) + (2 + 5*I)*i + 0*j + (7 + 8*I)*k

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

返回四元数在实轴平面上的角度。

示例

>>> from sympy.algebras.quaternion import Quaternion
>>> q = Quaternion(1, 4, 4, 4)
>>> q.angle()
2*atan(4*sqrt(3))

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

如果输入的四元数表示的变换弧在同一平面上，则返回 True。

参数:

其他一个四元数

返回:

真如果两个四元数的平面相同，除了其方向/符号。
假如果两个四元数的平面不同，除了其方向/符号之外。
无如果四元数的任何一个平面是未知的。

参见

vector_coplanar
is_pure

示例

>>> from sympy.algebras.quaternion import Quaternion
>>> q1 = Quaternion(1, 4, 4, 4)
>>> q2 = Quaternion(3, 8, 8, 8)
>>> Quaternion.arc_coplanar(q1, q2)
True

>>> q1 = Quaternion(2, 8, 13, 12)
>>> Quaternion.arc_coplanar(q1, q2)
False

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

返回 $\mathbf{Ax}(q)$，即四元数 $q$ 的轴。

参见

vector_part

示例

>>> from sympy.algebras.quaternion import Quaternion
>>> q = Quaternion(1, 1, 1, 1)
>>> q.axis()
0 + sqrt(3)/3*i + sqrt(3)/3*j + sqrt(3)/3*k

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

返回 $q$ 的指数，由 $e^q$ 给出。

返回:

四元数: 四元数的指数。

示例

>>> from sympy import Quaternion
>>> q = Quaternion(1, 2, 3, 4)
>>> q.exp()
E*cos(sqrt(29))
+ 2*sqrt(29)*E*sin(sqrt(29))/29*i
+ 3*sqrt(29)*E*sin(sqrt(29))/29*j
+ 4*sqrt(29)*E*sin(sqrt(29))/29*k

classmethod from_Matrix(elements)[源代码][源代码]¶

返回从列向量元素得到的四元数。如果 vector_only 为 True，则仅返回长度为 3 的矩阵形式的虚部。

参数:

元素长度为3或4的矩阵、列表或元组。如果长度为3，: 假设实部为零。默认值：False

返回:

四元数: 从输入元素创建的四元数。

示例

>>> from sympy import Quaternion
>>> from sympy.abc import a, b, c, d
>>> q = Quaternion.from_Matrix([a, b, c, d])
>>> q
a + b*i + c*j + d*k

>>> q = Quaternion.from_Matrix([b, c, d])
>>> q
0 + b*i + c*j + d*k

classmethod from_axis_angle(vector, angle)[源代码][源代码]¶

返回一个给定旋转轴和旋转角度的旋转四元数。

参数:

向量三个数字的元组: 给定轴的向量表示。
角度数字: 轴旋转的角度（以弧度为单位）。

返回:

四元数: 从给定轴和旋转角度计算出的归一化旋转四元数。

示例

>>> from sympy import Quaternion
>>> from sympy import pi, sqrt
>>> q = Quaternion.from_axis_angle((sqrt(3)/3, sqrt(3)/3, sqrt(3)/3), 2*pi/3)
>>> q
1/2 + 1/2*i + 1/2*j + 1/2*k

classmethod from_euler(angles, seq)[源代码][源代码]¶

返回与由 seq 定义的序列中的欧拉角表示的旋转等效的四元数。

参数:

角度由3个数字组成的列表、元组或矩阵: 欧拉角（以弧度为单位）。
seq长度为3的字符串: 表示旋转的序列。对于外旋，seq 必须全部小写，并且其元素必须来自集合 {'x', 'y', 'z'}。对于内旋，seq 必须全部大写，并且其元素必须来自集合 {'X', 'Y', 'Z'}。

返回:

四元数: 从给定序列的欧拉角计算出的归一化旋转四元数。

示例

>>> from sympy import Quaternion
>>> from sympy import pi
>>> q = Quaternion.from_euler([pi/2, 0, 0], 'xyz')
>>> q
sqrt(2)/2 + sqrt(2)/2*i + 0*j + 0*k

>>> q = Quaternion.from_euler([0, pi/2, pi] , 'zyz')
>>> q
0 + (-sqrt(2)/2)*i + 0*j + sqrt(2)/2*k

>>> q = Quaternion.from_euler([0, pi/2, pi] , 'ZYZ')
>>> q
0 + sqrt(2)/2*i + 0*j + sqrt(2)/2*k

classmethod from_rotation_matrix(M)[源代码][源代码]¶

返回矩阵的等效四元数。仅当矩阵是特殊正交矩阵（正交且 det(M) = 1）时，四元数才会被归一化。

参数:

M矩阵: 要转换为等效四元数的输入矩阵。为了使四元数归一化，M 必须是特殊正交的（正交且 det(M) = 1）。

返回:

四元数: 给定矩阵的四元数等价形式。

示例

>>> from sympy import Quaternion
>>> from sympy import Matrix, symbols, cos, sin, trigsimp
>>> x = symbols('x')
>>> M = Matrix([[cos(x), -sin(x), 0], [sin(x), cos(x), 0], [0, 0, 1]])
>>> q = trigsimp(Quaternion.from_rotation_matrix(M))
>>> q
sqrt(2)*sqrt(cos(x) + 1)/2 + 0*i + 0*j + sqrt(2 - 2*cos(x))*sign(sin(x))/2*k

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

返回四元数的索引向量。

返回:

四元数：表示所提供四元数的索引向量。

参见

axis
norm

示例

>>> from sympy.algebras.quaternion import Quaternion
>>> q = Quaternion(2, 4, 2, 4)
>>> q.index_vector()
0 + 4*sqrt(10)/3*i + 2*sqrt(10)/3*j + 4*sqrt(10)/3*k

integrate(*args)[源代码][源代码]¶

计算四元数的积分。

返回:

四元数: 将四元数(self)与给定的变量进行整合。

示例

四元数的定积分 :

>>> from sympy import Quaternion
>>> from sympy.abc import x
>>> q = Quaternion(1, 2, 3, 4)
>>> q.integrate(x)
x + 2*x*i + 3*x*j + 4*x*k

四元数的定积分 :

>>> from sympy import Quaternion
>>> from sympy.abc import x
>>> q = Quaternion(1, 2, 3, 4)
>>> q.integrate((x, 1, 5))
4 + 8*i + 12*j + 16*k

inverse()[源代码][源代码]¶: 返回四元数的逆。

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

如果四元数是纯的则返回真，如果四元数不是纯的则返回假，如果未知则返回无。

参见

scalar_part

示例

>>> from sympy.algebras.quaternion import Quaternion
>>> q = Quaternion(0, 8, 13, 12)
>>> q.is_pure()
True

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

如果四元数是零四元数则返回 true，如果不是零四元数则返回 false，如果值未知则返回 None。

参见

scalar_part
vector_part

示例

>>> from sympy.algebras.quaternion import Quaternion
>>> q = Quaternion(1, 0, 0, 0)
>>> q.is_zero_quaternion()
False

>>> q = Quaternion(0, 0, 0, 0)
>>> q.is_zero_quaternion()
True

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

返回四元数的对数，由 $\log q$ 给出。

示例

>>> from sympy import Quaternion
>>> q = Quaternion(1, 2, 3, 4)
>>> q.log()
log(sqrt(30))
+ 2*sqrt(29)*acos(sqrt(30)/30)/29*i
+ 3*sqrt(29)*acos(sqrt(30)/30)/29*j
+ 4*sqrt(29)*acos(sqrt(30)/30)/29*k

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

返回四元数的范数（模）的自然对数。

参见

norm

示例

>>> from sympy.algebras.quaternion import Quaternion
>>> q = Quaternion(2, 4, 2, 4)
>>> q.mensor()
log(2*sqrt(10))
>>> q.norm()
2*sqrt(10)

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

四元数相乘。

参数:

其他四元数或符号: 要乘以当前（自身）四元数的四元数。

返回:

四元数: 将自身与另一个四元数相乘后的结果四元数

示例

>>> from sympy import Quaternion
>>> from sympy import symbols
>>> q1 = Quaternion(1, 2, 3, 4)
>>> q2 = Quaternion(5, 6, 7, 8)
>>> q1.mul(q2)
(-60) + 12*i + 30*j + 24*k
>>> q1.mul(2)
2 + 4*i + 6*j + 8*k
>>> x = symbols('x', real = True)
>>> q1.mul(x)
x + 2*x*i + 3*x*j + 4*x*k

复数域上的四元数：

>>> from sympy import Quaternion
>>> from sympy import I
>>> q3 = Quaternion(3 + 4*I, 2 + 5*I, 0, 7 + 8*I, real_field = False)
>>> q3.mul(2 + 3*I)
(2 + 3*I)*(3 + 4*I) + (2 + 3*I)*(2 + 5*I)*i + 0*j + (2 + 3*I)*(7 + 8*I)*k

norm()[源代码][源代码]¶: 返回四元数的范数。

normalize()[源代码][源代码]¶: 返回四元数的归一化形式。

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

返回两个四元数的正交性。

参数:

其他一个四元数

返回:

真如果两个纯四元数被视为3D向量是正交的。
假如果将两个纯四元数视为3D向量时，它们不是正交的。
无如果将两个纯四元数视为3D向量是否正交是未知的。

示例

>>> from sympy.algebras.quaternion import Quaternion
>>> q = Quaternion(0, 4, 4, 4)
>>> q1 = Quaternion(0, 8, 8, 8)
>>> q.orthogonal(q1)
False

>>> q1 = Quaternion(0, 2, 2, 0)
>>> q = Quaternion(0, 2, -2, 0)
>>> q.orthogonal(q1)
True

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

如果两个纯四元数被视为3D向量时是平行的，则返回True。

参数:

其他一个四元数

返回:

真如果两个纯四元数被视为3D向量是平行的。
假如果两个纯四元数被视为3D向量时并不平行。
无如果将两个纯四元数视为3D向量是否平行是未知的。

示例

>>> from sympy.algebras.quaternion import Quaternion
>>> q = Quaternion(0, 4, 4, 4)
>>> q1 = Quaternion(0, 8, 8, 8)
>>> q.parallel(q1)
True

>>> q1 = Quaternion(0, 8, 13, 12)
>>> q.parallel(q1)
False

pow(p)[源代码][源代码]¶

找到四元数的 p 次幂。

参数:

p整数: 应用于四元数的幂。

返回:

四元数: 返回当前四元数的 p 次幂。如果 p = -1，则返回其逆。

示例

>>> from sympy import Quaternion
>>> q = Quaternion(1, 2, 3, 4)
>>> q.pow(4)
668 + (-224)*i + (-336)*j + (-448)*k

pow_cos_sin(p)[源代码][源代码]¶

计算余弦-正弦形式中的p次幂。

参数:

p整数: 应用于四元数的幂。

返回:

四元数: 余弦-正弦形式中的 p 次幂。

示例

>>> from sympy import Quaternion
>>> q = Quaternion(1, 2, 3, 4)
>>> q.pow_cos_sin(4)
900*cos(4*acos(sqrt(30)/30))
+ 1800*sqrt(29)*sin(4*acos(sqrt(30)/30))/29*i
+ 2700*sqrt(29)*sin(4*acos(sqrt(30)/30))/29*j
+ 3600*sqrt(29)*sin(4*acos(sqrt(30)/30))/29*k

property product_matrix_left¶

返回一个等效于从左侧进行Hamilton乘积的4 x 4矩阵。这在将四元数元素视为列向量时非常有用。给定一个四元数 $q = a + bi + cj + dk$ 其中a, b, c和d是实数，左侧的乘积矩阵为：

\[\begin{split}M = \begin{bmatrix} a &-b &-c &-d \\ b & a &-d & c \\ c & d & a &-b \\ d &-c & b & a \end{bmatrix}\end{split}\]

示例

>>> from sympy import Quaternion
>>> from sympy.abc import a, b, c, d
>>> q1 = Quaternion(1, 0, 0, 1)
>>> q2 = Quaternion(a, b, c, d)
>>> q1.product_matrix_left
Matrix([
[1, 0,  0, -1],
[0, 1, -1,  0],
[0, 1,  1,  0],
[1, 0,  0,  1]])

>>> q1.product_matrix_left * q2.to_Matrix()
Matrix([
[a - d],
[b - c],
[b + c],
[a + d]])

这相当于：

>>> (q1 * q2).to_Matrix()
Matrix([
[a - d],
[b - c],
[b + c],
[a + d]])

property product_matrix_right¶

返回一个等效于从右侧进行 Hamilton 乘积的 4 x 4 矩阵。这在将四元数元素视为列向量时非常有用。给定一个四元数 $q = a + bi + cj + dk$ 其中 a, b, c 和 d 是实数，左侧的乘积矩阵为：

\[\begin{split}M = \begin{bmatrix} a &-b &-c &-d \\ b & a & d &-c \\ c &-d & a & b \\ d & c &-b & a \end{bmatrix}\end{split}\]

示例

>>> from sympy import Quaternion
>>> from sympy.abc import a, b, c, d
>>> q1 = Quaternion(a, b, c, d)
>>> q2 = Quaternion(1, 0, 0, 1)
>>> q2.product_matrix_right
Matrix([
[1, 0, 0, -1],
[0, 1, 1, 0],
[0, -1, 1, 0],
[1, 0, 0, 1]])

注意交换的参数：矩阵代表右边的四元数，但仍被视为从左边进行的矩阵乘法。

>>> q2.product_matrix_right * q1.to_Matrix()
Matrix([
[ a - d],
[ b + c],
[-b + c],
[ a + d]])

这相当于：

>>> (q1 * q2).to_Matrix()
Matrix([
[ a - d],
[ b + c],
[-b + c],
[ a + d]])

static rotate_point(pin, r)[源代码][源代码]¶

返回旋转后的点针（一个三元组）的坐标。

参数:

固定元组

一个包含需要旋转的点的坐标的3元素元组。

r四元数或元组

旋转的轴和角度。

需要注意的是，当 r 是一个元组时，它必须是 (轴, 角度) 的形式。

返回:

元组: 旋转后点的坐标。

示例

>>> from sympy import Quaternion
>>> from sympy import symbols, trigsimp, cos, sin
>>> x = symbols('x')
>>> q = Quaternion(cos(x/2), 0, 0, sin(x/2))
>>> trigsimp(Quaternion.rotate_point((1, 1, 1), q))
(sqrt(2)*cos(x + pi/4), sqrt(2)*sin(x + pi/4), 1)
>>> (axis, angle) = q.to_axis_angle()
>>> trigsimp(Quaternion.rotate_point((1, 1, 1), (axis, angle)))
(sqrt(2)*cos(x + pi/4), sqrt(2)*sin(x + pi/4), 1)

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

返回四元数 q 的标量部分($\mathbf{S}(q)$)。

示例

>>> from sympy.algebras.quaternion import Quaternion
>>> q = Quaternion(4, 8, 13, 12)
>>> q.scalar_part()
4

set_norm(norm)[源代码][源代码]¶

设置已实例化的四元数的范数。

参数:

规范无或数字: 预定义的四元数范数。如果给定一个值，Quaternion.norm 将返回这个预定义的值，而不是计算范数。

示例

>>> from sympy import Quaternion
>>> from sympy.abc import a, b, c, d
>>> q = Quaternion(a, b, c, d)
>>> q.norm()
sqrt(a**2 + b**2 + c**2 + d**2)

设定规范：

>>> q.set_norm(1)
>>> q.norm()
1

移除集合范数：

>>> q.set_norm(None)
>>> q.norm()
sqrt(a**2 + b**2 + c**2 + d**2)

to_Matrix(vector_only=False)[源代码][源代码]¶

返回四元数的元素作为一个列向量。默认情况下，返回一个长度为4的``Matrix``，其中实部作为第一个元素。如果``vector_only``为``True``，则仅返回长度为3的Matrix的虚部。

参数:

仅向量布尔: 如果为 True，则仅返回虚部。默认值：False

返回:

矩阵: 由四元数元素构成的列向量。

示例

>>> from sympy import Quaternion
>>> from sympy.abc import a, b, c, d
>>> q = Quaternion(a, b, c, d)
>>> q
a + b*i + c*j + d*k

>>> q.to_Matrix()
Matrix([
[a],
[b],
[c],
[d]])

>>> q.to_Matrix(vector_only=True)
Matrix([
[b],
[c],
[d]])

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

返回四元数的旋转轴和角度。

返回:

元组: 元组 (轴, 角度)

示例

>>> from sympy import Quaternion
>>> q = Quaternion(1, 1, 1, 1)
>>> (axis, angle) = q.to_axis_angle()
>>> axis
(sqrt(3)/3, sqrt(3)/3, sqrt(3)/3)
>>> angle
2*pi/3

to_euler( seq, angle_addition=True, avoid_square_root=False, )[源代码][源代码]¶

返回表示与四元数相同旋转的欧拉角，顺序由 seq 给出。此方法实现参考了 [1]。

对于退化情况（万向节锁情况），第三个角度设置为零。

参数:

seq长度为3的字符串

表示旋转的序列。对于外旋，seq 必须全部小写，并且其元素必须来自集合 {'x', 'y', 'z'}。对于内旋，seq 必须全部大写，并且其元素必须来自集合 {'X', 'Y', 'Z'}。

angle_addition布尔

当为 True 时，第一和第三角度作为两个更简单的 atan2 表达式的加减给出。当为 False 时，第一和第三角度分别由一个更复杂的 atan2 表达式给出。这个等价的表达式由以下公式给出：

\[\operatorname{atan_2} (b,a) \pm \operatorname{atan_2} (d,c) = \operatorname{atan_2} (bc\pm ad, ac\mp bd)\]

默认值：True

避免平方根布尔

当为 True 时，第二个角度通过基于 acos 的表达式计算，这稍微复杂一些，但避免了平方根。当为 False 时，第二个角度通过 atan2 计算，这更简单，并且在数值上可能更好（某些数值实现的 acos 在接近零时存在问题）。默认值：False

返回:

元组: 从四元数计算出的欧拉角

参考文献

[1]

https://doi.org/10.1371/journal.pone.0276302

示例

>>> from sympy import Quaternion
>>> from sympy.abc import a, b, c, d
>>> euler = Quaternion(a, b, c, d).to_euler('zyz')
>>> euler
(-atan2(-b, c) + atan2(d, a),
 2*atan2(sqrt(b**2 + c**2), sqrt(a**2 + d**2)),
 atan2(-b, c) + atan2(d, a))

to_rotation_matrix( v=None, homogeneous=True, )[源代码][源代码]¶

如果未传递 v ，则返回表示围绕原点旋转的四元数的等效旋转变换矩阵。

参数:

v元组或无: 默认值：无
同质布尔: 当为 True 时，提供了一个可能在符号计算中更高效但在直接求值中效率较低的表达式。这两个公式在数学上是等价的。默认值：True

返回:

元组: 如果没有传递 v，则返回表示围绕原点旋转的四元数的等效旋转变换矩阵。

示例

>>> from sympy import Quaternion
>>> from sympy import symbols, trigsimp, cos, sin
>>> x = symbols('x')
>>> q = Quaternion(cos(x/2), 0, 0, sin(x/2))
>>> trigsimp(q.to_rotation_matrix())
Matrix([
[cos(x), -sin(x), 0],
[sin(x),  cos(x), 0],
[     0,       0, 1]])

如果传递了点(v)作为参数，则生成一个4x4的变换矩阵（用于围绕原点以外的点旋转）。

classmethod vector_coplanar(q1, q2, q3)[源代码][源代码]¶

如果将纯四元数视为3D向量的 q1、q2 和 q3 的轴共面，则返回 True。

参数:

q1: 一个纯四元数。
q2: 一个纯四元数。
q3: 一个纯四元数。

返回:

真如果将纯四元数视为3D向量的轴
q1、q2 和 q3 共面。
假如果将纯四元数视为3D向量的轴
q1, q2 和 q3 不共面。
无如果将纯四元数视为3D向量的轴
q1、q2 和 q3 是否共面尚不确定。

参见

axis
is_pure

示例

>>> from sympy.algebras.quaternion import Quaternion
>>> q1 = Quaternion(0, 4, 4, 4)
>>> q2 = Quaternion(0, 8, 8, 8)
>>> q3 = Quaternion(0, 24, 24, 24)
>>> Quaternion.vector_coplanar(q1, q2, q3)
True

>>> q1 = Quaternion(0, 8, 16, 8)
>>> q2 = Quaternion(0, 8, 3, 12)
>>> Quaternion.vector_coplanar(q1, q2, q3)
False

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

返回四元数 $q$ 的向量部分 $\mathbf{V}(q)$。

示例

>>> from sympy.algebras.quaternion import Quaternion
>>> q = Quaternion(1, 1, 1, 1)
>>> q.vector_part()
0 + 1*i + 1*j + 1*k

>>> q = Quaternion(4, 8, 13, 12)
>>> q.vector_part()
0 + 8*i + 13*j + 12*k