+ i{ ^RIHt^RIHt^RIHt^RIHtHtH t H t ^RI H t H t^RIHt^RIHtHtHt^RIHtHt^R IHt^R IHt^R IHt^R IHtH t ^R I!H"t"^RI#H$t$H%t%^RI&H't'^RI(H)t)Rt*Rt+!RR]"4t,R#))Rational)S)is_eq) conjugateimresign)explog)sqrt)acosasinatan2)cossin)trigsimp integrate)MutableDenseMatrix)sympify_sympify)Expr) fuzzy_notfuzzy_or)as_int) prec_to_dpscPVeVP'dVPRJd \R4h\;QJdRV4F 'dK RM RM !RV44pV'd5\ V^,\ RV444RJd \R4hR#R#R#R#)z$validate if input norm is consistentNFzInput norm must be positive.c3d"TF&qP;'dVPRJxK( R#5i)TN) is_numberis_real.0is& y/Users/tonyclaw/.openclaw/workspace/skills/math-calculator/venv/lib/python3.14/site-packages/sympy/algebras/quaternion.py _check_norm..s&L8a 99 T(998s00Tc32"TF q^,xK R#5i)Nr!s& r$r%r&s+C(QqDD(szIncompatible value for norm.)r is_positive ValueErrorallrsum)elementsnorm numericals&& r$ _check_normr1s DNNN   u $;< <CL8LCCCL8LL tQw+C(+C(CDM;< <N9 +c\V4\8wd \R4h\V4^8wd\RP V44hVP 4pVP 4pV'gV'g \R4hVP4wr4pW48XgWE8Xd \R4h\V4\R4, pV'd*\RP RPV444hV#)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_extrinsicrEs CyC788 3x1}5<> c(S] "C ""(&"68 8 r2caa]tRt^:toRtRtRtRRlt]R4t]R4tRtRtRtRtRtRtRtRtRt Rt!Rt"Rt#Rt$]%R 4t&R!t'R"t(R#t)R$t*R%t+R&t,R't-R(t.R)t/R*t0R+t1]%R,4t2R-t3R?R.lt4R/t5R0t6R1t7R2t8R3t9R4t:R5t;]R64tR9t?R:t@R;tAVtBV;tC#)@ QuaternionafProvides basic quaternion operations. Quaternion objects can be instantiated as ``Quaternion(a, b, c, d)`` as in $q = a + bi + cj + dk$. 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 >>> 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<\\WW434wrr4\;QJdRWW434F 'gK RM RM!RWW4344'd \R4h\SV`WW#V4pWWnVPV4V#)c3<"TFqPRJxK R#5i)FN)is_commutativer!s& r$r%%Quaternion.__new__..rs?,Q5(,sTFz arguments have to be commutative)mapranyr+super__new__ _real_fieldset_norm) clsabcd real_fieldr/obj __class__s &&&&&&& r$rOQuaternion.__new__ost1,/ a 3?1,?333?1,? ? ??@ @gocaA.$ T r2c T\V4p\VPV4WnR#)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$rQQuaternion.set_normys!@t}DIIt$ r2c(VP^,#)rr\r^s&r$rS Quaternion.ayy|r2c(VP^,#)rarbs&r$rT Quaternion.brdr2c(VP^,#)r(rarbs&r$rU Quaternion.crdr2c(VP^,#)rarbs&r$rV Quaternion.drdr2cVP#N)rPrbs&r$rWQuaternion.real_fieldsr2c  \VPVP)VP)VP).VPVPVP)VP.VPVPVPVP).VPVP)VPVP..4#)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]]) MatrixrSrTrUrVrbs&r$product_matrix_leftQuaternion.product_matrix_leftsX$&&466'DFF73$&&$&&1$&&1$&&$&&$&&1 34 4r2c  \VPVP)VP)VP).VPVPVPVP).VPVP)VPVP.VPVPVP)VP..4#)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]]) rqrbs&r$product_matrix_rightQuaternion.product_matrix_rightsb$&&466'DFF73$&&1$&&$&&$&&1$&&$&&1 34 4r2c tV'd\VPR,4#\VP4#)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]]) :rfNN)rrr\)r^ vector_onlys&&r$ to_MatrixQuaternion.to_Matrixs*X $))B-( ($))$ $r2c \V4pV^8wd"V^8wd\RPV44hV^8Xd\^.VO5!#\V!#)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 z7Input elements must have length 3 or 4, got {} elements)r8r+r9rG)rRr.lengths&& r$ from_MatrixQuaternion.from_MatrixKsZBX Q;6Q;((.v8 8 Q;a+(+ +x( (r2c (\V4^8wd \R4h\V4pVP4wrEpRUu.uF qwV8Xd^M^NK ppRUu.uF qwV8Xd^M^NK p pRUu.uF qwV8Xd^M^NK p pVP W^,4p VP W^,4p VP W^,4p V'd\ W,V ,4#\ W,V ,4#uupiuupiuupi)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 z3 angles must be given.xyz)r8r+rEr<from_axis_angler)rRanglesr?rAr#rBrCneiejekqiqjqks&&& 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 0sDD 0Dc  X VP4'd \R4h.ROp\V4pVP4wrgpRP V4^,pRP V4^,pRP V4^,pV'gYrWh8Hp V 'd^V, V, pWg, Wx, ,W, ,^,p VP VP VPVP.p V ^,p W,p W,pW,V ,pV 'g"W, W,W,W, 3wrrV'dV 'd[VP4^,p\W,W,,W,, W,, V, 4V^&M^VP4^,,p\W,W,,W,, W,, V, 4V^&M^\\W,W,,4\W,W,,44,V^&V 'g+V^;;,\P^, ,uu&^p\!V\P"4'd#\!V\P"4'd^p\!V \P"4'd#\!V \P"4'd^pV^8XdV'd>\W4\W4,V^&\W4\W4, V^&M\W,W,,W,W,, 4V^&\W,W,, W,W,,4V^&M\P"V^V'*,&V^8Xd^\W4,V^V,&MB^\W4,V^V,&T^V,;;,V'dRM^,uu&V 'gV^;;,V ,uu&V'd\%VRRR1,4#\%V4#)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.rN)rrr)is_zero_quaternionr+rEr<indexrSrTrUrVr/r rrr rPirZerotuple)r^r?angle_additionavoid_square_rootrrAr#rBrC symmetricr r.rSrTrUrVn2cases&&&& 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 "& &= r2c XVwr4p\V^,V^,,V^,,4pW6, WF, WV, rTp\V\P,4p\ V\P,4pW7,p WG,p WW,p V!WW4#)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 rrHalfr) rRvectoranglexyzr/srSrTrUrVs &&& r$rQuaternion.from_axis_angleDs8 qAqD1a4K!Q$&'Xqxq     E E E 1r2c VP4\^^4,p\W!R,,VR,,VR,,4^, p\W!R,,VR,, VR,, 4^, p\W!R,, VR,,VR,, 4^, p\W!R,, VR,, VR,,4^, pV\VR,VR,, 4,pV\VR,VR,, 4,pV\VR,VR ,, 4,p\ W4WV4#) 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 )rr)rfrf)r(r()r(rf)rfr()rr()r(r)rfr)rrf)detrr r rG)rRMabsQrSrTrUrVs&& 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$VPV4#rnaddr^others&&r$__add__Quaternion.__add__xxr2c$VPV4#rnrrs&&r$__radd__Quaternion.__radd__rr2c2VPVR,4#rfrrrs&&r$__sub__Quaternion.__sub__sxxb!!r2c8VPV\V44#rn _generic_mulrrs&&r$__mul__Quaternion.__mul__s  x77r2c8VP\V4V4#rnrrs&&r$__rmul__Quaternion.__rmul__s  %$77r2c$VPV4#rn)pow)r^ps&&r$__pow__Quaternion.__pow__sxx{r2cv\VP)VP)VP)VP)4#rn)rGrSrTrUrVrbs&r$__neg__Quaternion.__neg__s+466'DFF7TVVGdffW==r2c4V\V4R,,#rrrs&&r$ __truediv__Quaternion.__truediv__sgenb(((r2c4\V4VR,,#rrrs&&r$ __rtruediv__Quaternion.__rtruediv__su~b((r2c"VP!V!#rnrr^r\s&*r$_eval_IntegralQuaternion._eval_Integrals~~t$$r2c VPRR4VP!VPUu.uFq3P!V/VBNK up!#uupi)evaluateT) setdefaultfuncr\diff)r^symbolskwargsrSs&*, r$rQuaternion.diffsC*d+yy J !6675f5 JKKJsA c Tp\V4p\V\4'gVP'diVP'dW\\ V4VP ,\V4VP,VPVP4#VP'd>\VP V,VPVPVP4#\R4h\VP VP ,VPVP,VPVP,VPVP,4#)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!" "r2c 8VPV\V44#)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 N\V\4'g\V\4'g W,#\V\4'gVP'd:VP'd(\\ V4\ V4^^4V,#VP 'dO\WP,WP,WP,WP,4#\R4h\V\4'gVP'd:VP'd(V\\ V4\ V4^^4,#VP 'dO\WP,WP,WP,WP,4#\R4hVPfVPfRpM%VP4VP4,p\VP)VP,VPVP,, VPVP,, VPVP,,VPVP,VPVP,,VPVP,, VPVP,,VP)VP,VPVP,,VPVP,,VPVP,,VPVP,VPVP,, VPVP,,VPVP,,VR7#)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 zAOnly commutative expressions can be multiplied with a Quaternion.Nr/)rrGrWrrrrJrSrTrUrVr+r]r/)rrr/s&& r$rQuaternion._generic_mulsnV"j))*R2L2L7N"j))}}}!"R&"R&!Q7"<<"""!"tt)R$$YTT 29MM !dee"j))}}}Jr"vr"vq!<<<"""!"tt)R$$YTT 29MM !dee 88  0D779rwwy(D244%*rttBDDy02449>r2c VPfpTp\\VP^,VP^,,VP ^,,VP ^,,44#VP#)z#Returns the norm of the quaternion.)r]r rrSrTrUrVrs& r$r/Quaternion.normms[ :: Aa!##q&1336!9ACCF!BCD Dzzr2c BTpV^VP4, ,#)z.Returns the normalized form of the quaternion.rrs& r$ normalizeQuaternion.normalizews AaffhJr2c TpVP4'g \R4h\V4^VP4^,, ,#)z&Returns the inverse of the quaternion.z6Cannot compute inverse for a quaternion with zero norm)r/r+rrs& r$inverseQuaternion.inverse|s; vvxxUV V|q1}--r2c T\V4rT^8dTP4T)rT^8XdT#\ ^^^^4pT^8d+T^,'d Y2,pY",pT^,pK1T# \d \u#i;i)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 )rr+NotImplementedrrG)r^rrress&& r$rQuaternion.pows2 "q q599;q 6HAq!$!e1uu FA !GA ! "! ! "s A11BBc nTp\VP^,VP^,,VP^,,4p\ VP 4\ V4,p\ VP 4\V4,VP,V, p\ VP 4\V4,VP,V, p\ VP 4\V4,VP,V, p\W4WV4#)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 rTrUrVr rSrrrG)r^r vector_normrSrTrUrVs& r$r Quaternion.exps, 1336ACCF?QSS!V34 Hs;' ' Hs;' '!## - ; Hs;' '!## - ; Hs;' '!## - ;!%%r2c $Tp\VP^,VP^,,VP^,,4pVP 4p\ V4pVP\ VPV, 4,V, pVP\ VPV, 4,V, pVP\ VPV, 4,V, p\WEWg4#)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 rTrUrVr/lnr rSrG)r^rrq_normrSrTrUrVs& r$r Quaternion.logs 1336ACCF?QSS!V34  vJ CC$qssV|$ ${ 2 CC$qssV|$ ${ 2 CC$qssV|$ ${ 2!%%r2cVPUu.uFq"P!V!NK ppVPpVeVP!V!p\W44\ VRV/#uupi)Nr/)r\subsr]r1rG)r^r\r#r.r/s&* r$ _eval_subsQuaternion._eval_subssZ+/9959aFFDM95zz  99d#DH#8/$// 6sAc  \V4p\VPUu.uFq3PVR7NK up!#uupi)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)rrGr\evalf)r^precnprecargs&& r$ _eval_evalfQuaternion._eval_evalfs8,D!$))D)3III.)DEEDs>c TpVP4wr4\PW1V,4pWRP4V,,#)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_anglerGrr/)r^rrvrrs&& r$ pow_cos_sinQuaternion.pow_cos_sin s>< __&   ' 'u9 5VVXq[!!r2c  \\VP.VO5!\VP.VO5!\VP.VO5!\VP .VO5!4#)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 )rGrrSrTrUrVrs&*r$rQuaternion.integrate-sT:)DFF2T2Idff4Lt4L#DFF2T2Idff4Lt4LN Nr2c R\V\4'd&\PV^,V^,4pMVP 4pV\^V^,V^,V^,4,\ V4,pVP VPVP3#)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) ) rrrGrrrrTrUrV)pinrrpouts&& r$ rotate_pointQuaternion.rotate_pointMs|H a  **1Q416A A:aQQQ889Q<G''r2c TpVPP'd VR,pVP4p\^\ VP4,4p\ ^VPVP,, 4p\VP V, 4p\VPV, 4p\VPV, 4pWEV3pWr3pV#)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 r) rS is_negativerrr r rTrUrV) r^rrrrrrr ts & r$r Quaternion.to_axis_anglezs*  33???BA KKMT!##Y' QSSW  QSS1W  QSS1W  QSS1W  1I Jr2c  0 TpVP4R,pV'Ed%WCP^,VP^,,VP^,, VP^,, ,pWCP^,VP^,, VP^,,VP^,, ,pWCP^,VP^,, VP^,, VP^,,,pM^^V,VP^,VP^,,,, p^^V,VP^,VP^,,,, p^^V,VP^,VP^,,,, p^V,VPVP,VPVP,, ,p^V,VPVP,VPVP,,,p ^V,VPVP,VPVP,,,p ^V,VPVP,VPVP,, ,p ^V,VPVP,VPVP,, ,p ^V,VPVP,VPVP,,,p V'g\ WXV .WV .WV..4#VwrpWV,, W,, VV ,, pWV ,, W,, VV ,, pVW,, W,, VV,, p^;p;pp^p\ WXV V.WV V.WVV.VVVV..4#)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/rSrTrUrVrr)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 Gr2c VP#)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 )rSrbs&r$ scalar_partQuaternion.scalar_parts $vv r2c Z\^VPVPVP4#)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 )rGrTrUrVrbs&r$ vector_partQuaternion.vector_parts!.!TVVTVVTVV44r2c VP4P4p\^VPVPVP 4#)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 )r5rrGrTrUrV)r^axiss& r$r8Quaternion.axiss82!++-!TVVTVVTVV44r2c .VPP#)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 )rSis_zerorbs&r$is_pureQuaternion.is_pure8s2vv~~r2c 6VP4P#)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;rbs&r$rQuaternion.is_zero_quaternionSs<yy{"""r2c |^\VP4P4VP44,#)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)) )rr5r/r2rbs&r$rQuaternion.angless1.5))+002D4D4D4FGGGr2c NVP4'gVP4'd \R4h\VP4VP4, P4VP4VP4,P4.4#)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+rr8rs&&r$ arc_coplanarQuaternion.arc_coplanarsvT  # # % %5+C+C+E+EHI I$))+ 4HHJTYY[[`[e[e[gMgL{L{L}~r2c \VP44'g?\VP44'g \VP44'd \R4h\VPVP VP .VPVP VP .VPVP VP ..4P4pVP#)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+rrrTrUrVrr;)rRrrq3rs&&&& 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 \VP44'g \VP44'd \R4hW,W,,P4#)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 rFrKrs&&r$ orthogonalQuaternion.orthogonal"sJJ T\\^ $ $ %--/(B(BAB B UZ';;==r2c LVP4VP4,#)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/r8rbs&r$ index_vectorQuaternion.index_vectorLs>yy{TYY[((r2c 4\VP44#)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/rbs&r$mensorQuaternion.mensorms*$))+r2)r])rrrrTN)F)TF)NT)D__name__ __module__ __qualname____firstlineno____doc__ _op_priorityrJrOrQpropertyrSrTrUrVrWrsrvrz classmethodr~rrrrrrrrrrrrrrrrr staticmethodrrr/rrrr r rr rrrr r/r2r5r8r<rrrCrHrLrOrRrU__static_attributes____classdictcell__ __classcell__)rY __classdict__s@@r$rGrG: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)Br2rGN)-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.denserrrsympy.core.sympifyrrsympy.core.exprrsympy.core.logicrrsympy.utilities.miscrmpmath.libmp.libmpfrr1rErGr)r2r$rssS'"'JJC9HH?,/=0 0'+=6HHr2