o o h@sddlmZddlmZddlmZddlmZmZm Z m Z ddl m Z m ZddlmZddlmZmZmZddlmZmZdd lmZdd lmZdd lmZdd lmZm Z dd l!m"Z"ddl#m$Z$m%Z%ddl&m'Z'ddl(m)Z)ddZ*ddZ+Gddde"Z,dS))Rational)S)is_eq) conjugateimresign)explog)sqrt)acosasinatan2)cossin)trigsimp integrate)MutableDenseMatrix)sympify_sympify)Expr) fuzzy_notfuzzy_or)as_int) prec_to_dpscCsn|dur/|jr1|jdurtdtdd|D}|r3t|dtdd|Ddur5tddSdSdSdS) z$validate if input norm is consistentNFzInput norm must be positive.css |] }|jo |jduVqdS)TN) is_numberis_real.0ir!m/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/sympy/algebras/quaternion.py sz_check_norm..css|]}|dVqdS)r$Nr!rr!r!r"r#szIncompatible value for norm.)r is_positive ValueErrorallrsum)elementsnorm numericalr!r!r" _check_norms $r,cCst|tkr tdt|dkrtd||}|}|s'|s'td|\}}}||ks6||kr:tdt|td}|rNtdd ||S) 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 jkbadr!r!r" _is_extrinsics"   r?cseZdZdZdZdZdufdd Zd d Zed d Z ed dZ eddZ eddZ eddZ eddZeddZdvddZeddZeddZdwdd Zed!d"Zed#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd3d4Zd5d6Zd7d8Z d9d:Z!d;d<Z"d=d>Z#e$d?d@Z%dAdBZ&dCdDZ'dEdFZ(dGdHZ)dIdJZ*dKdLZ+dMdNZ,dOdPZ-dQdRZ.dSdTZ/dUdVZ0e$dWdXZ1dYdZZ2dxd[d\Z3d]d^Z4d_d`Z5dadbZ6dcddZ7dedfZ8dgdhZ9didjZ:edkdlZ;dmdnZdsdtZ?Z@S)y QuaternionaProvides 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&@FrTNcsdtt||||f\}}}}tdd||||fDrtdt|||||}||_|||S)Ncss|]}|jduVqdS)FN)is_commutativerr!r!r"r#rsz%Quaternion.__new__..z arguments have to be commutative)mapranyr&super__new__ _real_fieldset_norm)clsabcd real_fieldr*obj __class__r!r"rEos zQuaternion.__new__cCst|}t|j|||_dS)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)rr,args_norm)selfr*r!r!r"rGys  zQuaternion.set_normcC |jdS)NrrQrSr!r!r"rI z Quaternion.acCrT)NrUrVr!r!r"rJrWz Quaternion.bcCrT)Nr$rUrVr!r!r"rKrWz Quaternion.ccCrT)Nr-rUrVr!r!r"rLrWz Quaternion.dcC|jSN)rFrVr!r!r"rMszQuaternion.real_fieldcCs\t|j|j |j |j g|j|j|j |jg|j|j|j|j g|j|j |j|jggS)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]]) MatrixrIrJrKrLrVr!r!r"product_matrix_lefts ,zQuaternion.product_matrix_leftcCs\t|j|j |j |j g|j|j|j|j g|j|j |j|jg|j|j|j |jggS)aMReturns 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]]) r[rVr!r!r"product_matrix_rights 1zQuaternion.product_matrix_rightcCs |r t|jddSt|jS)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]]) rXN)r\rQ)rS vector_onlyr!r!r" to_Matrixs, zQuaternion.to_MatrixcCsFt|}|dkr|dkrtd||dkrtdg|RSt|S)aReturns 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 r-z7Input elements must have length 3 or 4, got {} elementsr)r2r&r3r@)rHr)lengthr!r!r" from_MatrixKs!zQuaternion.from_Matrixc st|dkr tdt|}|\fdddD}fdddD}fdddD}|||d}|||d }|||d } |rRt| ||St||| S) 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 r-z3 angles must be given.cg|] }|kr dndqSrXrr!rn)r r!r" z)Quaternion.from_euler..xyzcrdrer!rf)r<r!r"rhricrdrer!rf)r=r!r"rhrirrXr$)r2r&r?r6from_axis_angler) rHanglesr9r;eiejekqiqjqkr!)r r<r=r" from_eulervs +zQuaternion.from_eulercCs2|rtdgd}t|}|\}}}d|d}d|d}d|d}|s3||}}||k} | r?d||}||||||d} |j|j|j|jg} | d} | |} | |}| || }| s}| || ||| || f\} } }}|r| r| d}t | | | | ||||||d<nEd| d}t ||||| | | | ||d<n&dt t ||||t | | | | |d<| s|dtjd8<d}t|tjrt|tjrd}t| tjrt| tjrd}|dkrK|r$t | | t |||d<t | | t |||d<nZt | || || || ||d<t | || || || ||d<n3tj|d| <|dkrddt | | |d|<ndt |||d|<|d||rzdnd9<| s|d| 9<|rt|d d dSt|S) a}Returns 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.)rrrrjrXr$rN)is_zero_quaternionr&r?r6indexrIrJrKrLr*r r rr rPirZerotuple)rSr9angle_additionavoid_square_rootrlr;r r<r= symmetricrr)rIrJrKrLn2caser!r!r"to_eulersf@   $ ..2 &( zQuaternion.to_eulerc Cs|\}}}t|d|d|d}||||||}}}t|tj}t|tj}||} ||} ||} ||| | | S)aReturns 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) rHvectoranglexyzr*srIrJrKrLr!r!r"rkDs zQuaternion.from_axis_anglecCs|tdd}t||d|d|dd}t||d|d|dd}t||d|d|dd}t||d|d|dd}|t|d|d}|t|d |d }|t|d |d }t||||S) 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 rXr-)rr)rXrX)r$r$r$)r$rX)rXr$)rr$)r$rre)rrX)detrr rr@)rHMabsQrIrJrKrLr!r!r"from_rotation_matrixos$$$$zQuaternion.from_rotation_matrixcC ||SrZaddrSotherr!r!r"__add__ zQuaternion.__add__cCrrZrrr!r!r"__radd__rzQuaternion.__radd__cCs||dSNrurrr!r!r"__sub__szQuaternion.__sub__cC||t|SrZ _generic_mulrrr!r!r"__mul__zQuaternion.__mul__cCs|t||SrZrrr!r!r"__rmul__rzQuaternion.__rmul__cCrrZ)pow)rSpr!r!r"__pow__rzQuaternion.__pow__cCst|j |j |j |j SrZ)r@rIrJrKrLrVr!r!r"__neg__szQuaternion.__neg__cCs|t|dSrrrr!r!r" __truediv__rzQuaternion.__truediv__cCst||dSrrrr!r!r" __rtruediv__rzQuaternion.__rtruediv__cGs |j|SrZrrSrQr!r!r"_eval_IntegralrzQuaternion._eval_Integralcs(dd|jfdd|jDS)NevaluateTcsg|] }|jiqSr!)diff)rrIkwargssymbolsr!r"rhriz#Quaternion.diff..) setdefaultfuncrQ)rSrrr!rr"rs zQuaternion.diffcCs|}t|}t|ts8|jr$|jr$tt||jt||j|j |j S|j r4t|j||j|j |j St dt|j|j|j|j|j |j |j |j S)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>> 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 rrr!r!r"muls'zQuaternion.mulcCst|tst|ts||St|ts@|jr&|jr&tt|t|dd|S|jr>> 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*)rr@rMrrrrArIrJrKrLr&rRr*)rrr*r!r!r"rs.+  &  &2.0.zQuaternion._generic_mulcCs&|}t|j|j |j |j |jdS)z(Returns the conjugate of the quaternion.r)r@rIrJrKrLrRrSqr!r!r"_eval_conjugatehs"zQuaternion._eval_conjugatecCsD|jdur|}tt|jd|jd|jd|jdS|jS)z#Returns the norm of the quaternion.Nr$)rRr rrIrJrKrLrr!r!r"r*ms 0zQuaternion.normcCs|}|d|S)z.Returns the normalized form of the quaternion.rXrrr!r!r" normalizewszQuaternion.normalizecCs,|}|s tdt|d|dS)z&Returns the inverse of the quaternion.z6Cannot compute inverse for a quaternion with zero normrXr$)r*r&rrr!r!r"inverse|szQuaternion.inversecCsz |t|}}Wn tytYSw|dkr!|| }}|dkr'|Stdddd}|dkrF|d@r:||9}||9}|dL}|dks2|S)aFinds 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 rrX)rr&NotImplementedrr@)rSrrresr!r!r"rs" zQuaternion.powcCs|}t|jd|jd|jd}t|jt|}t|jt||j|}t|jt||j|}t|jt||j|}t||||S)aReturns 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 rJrKrLr rIrrr@)rSr vector_normrIrJrKrLr!r!r"r s"zQuaternion.expcCs|}t|jd|jd|jd}|}t|}|jt|j||}|jt|j||}|jt|j||}t||||S)agReturns 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 rJrKrLr*lnr rIr@)rSrrq_normrIrJrKrLr!r!r"r s"zQuaternion.logcsDfdd|jD}|j}|dur|j}t||t|d|iS)Ncsg|]}|jqSr!)subsrrUr!r"rhsz)Quaternion._eval_subs..r*)rQrRrr,r@)rSrQr)r*r!rUr" _eval_subss   zQuaternion._eval_subscs t|tfdd|jDS)a Returns 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 csg|]}|jdqS))rg)evalf)rargnprecr!r"rhsz*Quaternion._eval_evalf..)rr@rQ)rSprecr!rr" _eval_evalfszQuaternion._eval_evalfcCs0|}|\}}t|||}|||S)aYComputes 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_angler@rkr*)rSrrvrrr!r!r" pow_cos_sin s zQuaternion.pow_cos_sincGsFtt|jg|Rt|jg|Rt|jg|Rt|jg|RS)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 )r@rrIrJrKrLrr!r!r"r-s" zQuaternion.integratecCs^t|trt|d|d}n|}|td|d|d|dt|}|j|j|jfS)aReturns 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) rrXr$) rrzr@rkrrrJrKrL)pinrrpoutr!r!r" rotate_pointNs $&zQuaternion.rotate_pointc Cs|}|jjr |d}|}tdt|j}td|j|j}t|j|}t|j|}t|j|}|||f}||f}|S)aReturns 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 rur$rX) rI is_negativerrr r rJrKrL) rSrrrrrrrtr!r!r"r{s zQuaternion.to_axis_anglecCs||}|d}|rM||jd|jd|jd|jd}||jd|jd|jd|jd}||jd|jd|jd|jd}n0dd||jd|jd}dd||jd|jd}dd||jd|jd}d||j|j|j|j}d||j|j|j|j} d||j|j|j|j} d||j|j|j|j} d||j|j|j|j} d||j|j|j|j} |st||| g| || g| | |ggS|\}}}||||||| }||| |||| }||| || ||}d}}}d}t||| |g| || |g| | ||g||||ggS)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$rXr)r*rIrJrKrLr\)rSr homogeneousrrm00m11m22m01m02m10m12m20m21rrrm03m13m23m30m31m32m33r!r!r"to_rotation_matrixs4' ,,.            zQuaternion.to_rotation_matrixcCrY)amReturns 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 )rIrVr!r!r" scalar_partszQuaternion.scalar_partcCstd|j|j|jS)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)r@rJrKrLrVr!r!r" vector_partszQuaternion.vector_partcCs |}td|j|j|jS)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)rrr@rJrKrL)rSaxisr!r!r"rs zQuaternion.axiscCs|jjS)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 )rIis_zerorVr!r!r"is_pure9szQuaternion.is_purecCs |jS)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*rrVr!r!r"rvTs zQuaternion.is_zero_quaternioncCsdt||S)a7 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$)rrr*rrVr!r!r"rtszQuaternion.anglecCsD|s|r tdt||||gS)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)rvr&rrrr!r!r" arc_coplanars*,zQuaternion.arc_coplanarcCsht|st|st|rtdt|j|j|jg|j|j|jg|j|j|jgg}|jS)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) rrr&r\rJrKrLrr)rHrrq3rr!r!r"vector_coplanars$66zQuaternion.vector_coplanarcCs4t|s t|rtd||||S)a Returns True if the two pure quaternions seen as 3D vectors are parallel. Explanation =========== Two pure quaternions are called parallel when their vector product is commutative which implies that the quaternions seen as 3D vectors have same direction. Parameters ========== other : a Quaternion Returns ======= True : if the two pure quaternions seen as 3D vectors are parallel. False : if the two pure quaternions seen as 3D vectors are not parallel. None : if the two pure quaternions seen as 3D vectors are parallel is unknown. Examples ======== >>> 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 purerrr&rvrr!r!r"parallel%zQuaternion.parallelcCs4t|s t|rtd||||S)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 rrrr!r!r" orthogonal#rzQuaternion.orthogonalcCs||S)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*rrVr!r!r" index_vectorMszQuaternion.index_vectorcCs t|S)aj 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*rVr!r!r"mensorns zQuaternion.mensor)rrrrTN)F)TF)NT)A__name__ __module__ __qualname____doc__ _op_priorityrArErGpropertyrIrJrKrLrMr]r^r` classmethodrcrsrrkrrrrrrrrrrrrrr staticmethodrrr*rrrr r rrrrrrrrrrrrvrrrrrrr __classcell__r!r!rOr"r@:s0 $      1  61 *  ? * +6) K -#! , (L / ;**!r@N)-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 r rrrsympy.simplify.trigsimprsympy.integrals.integralsrsympy.matrices.denserr\sympy.core.sympifyrrsympy.core.exprrsympy.core.logicrrsympy.utilities.miscrmpmath.libmp.libmpfrr,r?r@r!r!r!r"s&