B cdT@sddlmZddlmZddlmZmZmZmZddl m Z m Z ddl mZddlmZmZmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZGd ddeZ dS))Rational)S) conjugateimresign)explog)sqrt)acoscossin)trigsimp) integrate)MutableDenseMatrix)sympify)Expr) prec_to_dpsc@sXeZdZdZdZdZdMddZedd Zed d Z ed d Z eddZ eddZ e ddZe ddZddZddZddZddZddZd d!Zd"d#Zd$d%Zd&d'Zd(d)Zd*d+Zd,d-Zd.d/Zed0d1Zd2d3Zd4d5Z d6d7Z!d8d9Z"d:d;Z#dd?Z%d@dAZ&dBdCZ'dDdEZ(edFdGZ)dHdIZ*dNdKdLZ+dJS)O QuaternionaJProvides basic quaternion operations. Quaternion objects can be instantiated as Quaternion(a, b, c, d) as in (a + b*i + c*j + d*k). 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 References ========== .. [1] http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/ .. [2] https://en.wikipedia.org/wiki/Quaternion g&@FrTcCs|t|}t|}t|}t|}tdd||||gDrDtdn4t|||||}||_||_||_||_||_ |SdS)Ncss|]}|jdkVqdS)FN)is_commutative).0irf/work/yifan.wang/ringdown/master-ringdown-env/lib/python3.7/site-packages/sympy/algebras/quaternion.py :sz%Quaternion.__new__..z arguments have to be commutative) rany ValueErrorr__new___a_b_c_d _real_field)clsabcd real_fieldobjrrrr4s zQuaternion.__new__cCs|jS)N)r)selfrrrr$Esz Quaternion.acCs|jS)N)r)r*rrrr%Isz Quaternion.bcCs|jS)N)r )r*rrrr&Msz Quaternion.ccCs|jS)N)r!)r*rrrr'Qsz Quaternion.dcCs|jS)N)r")r*rrrr(UszQuaternion.real_fieldc 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 rZHalfr ) r#Zvectoranglexyznormsr$r%r&r'rrrfrom_axis_angleYs 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 )rr)r3r3)r+r+r+)r+r3)r3r+)rr+)r+r)r3r)rr3)Zdetrr rr)r#MZabsQr$r%r&r'rrrfrom_rotation_matrixs$$$$zQuaternion.from_rotation_matrixcCs ||S)N)add)r*otherrrr__add__szQuaternion.__add__cCs ||S)N)r7)r*r8rrr__radd__szQuaternion.__radd__cCs||dS)N)r7)r*r8rrr__sub__szQuaternion.__sub__cCs |||S)N) _generic_mul)r*r8rrr__mul__szQuaternion.__mul__cCs |||S)N)r=)r*r8rrr__rmul__szQuaternion.__rmul__cCs ||S)N)pow)r*prrr__pow__szQuaternion.__pow__cCst|j |j |j |j S)N)rrrr r')r*rrr__neg__szQuaternion.__neg__cCs|t|dS)Nr;)r)r*r8rrr __truediv__szQuaternion.__truediv__cCst||dS)Nr;)r)r*r8rrr __rtruediv__szQuaternion.__rtruediv__cGs |j|S)N)r)r*argsrrr_eval_IntegralszQuaternion._eval_Integralcs(dd|jfdd|jDS)NevaluateTcsg|]}|jqSr)diff)rr$)kwargssymbolsrr sz#Quaternion.diff..) setdefaultfuncrF)r*rKrJr)rJrKrrIs zQuaternion.diffcCs|}t|}t|tsp|jrH|jrHtt||jt||j|j |j S|j rht|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 )r=)r*r8rrrmuls'zQuaternion.mulcCst|}t|}t|ts,t|ts,||St|ts|jr\|jr\tt|t|dd|S|jrt||j||j ||j ||j St dt|ts|jr|jr|tt|t|ddS|jrt||j||j ||j ||j St dt|j |j |j |j |j |j |j|j|j |j|j |j |j |j |j|j |j |j |j |j|j |j |j|j |j |j |j |j |j |j|j|j S)aGeneric multiplication. Parameters ========== q1 : Quaternion or symbol q2 : Quaternion or symbol It's 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 >>> 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, 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 Quaternion >>> 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.) rrOrr(rPrrrr$r%r&r'r)rQrRrrrr=1s(+  &  &2.0zQuaternion._generic_mulcCs |}t|j|j |j |j S)z(Returns the conjugate of the quaternion.)rr$r%r&r')r*qrrr_eval_conjugatezszQuaternion._eval_conjugatecCs4|}tt|jd|jd|jd|jdS)z#Returns the norm of the quaternion.r+)r rr$r%r&r')r*rTrrrr0szQuaternion.normcCs|}|d|S)z.Returns the normalized form of the quaternion.r3)r0)r*rTrrr normalizeszQuaternion.normalizecCs,|}|stdt|d|dS)z&Returns the inverse of the quaternion.z6Cannot compute inverse for a quaternion with zero normr3r+)r0rr)r*rTrrrinverseszQuaternion.inversecCsxt|}|}|dkr|Sd}|js*tS|dkrB|| }}x0|dkrr|ddkr`||}|d}||}qDW|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 r;r3rr+)rrWZ is_IntegerNotImplemented)r*rArTresrrrr@s   zQuaternion.powcCs|}t|jd|jd|jd}t|jt|}t|jt||j|}t|jt||j|}t|jt||j|}t||||S)aReturns the exponential of q (e^q). Returns ======= Quaternion Exponential of q (e^q). 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 r%r&r'rr$r r r)r*rT vector_normr$r%r&r'rrrrs"zQuaternion.expcCs|}t|jd|jd|jd}|}t|}|jt|j||}|jt|j||}|jt|j||}t||||S)aeReturns the natural logarithm of the quaternion (_ln(q)). Examples ======== >>> from sympy import Quaternion >>> q = Quaternion(1, 2, 3, 4) >>> q._ln() 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 r%r&r'r0lnr r$r)r*rTrZZq_normr$r%r&r'rrr_lns"zQuaternion._lncs 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))n)Zevalf)rarg)nprecrrrLsz*Quaternion._eval_evalf..)rrrF)r*precr)r_r _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_anglerr2r0)r*rArTvr,rRrrr pow_cos_sins zQuaternion.pow_cos_sincGs>tt|jf|t|jf|t|jf|t|jf|S)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 )rrr$r%r&r')r*rFrrrr5szQuaternion.integratecCs^t|tr t|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) rr3r+) rOtuplerr2rVrr%r&r')ZpinrrTZpoutrrr rotate_pointVs $ &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 r;r+r3) r$Z is_negativerVrr r r%r&r') r*rTr,r1r-r.r/rctrrrrbs zQuaternion.to_axis_angleNcCs|}|d}dd||jd|jd}d||j|j|j|j}d||j|j|j|j}d||j|j|j|j}dd||jd|jd}d||j|j|j|j} d||j|j|j|j} d||j|j|j|j} dd||jd|jd} |sVt|||g||| g| | | ggS|\} }}| | |||||}|| ||||| }|| | || || }d}}}d}t||||g||| |g| | | |g||||ggSdS)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 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. 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((1, 1, 1))) Matrix([ [cos(x), -sin(x), 0, sin(x) - cos(x) + 1], [sin(x), cos(x), 0, -sin(x) - cos(x) + 1], [ 0, 0, 1, 0], [ 0, 0, 0, 1]]) r3r+rN)r0r&r'r%r$Matrix)r*rcrTr1Zm00Zm01Zm02Zm10Zm11Zm12Zm20Zm21Zm22r-r.r/Zm03Zm13Zm23Zm30Zm31Zm32Zm33rrrto_rotation_matrixs*1             zQuaternion.to_rotation_matrix)rrrrT)N),__name__ __module__ __qualname____doc__Z _op_priorityrrpropertyr$r%r&r'r( classmethodr2r6r9r:r<r>r?rBrCrDrErGrIr7rS staticmethodr=rUr0rVrWr@rr\rardrrgrbrkrrrrrsL       + ,6) I.#! -(rN)!Zsympy.core.numbersrZsympy.core.singletonrZ$sympy.functions.elementary.complexesrrrrZ&sympy.functions.elementary.exponentialrr r[Z(sympy.functions.elementary.miscellaneousr Z(sympy.functions.elementary.trigonometricr r r Zsympy.simplify.trigsimprZsympy.integrals.integralsrZsympy.matrices.denserrjZsympy.core.sympifyrZsympy.core.exprrZmpmath.libmp.libmpfrrrrrrs