\h{ SSKJr SSKJr SSKJr SSKJrJrJ r J r SSK J r J r SSKJr SSKJrJrJr SSKJrJr SS KJr SS KJr SS KJr SS KJrJ r SS K!J"r" SSK#J$r$J%r% SSK&J'r' SSK(J)r) Sr*Sr+"SS\"5r,g))Rational)S)is_eq) conjugateimresign)explog)sqrt)acosasinatan2)cossin)trigsimp integrate)MutableDenseMatrix)sympify_sympify)Expr) fuzzy_notfuzzy_or)as_int) prec_to_dpscUbtUR(abURSLa [S5e[SU55nU(a.[ US-[ SU555SLa [S5egggg)z$validate if input norm is consistentNFzInput norm must be positive.c3b# UH%oR=(a URSLv M' g7f)TN) is_numberis_real.0is Q/var/www/auris/envauris/lib/python3.13/site-packages/sympy/algebras/quaternion.py _check_norm..s#L8a 9 T(998s-/c3*# UH oS-v M g7f)r'Nr!s r$r%r&s+C(QqD(szIncompatible value for norm.)r is_positive ValueErrorallrsum)elementsnorm numericals r$ _check_normr1st DNN   u $;< <L8LL tQw+C(+C(CDM;< <N9 +c[U5[:wa [S5e[U5S:wa[SR U55eUR 5nUR 5nU(dU(d [S5eUR5up4nX4:XdXE:Xa [S5e[U5[S5- nU(a)[SR SRU555eU$) zGvalidate seq and return True if seq is lowercase and False if uppercasezExpected seq to be a string.zExpected 3 axes, got `{}`.zkseq must either be fully uppercase (for extrinsic rotations), or fully lowercase, for intrinsic rotations).z"Consecutive axes must be differentxyzXYZzNExpected axes from `seq` to be from ['x', 'y', 'z'] or ['X', 'Y', 'Z'], got {}) typestrr+lenformatisupperislowerlowersetjoin)seq intrinsic extrinsicr#jkbads r$ _is_extrinsicrFs CyC788 3x1}5<> c(S] "C ""(&"68 8 r2c^\rSrSrSrSrSrS=U4SjjrSr\ S5r \ S5r \ S 5r \ S 5r \ S 5r\ S 5r\ S 5rS>Sjr\S5r\S5rS?Sjr\S5r\S5rSrSrSrSrSrSrSrSrSr Sr!Sr"Sr#S r$\%S!5r&S"r'S#r(S$r)S%r*S&r+S'r,S(r-S)r.S*r/S+r0S,r1\%S-5r2S.r3S@S/jr4S0r5S1r6S2r7S3r8S4r9S5r:S6r;\S75rS:r?S;r@S>> from sympy import Quaternion >>> q = Quaternion(1, 2, 3, 4) >>> q 1 + 2*i + 3*j + 4*k Quaternions over complex fields can be defined as: >>> 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 Defining symbolic unit quaternions: >>> 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 References ========== .. [1] https://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/ .. [2] https://en.wikipedia.org/wiki/Quaternion g&@Fc>[[XX445upp4[SXX4455(a [S5e[TU]XX#U5nXWlURU5 U$)Nc3<# UHoRSLv M g7f)FN)is_commutativer!s r$r%%Quaternion.__new__..rs?,Q5(,sz arguments have to be commutative)mapranyr+super__new__ _real_fieldset_norm) clsabcd real_fieldr/obj __class__s r$rQQuaternion.__new__os`1,/ a ?1,? ? ??@ @gocaA.$ T r2cR[U5n[URU5 Xlg)aSets norm of an already instantiated quaternion. Parameters ========== norm : None or number Pre-defined quaternion norm. If a value is given, Quaternion.norm returns this pre-defined value instead of calculating the norm Examples ======== >>> 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) Setting the norm: >>> q.set_norm(1) >>> q.norm() 1 Removing set norm: >>> q.set_norm(None) >>> q.norm() sqrt(a**2 + b**2 + c**2 + d**2) N)rr1args_norm)selfr/s r$rSQuaternion.set_normys!@t}DIIt$ r2c URS$)Nrr^r`s r$rU Quaternion.ayy|r2c URS$)Nrcrds r$rV Quaternion.brfr2c URS$)Nr'rcrds r$rW Quaternion.crfr2c URS$)Nr4rcrds r$rX Quaternion.drfr2cUR$N)rRrds r$rYQuaternion.real_fieldsr2c [URUR*UR*UR*/URURUR*UR/URURURUR*/URUR*URUR//5$)aReturns 4 x 4 Matrix equivalent to a Hamilton product from the left. This can be useful when treating quaternion elements as column vectors. Given a quaternion $q = a + bi + cj + dk$ where a, b, c and d are real numbers, the product matrix from the left is: .. math:: M = \begin{bmatrix} a &-b &-c &-d \\ b & a &-d & c \\ c & d & a &-b \\ d &-c & b & a \end{bmatrix} Examples ======== >>> 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]]) This is equivalent to: >>> (q1 * q2).to_Matrix() Matrix([ [a - d], [b - c], [b + c], [a + d]]) MatrixrUrVrWrXrds r$product_matrix_leftQuaternion.product_matrix_leftsX$&&466'DFF73$&&$&&1$&&1$&&$&&$&&1 34 4r2c [URUR*UR*UR*/URURURUR*/URUR*URUR/URURUR*UR//5$)a%Returns 4 x 4 Matrix equivalent to a Hamilton product from the right. This can be useful when treating quaternion elements as column vectors. Given a quaternion $q = a + bi + cj + dk$ where a, b, c and d are real numbers, the product matrix from the left is: .. math:: M = \begin{bmatrix} a &-b &-c &-d \\ b & a & d &-c \\ c &-d & a & b \\ d & c &-b & a \end{bmatrix} Examples ======== >>> 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]]) Note the switched arguments: the matrix represents the quaternion on the right, but is still considered as a matrix multiplication from the left. >>> q2.product_matrix_right * q1.to_Matrix() Matrix([ [ a - d], [ b + c], [-b + c], [ a + d]]) This is equivalent to: >>> (q1 * q2).to_Matrix() Matrix([ [ a - d], [ b + c], [-b + c], [ a + d]]) rrrds r$product_matrix_rightQuaternion.product_matrix_rightsb$&&466'DFF73$&&1$&&$&&$&&1$&&$&&1 34 4r2cjU(a[URSS5$[UR5$)aReturns elements of quaternion as a column vector. By default, a ``Matrix`` of length 4 is returned, with the real part as the first element. If ``vector_only`` is ``True``, returns only imaginary part as a Matrix of length 3. Parameters ========== vector_only : bool If True, only imaginary part is returned. Default value: False Returns ======= Matrix A column vector constructed by the elements of the quaternion. Examples ======== >>> 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]]) rhN)rsr^)r` vector_onlys r$ to_MatrixQuaternion.to_Matrixs,X $))AB-( ($))$ $r2c[U5nUS:wa US:wa[SRU55eUS:Xa [S/UQ76$[U6$)aKReturns quaternion from elements of a column vector`. If vector_only is True, returns only imaginary part as a Matrix of length 3. Parameters ========== elements : Matrix, list or tuple of length 3 or 4. If length is 3, assume real part is zero. Default value: False Returns ======= Quaternion A quaternion created from the input elements. Examples ======== >>> 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 r4z7Input elements must have length 3 or 4, got {} elementsr)r9r+r:rH)rTr.lengths r$ from_MatrixQuaternion.from_MatrixKsZBX Q;6Q;((.v8 8 Q;a+(+ +x( (r2c[U5S:wa [S5e[U5nUR5upEnSVs/sH owU:XaSOSPM nnSVs/sH owU:XaSOSPM n nSVs/sH owU:XaSOSPM n nUR XS5n UR XS5n UR XS5n U(a[ X-U -5$[ X-U -5$s snfs snfs snf)aReturns quaternion equivalent to rotation represented by the Euler angles, in the sequence defined by ``seq``. Parameters ========== angles : list, tuple or Matrix of 3 numbers The Euler angles (in radians). seq : string of length 3 Represents the sequence of rotations. For extrinsic rotations, seq must be all lowercase and its elements must be from the set ``{'x', 'y', 'z'}`` For intrinsic rotations, seq must be all uppercase and its elements must be from the set ``{'X', 'Y', 'Z'}`` Returns ======= Quaternion The normalized rotation quaternion calculated from the Euler angles in the given sequence. Examples ======== >>> 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 r4z3 angles must be given.xyzrhrr')r9r+rFr=from_axis_angler)rTanglesr@rBr#rCrDneiejekqiqjqks r$ from_eulerQuaternion.from_eulervsV v;! 67 7!#& ))+a+0 0%Q6aq % 0*/ 0%Q6aq % 0*/ 0%Q6aq % 0 AY /  AY /  AY / BGbL) )BGbL) )1 0 0sC'C,/C1c UR5(a [S5e/SQn[U5nUR5upgnSR U5S-nSR U5S-nSR U5S-nU(dXpXh:Hn U (aSU- U- nXg- Xx- -X- -S-n UR UR URUR/n U Sn Xn XnXU -nU (dX- X-X-X- 4uppU(avU (a6UR5S-n[X-X--X-- X-- U- 5US'OSUR5S--n[X-X--X-- X-- U- 5US'OWS[[X-X--5[X-X--55-US'U (dUS==[RS- -ss'Sn[!U[R"5(a![!U[R"5(aSn[!U [R"5(a![!U [R"5(aSnUS:XawU(a5[X5[X5-US'[X5[X5- US'O[X-X--X-X-- 5US'[X-X-- X-X--5US'Oc[R"USU(+-'US:XaS[X5-USU-'O-S[X5-USU-'USU-==U(aSOS-ss'U (d US==U -ss'U(a[%US S S25$[%U5$) aReturns Euler angles representing same rotation as the quaternion, in the sequence given by ``seq``. This implements the method described in [1]_. For degenerate cases (gymbal lock cases), the third angle is set to zero. Parameters ========== seq : string of length 3 Represents the sequence of rotations. For extrinsic rotations, seq must be all lowercase and its elements must be from the set ``{'x', 'y', 'z'}`` For intrinsic rotations, seq must be all uppercase and its elements must be from the set ``{'X', 'Y', 'Z'}`` angle_addition : bool When True, first and third angles are given as an addition and subtraction of two simpler ``atan2`` expressions. When False, the first and third angles are each given by a single more complicated ``atan2`` expression. This equivalent expression is given by: .. math:: \operatorname{atan_2} (b,a) \pm \operatorname{atan_2} (d,c) = \operatorname{atan_2} (bc\pm ad, ac\mp bd) Default value: True avoid_square_root : bool When True, the second angle is calculated with an expression based on ``acos``, which is slightly more complicated but avoids a square root. When False, second angle is calculated with ``atan2``, which is simpler and can be better for numerical reasons (some numerical implementations of ``acos`` have problems near zero). Default value: False Returns ======= Tuple The Euler angles calculated from the quaternion Examples ======== >>> 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)) References ========== .. [1] https://doi.org/10.1371/journal.pone.0276302 z(Cannot convert a quaternion with norm 0.)rrrrrhr'rN)is_zero_quaternionr+rFr=indexrUrVrWrXr/r rrr rPirZerotuple)r`r@angle_additionavoid_square_rootrrBr#rCrD symmetricr r.rUrVrWrXn2cases r$to_eulerQuaternion.to_eulers4@  " " $ $GH H!#& ))+a KKNQ  KKNQ  KKNQ qF A A!% AE*a/FFDFFDFFDFF3 QK K K K$ quae3JA! YY[!^ !%!%-!%"7!%"?2!EFq a' !%!%-!%"7!%"?2!EFq E$ququ}"5tAEAEM7JKKF1Iq QTTAX%  AFF  a 0 0D AFF  a 0 0D 19!!K%+5q !!K%+5q !!#)QS13Y7q !!#)QS13Y7q +,&&F1I & 'qy()E!Kq9}%()E!Kq9}%q9}% "qA% 1I I "& &= r2cUup4n[US-US--US--5nX6- XF- XV- pTn[U[R-5n[ U[R-5nX7-n XG-n XW-n U"XX5$)a8Returns a rotation quaternion given the axis and the angle of rotation. Parameters ========== vector : tuple of three numbers The vector representation of the given axis. angle : number The angle by which axis is rotated (in radians). Returns ======= Quaternion The normalized rotation quaternion calculated from the given axis and the angle of rotation. Examples ======== >>> 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 r')r rrHalfr) rTvectoranglexyzr/srUrVrWrXs r$rQuaternion.from_axis_angleDs8 qAqD1a4K!Q$&'Xqxq     E E E 1r2cUR5[SS5-n[X!S-US-US-5S- n[X!S-US- US- 5S- n[X!S- US-US- 5S- n[X!S- US- US-5S- nU[USUS- 5-nU[US US - 5-nU[US US - 5-n[ X4XV5$) aReturns the equivalent quaternion of a matrix. The quaternion will be normalized only if the matrix is special orthogonal (orthogonal and det(M) = 1). Parameters ========== M : Matrix Input matrix to be converted to equivalent quaternion. M must be special orthogonal (orthogonal and det(M) = 1) for the quaternion to be normalized. Returns ======= Quaternion The quaternion equivalent to given matrix. Examples ======== >>> 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 rhr4)rr)rhrh)r'r'r')r'rh)rhr')rr')r'r)rhr)rrh)detrr r rH)rTMabsQrUrVrWrXs r$from_rotation_matrixQuaternion.from_rotation_matrixos>uuwA& $!D')AdG3 4q 8 $!D')AdG3 4q 8 $!D')AdG3 4q 8 $!D')AdG3 4q 8 QtWqw&' ' QtWqw&' ' QtWqw&' '!%%r2c$URU5$roaddr`others r$__add__Quaternion.__add__xxr2c$URU5$rorrs r$__radd__Quaternion.__radd__rr2c*URUS-5$Nrrrs r$__sub__Quaternion.__sub__sxxb!!r2c8URU[U55$ro _generic_mulrrs r$__mul__Quaternion.__mul__s  x77r2c8UR[U5U5$rorrs r$__rmul__Quaternion.__rmul__s  %$77r2c$URU5$ro)pow)r`ps r$__pow__Quaternion.__pow__sxx{r2cv[UR*UR*UR*UR*5$ro)rHrUrVrWrXrds r$__neg__Quaternion.__neg__s+466'DFF7TVVGdffW==r2c$U[U5S--$rrrs r$ __truediv__Quaternion.__truediv__sgenb(((r2c$[U5US--$rrrs r$ __rtruediv__Quaternion.__rtruediv__su~b((r2c UR"U6$rorr`r^s r$_eval_IntegralQuaternion._eval_Integrals~~t$$r2c URSS5 UR"URVs/sHo3R"U0UD6PM sn6$s snf)NevaluateT) setdefaultfuncr^diff)r`symbolskwargsrUs r$rQuaternion.diffsC*d+yy J !6675f5 JKKJsA cUn[U5n[U[5(dUR(a_UR(aN[[ U5UR -[U5UR-URUR5$UR(a9[UR U-URURUR5$[S5e[UR UR -URUR-URUR-URUR-5$)aAdds quaternions. Parameters ========== other : Quaternion The quaternion to add to current (self) quaternion. Returns ======= Quaternion The resultant quaternion after adding self to other Examples ======== >>> 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 Quaternions over complex fields : >>> 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 z> !_``"$$+rttbdd{BDD244KDDB!" "r2c8URU[U55$)aMultiplies quaternions. Parameters ========== other : Quaternion or symbol The quaternion to multiply to current (self) quaternion. Returns ======= Quaternion The resultant quaternion after multiplying self with other Examples ======== >>> 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 Quaternions over complex fields : >>> 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 rrs r$mulQuaternion.mulsN  x77r2c[U[5(d[U[5(dX-$[U[5(dUR(a4UR(a#[[ U5[ U5SS5U-$UR (a>[XR-XR-XR-XR-5$[S5e[U[5(dUR(a4UR(a#U[[ U5[ U5SS5-$UR (a>[XR-XR-XR-XR-5$[S5eURcURcSnO!UR5UR5-n[UR*UR-URUR-- URUR-- URUR--URUR-URUR--URUR-- URUR--UR*UR-URUR--URUR--URUR--URUR-URUR-- URUR--URUR--US9$)aGeneric multiplication. Parameters ========== q1 : Quaternion or symbol q2 : Quaternion or symbol It is important to note that if neither q1 nor q2 is a Quaternion, this function simply returns q1 * q2. Returns ======= Quaternion The resultant quaternion after multiplying q1 and q2 Examples ======== >>> from sympy import Quaternion >>> from sympy import Symbol, S >>> q1 = Quaternion(1, 2, 3, 4) >>> q2 = Quaternion(5, 6, 7, 8) >>> Quaternion._generic_mul(q1, q2) (-60) + 12*i + 30*j + 24*k >>> Quaternion._generic_mul(q1, S(2)) 2 + 4*i + 6*j + 8*k >>> x = Symbol('x', real = True) >>> Quaternion._generic_mul(q1, x) x + 2*x*i + 3*x*j + 4*x*k Quaternions over complex fields : >>> from sympy import I >>> q3 = Quaternion(3 + 4*I, 2 + 5*I, 0, 7 + 8*I, real_field = False) >>> Quaternion._generic_mul(q3, 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 rzAOnly commutative expressions can be multiplied with a Quaternion.Nr/)rrHrYrrrrLrUrVrWrXr+r_r/)rrr/s r$rQuaternion._generic_muls`V"j))*R2L2L7N"j))}}!"R&"R&!Q7"<<""!"tt)R$$YTT 29MM !dee"j))}}Jr"vr"vq!<<<""!"tt)R$$YTT 29MM !dee 88  0D779rwwy(D244%*rttBDDy02449>r2cURcSUn[[URS-URS--UR S--UR S--55$UR$)z#Returns the norm of the quaternion.r')r_r rrUrVrWrXrs r$r/Quaternion.normms[ :: Aa!##q&1336!9ACCF!BCD Dzzr2c2UnUSUR5- -$)z.Returns the normalized form of the quaternion.rhrrs r$ normalizeQuaternion.normalizews AaffhJr2cUnUR5(d [S5e[U5SUR5S-- -$)z&Returns the inverse of the quaternion.z6Cannot compute inverse for a quaternion with zero normrhr')r/r+rrs r$inverseQuaternion.inverse|s; vvxxUV V|q1}--r2cU[U5pUS:aUR5U*pUS:XaU$[ SSSS5nUS:aUS-(aX2-nX"-nUS-nUS:aMU$![a [s$f=f)akFinds the pth power of the quaternion. Parameters ========== p : int Power to be applied on quaternion. Returns ======= Quaternion Returns the p-th power of the current quaternion. Returns the inverse if p = -1. Examples ======== >>> from sympy import Quaternion >>> q = Quaternion(1, 2, 3, 4) >>> q.pow(4) 668 + (-224)*i + (-336)*j + (-448)*k rrh)rr+NotImplementedrrH)r`rrress r$rQuaternion.pows2 "q q599;q 6HAq!$!e1u FA !GA !e  ! "! ! "s A##A65A6cUn[URS-URS--URS--5n[ UR 5[ U5-n[ UR 5[U5-UR-U- n[ UR 5[U5-UR-U- n[ UR 5[U5-UR-U- n[X4XV5$)aKReturns the exponential of $q$, given by $e^q$. Returns ======= Quaternion The exponential of the quaternion. Examples ======== >>> 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 r') r rVrWrXr rUrrrH)r`r vector_normrUrVrWrXs r$r Quaternion.exps, 1336ACCF?QSS!V34 Hs;' ' Hs;' '!## - ; Hs;' '!## - ; Hs;' '!## - ;!%%r2cUn[URS-URS--URS--5nUR 5n[ U5nUR[ URU- 5-U- nUR[ URU- 5-U- nUR[ URU- 5-U- n[XEXg5$)aReturns the logarithm of the quaternion, given by $\log q$. Examples ======== >>> 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 r') r rVrWrXr/lnr rUrH)r`rrq_normrUrVrWrXs r$r Quaternion.logs 1336ACCF?QSS!V34  vJ CC$qssV|$ ${ 2 CC$qssV|$ ${ 2 CC$qssV|$ ${ 2!%%r2cURVs/sHo"R"U6PM nnURnUbUR"U6n[X45 [ USU06$s snf)Nr/)r^subsr_r1rH)r`r^r#r.r/s r$ _eval_subsQuaternion._eval_subssZ+/9959aFFDM95zz  99d#DH#8/$// 6sAc [U5n[URVs/sHo3RUS9PM sn6$s snf)aReturns the floating point approximations (decimal numbers) of the quaternion. Returns ======= Quaternion Floating point approximations of quaternion(self) Examples ======== >>> from sympy import Quaternion >>> from sympy import sqrt >>> q = Quaternion(1/sqrt(1), 1/sqrt(2), 1/sqrt(3), 1/sqrt(4)) >>> q.evalf() 1.00000000000000 + 0.707106781186547*i + 0.577350269189626*j + 0.500000000000000*k )r)rrHr^evalf)r`precnprecargs r$ _eval_evalfQuaternion._eval_evalfs8,D!$))D)3III.)DEEDs;cUnUR5up4[RX1U-5nXRR5U--$)aComputes the pth power in the cos-sin form. Parameters ========== p : int Power to be applied on quaternion. Returns ======= Quaternion The p-th power in the cos-sin form. Examples ======== >>> 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 ) to_axis_anglerHrr/)r`rrvrrs r$ pow_cos_sinQuaternion.pow_cos_sin s>< __&   ' 'u9 5VVXq[!!r2c [[UR/UQ76[UR/UQ76[UR/UQ76[UR /UQ765$)aComputes integration of quaternion. Returns ======= Quaternion Integration of the quaternion(self) with the given variable. Examples ======== Indefinite Integral of quaternion : >>> 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 Definite integral of quaternion : >>> 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 )rHrrUrVrWrXrs r$rQuaternion.integrate-sT:)DFF2T2Idff4Lt4L#DFF2T2Idff4Lt4LN Nr2c[U[5(a[RUSUS5nOUR 5nU[SUSUSUS5-[ U5-nUR URUR4$)a>Returns the coordinates of the point pin (a 3 tuple) after rotation. Parameters ========== pin : tuple A 3-element tuple of coordinates of a point which needs to be rotated. r : Quaternion or tuple Axis and angle of rotation. It's important to note that when r is a tuple, it must be of the form (axis, angle) Returns ======= tuple The coordinates of the point after rotation. Examples ======== >>> 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) rrhr') rrrHrrrrVrWrX)pinrrpouts r$ rotate_pointQuaternion.rotate_pointMs|H a  **1Q416A A:aQQQ889Q<G''r2cUnURR(aUS-nUR5n[S[ UR5-5n[ SURUR-- 5n[UR U- 5n[URU- 5n[URU- 5nXEU4nXr4nU$)a"Returns the axis and angle of rotation of a quaternion. Returns ======= tuple Tuple of (axis, angle) Examples ======== >>> 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 rr'rh) rU is_negativerrr r rVrWrX) r`rrrrrrrts r$rQuaternion.to_axis_anglezs*  33??BA KKMT!##Y' QSSW  QSS1W  QSS1W  QSS1W  1I Jr2c RUnUR5S-nU(aXCRS-URS--URS-- URS-- -nXCRS-URS-- URS--URS-- -nXCRS-URS-- URS-- URS---nOxSSU-URS-URS---- nSSU-URS-URS---- nSSU-URS-URS---- nSU-URUR-URUR-- -nSU-URUR-URUR---n SU-URUR-URUR---n SU-URUR-URUR-- -n SU-URUR-URUR-- -n SU-URUR-URUR---n U(d[ XXU /XU /XU//5$UupnXU-- X-- UU -- nXU -- X-- UU -- nUX-- X-- UU-- nS=n=nnSn[ XXU U/XU U/XUU/UUUU//5$)aReturns the equivalent rotation transformation matrix of the quaternion which represents rotation about the origin if ``v`` is not passed. Parameters ========== v : tuple or None Default value: None homogeneous : bool When True, gives an expression that may be more efficient for symbolic calculations but less so for direct evaluation. Both formulas are mathematically equivalent. Default value: True Returns ======= tuple Returns the equivalent rotation transformation matrix of the quaternion which represents rotation about the origin if v is not passed. Examples ======== >>> 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]]) Generates a 4x4 transformation matrix (used for rotation about a point other than the origin) if the point(v) is passed as an argument. r'rhr)r/rUrVrWrXrs)r`r homogeneousrrm00m11m22m01m02m10m12m20m21rrrm03m13m23m30m31m32m33s r$to_rotation_matrixQuaternion.to_rotation_matrixsN  FFHbL SS!Vacc1f_qssAv-Q67CSS!Vacc1f_qssAv-Q67CSS!Vacc1f_qssAv-Q67Cac1336ACCF?++Cac1336ACCF?++Cac1336ACCF?++Cc133qss7QSSW$%c133qss7QSSW$%c133qss7QSSW$%c133qss7QSSW$%c133qss7QSSW$%c133qss7QSSW$%Cc?SsOc_MN NIQ1e)ae#ae+Ce)ae#ae+Cae)ae#ae+C C #CCc3/#C1ES#.c30DFG Gr2cUR$)aReturns scalar part($\mathbf{S}(q)$) of the quaternion q. Explanation =========== Given a quaternion $q = a + bi + cj + dk$, returns $\mathbf{S}(q) = a$. Examples ======== >>> from sympy.algebras.quaternion import Quaternion >>> q = Quaternion(4, 8, 13, 12) >>> q.scalar_part() 4 )rUrds r$ scalar_partQuaternion.scalar_parts $vv r2cZ[SURURUR5$)a Returns $\mathbf{V}(q)$, the vector part of the quaternion $q$. Explanation =========== Given a quaternion $q = a + bi + cj + dk$, returns $\mathbf{V}(q) = bi + cj + dk$. Examples ======== >>> 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 r)rHrVrWrXrds r$ vector_partQuaternion.vector_parts!.!TVVTVVTVV44r2cUR5R5n[SURURUR 5$)a Returns $\mathbf{Ax}(q)$, the axis of the quaternion $q$. Explanation =========== Given a quaternion $q = a + bi + cj + dk$, returns $\mathbf{Ax}(q)$ i.e., the versor of the vector part of that quaternion equal to $\mathbf{U}[\mathbf{V}(q)]$. The axis is always an imaginary unit with square equal to $-1 + 0i + 0j + 0k$. Examples ======== >>> 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 See Also ======== vector_part r)r8rrHrVrWrX)r`axiss r$r;Quaternion.axiss82!++-!TVVTVVTVV44r2c.URR$)a Returns true if the quaternion is pure, false if the quaternion is not pure or returns none if it is unknown. Explanation =========== A pure quaternion (also a vector quaternion) is a quaternion with scalar part equal to 0. Examples ======== >>> from sympy.algebras.quaternion import Quaternion >>> q = Quaternion(0, 8, 13, 12) >>> q.is_pure() True See Also ======== scalar_part )rUis_zerords r$is_pureQuaternion.is_pure8s2vv~~r2c6UR5R$)a Returns true if the quaternion is a zero quaternion or false if it is not a zero quaternion and None if the value is unknown. Explanation =========== A zero quaternion is a quaternion with both scalar part and vector part equal to 0. Examples ======== >>> 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 See Also ======== scalar_part vector_part )r/r>rds r$rQuaternion.is_zero_quaternionSs<yy{"""r2ctS[UR5R5UR55-$)a Returns the angle of the quaternion measured in the real-axis plane. Explanation =========== Given a quaternion $q = a + bi + cj + dk$ where $a$, $b$, $c$ and $d$ are real numbers, returns the angle of the quaternion given by .. math:: \theta := 2 \operatorname{atan_2}\left(\sqrt{b^2 + c^2 + d^2}, {a}\right) Examples ======== >>> from sympy.algebras.quaternion import Quaternion >>> q = Quaternion(1, 4, 4, 4) >>> q.angle() 2*atan(4*sqrt(3)) r')rr8r/r5rds r$rQuaternion.angless1.5))+002D4D4D4FGGGr2c:UR5(dUR5(a [S5e[UR5UR5- R5UR5UR5-R5/5$)as Returns True if the transformation arcs represented by the input quaternions happen in the same plane. Explanation =========== Two quaternions are said to be coplanar (in this arc sense) when their axes are parallel. The plane of a quaternion is the one normal to its axis. Parameters ========== other : a Quaternion Returns ======= True : if the planes of the two quaternions are the same, apart from its orientation/sign. False : if the planes of the two quaternions are not the same, apart from its orientation/sign. None : if plane of either of the quaternion is unknown. Examples ======== >>> 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 See Also ======== vector_coplanar is_pure z)Neither of the given quaternions can be 0)rr+rr;rs r$ arc_coplanarQuaternion.arc_coplanarsvT  # # % %5+C+C+E+EHI I$))+ 4HHJTYY[[`[e[e[gMgL{L{L}~r2c[UR55(d<[UR55(d[UR55(a [S5e[URUR UR /URUR UR /URUR UR //5R5nUR$)a Returns True if the axis of the pure quaternions seen as 3D vectors ``q1``, ``q2``, and ``q3`` are coplanar. Explanation =========== Three pure quaternions are vector coplanar if the quaternions seen as 3D vectors are coplanar. Parameters ========== q1 A pure Quaternion. q2 A pure Quaternion. q3 A pure Quaternion. Returns ======= True : if the axis of the pure quaternions seen as 3D vectors q1, q2, and q3 are coplanar. False : if the axis of the pure quaternions seen as 3D vectors q1, q2, and q3 are not coplanar. None : if the axis of the pure quaternions seen as 3D vectors q1, q2, and q3 are coplanar is unknown. Examples ======== >>> 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 See Also ======== axis is_pure "The given quaternions must be pure) rr?r+rsrVrWrXrr>)rTrrq3rs r$vector_coplanarQuaternion.vector_coplanarsl RZZ\ " "i &=&=2::>> 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 z%The provided quaternions must be purerr?r+rrs r$parallelQuaternion.parallelsJJ T\\^ $ $ %--/(B(BDE E UZ';;==r2c[UR55(d[UR55(a [S5eX-X--R5$)a Returns the orthogonality of two quaternions. Explanation =========== Two pure quaternions are called orthogonal when their product is anti-commutative. Parameters ========== other : a Quaternion Returns ======= True : if the two pure quaternions seen as 3D vectors are orthogonal. False : if the two pure quaternions seen as 3D vectors are not orthogonal. None : if the two pure quaternions seen as 3D vectors are orthogonal is unknown. Examples ======== >>> 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 rIrNrs r$ orthogonalQuaternion.orthogonal"sJJ T\\^ $ $ %--/(B(BAB B UZ';;==r2cDUR5UR5-$)a Returns the index vector of the quaternion. Explanation =========== The index vector is given by $\mathbf{T}(q)$, the norm (or magnitude) of the quaternion $q$, multiplied by $\mathbf{Ax}(q)$, the axis of $q$. Returns ======= Quaternion: representing index vector of the provided quaternion. Examples ======== >>> 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 See Also ======== axis norm )r/r;rds r$ index_vectorQuaternion.index_vectorLs>yy{TYY[((r2c4[UR55$)a Returns the natural logarithm of the norm(magnitude) of the quaternion. Examples ======== >>> from sympy.algebras.quaternion import Quaternion >>> q = Quaternion(2, 4, 2, 4) >>> q.mensor() log(2*sqrt(10)) >>> q.norm() 2*sqrt(10) See Also ======== norm )rr/rds r$mensorQuaternion.mensorms*$))+r2)r_)rrrrTN)F)TF)NT)C__name__ __module__ __qualname____firstlineno____doc__ _op_priorityrLrQrSpropertyrUrVrWrXrYrtrwr{ classmethodrrrrrrrrrrrrrrrrrr staticmethodrrr/rrrr r rr rrrrr2r5r8r;r?rrrFrKrOrRrUrX__static_attributes__ __classcell__)r[s@r$rHrH:s!/`LN"H  /4/4b4444l/%b()()T=*=*~L!\((T)&)&V"88>))%L4"l'8RI%I%V?  .+Z&>&40F2!"FN@*(*(X&PJGX(525:6#@H4-@^99v(>T(>T)Br2rHN)-sympy.core.numbersrsympy.core.singletonrsympy.core.relationalr$sympy.functions.elementary.complexesrrrr &sympy.functions.elementary.exponentialr r r(sympy.functions.elementary.miscellaneousr (sympy.functions.elementary.trigonometricr rrrrsympy.simplify.trigsimprsympy.integrals.integralsrsympy.matrices.denserrssympy.core.sympifyrrsympy.core.exprrsympy.core.logicrrsympy.utilities.miscrmpmath.libmp.libmpfrr1rFrHr)r2r$rtsS'"'JJC9HH?,/=0 0'+=6HHr2