Cleanup around Quaternion (#228)

* update compat table for Quaternions.jl

* cleanup with Quaternions.imag_part

* fix parenthesis

Author: hyrodium

Project.toml

@@ -10,7 +10,7 @@ StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
 
 [compat]
-Quaternions = "0.4.5, 0.5"
+Quaternions = "0.5.3"
 StaticArrays = "1.2.12"
 julia = "1.6"
 

src/angleaxis_types.jl

@@ -78,10 +78,8 @@ end
 end
 
 @inline function (::Type{AA})(q::QuatRotation) where AA <: AngleAxis
-    w = q.q.s
-    x = q.q.v1
-    y = q.q.v2
-    z = q.q.v3
+    w = real(q.q)
+    x, y, z = imag_part(q.q)
     s2 = x * x + y * y + z * z
     sin_t2 = sqrt(s2)
     theta = 2 * atan(sin_t2, w)

src/derivatives.jl

@@ -31,10 +31,8 @@ to the output parameterization, centered at the value of R.
 Returns the jacobian for rotating the vector X by R.
 """
 function jacobian(::Type{RotMatrix},  q::QuatRotation)
-    w = q.q.s
-    x = q.q.v1
-    y = q.q.v2
-    z = q.q.v3
+    w = real(q.q)
+    x, y, z = imag_part(q.q)
 
     # let q = s * qhat where qhat is a unit quaternion and  s is a scalar,
     # then R = RotMatrix(q) = RotMatrix(s * qhat) = s * RotMatrix(qhat)
@@ -138,10 +136,8 @@ end
 # Jacobian converting from a Quaternion to an MRP
 #
 function jacobian(::Type{MRP}, q::QuatRotation{T}) where T
-    w = q.q.s
-    x = q.q.v1
-    y = q.q.v2
-    z = q.q.v3
+    w = real(q.q)
+    x, y, z = imag_part(q.q)
 
     den = 1 + w
     scale = 1 / den
@@ -184,10 +180,8 @@ end
 
 # TODO: should this be jacobian(:rotate, q,  X)   # or something?
 function jacobian(q::QuatRotation, X::AbstractVector)
-    w = q.q.s
-    x = q.q.v1
-    y = q.q.v2
-    z = q.q.v3
+    w = real(q.q)
+    x, y, z = imag_part(q.q)
 
     @assert length(X) === 3
     T = eltype(q)

src/error_maps.jl

@@ -220,10 +220,8 @@ end
 
 
 function jacobian(::InvCayleyMap, q::QuatRotation)
-    w = q.q.s
-    x = q.q.v1
-    y = q.q.v2
-    z = q.q.v3
+    w = real(q.q)
+    x, y, z = imag_part(q.q)
 
     μ = scaling(CayleyMap)
     si = 1/w
@@ -234,10 +232,8 @@ end
 
 
 function jacobian(::InvMRPMap, q::QuatRotation)
-    w = q.q.s
-    x = q.q.v1
-    y = q.q.v2
-    z = q.q.v3
+    w = real(q.q)
+    x, y, z = imag_part(q.q)
 
     μ = scaling(MRPMap)
     si = 1/(1+w)

src/mrps.jl

@@ -35,10 +35,8 @@ Base.one(::Type{RP}) where RP <: MRP = RP(0.0, 0.0, 0.0)
 end
 
 @inline function (::Type{RP})(q::QuatRotation) where RP<:MRP
-    w = q.q.s
-    x = q.q.v1
-    y = q.q.v2
-    z = q.q.v3
+    w = real(q.q)
+    x, y, z = imag_part(q.q)
 
     M = 1/(1+w)
     RP(x*M, y*M, z*M)

src/rodrigues_params.jl

@@ -32,10 +32,8 @@ params(g::RodriguesParam) = SVector{3}(g.x, g.y, g.z)
 end
 
 @inline function (::Type{G})(q::QuatRotation) where G<:RodriguesParam
-    w = q.q.s
-    x = q.q.v1
-    y = q.q.v2
-    z = q.q.v3
+    w = real(q.q)
+    x, y, z = imag_part(q.q)
 
     return G(x/w, y/w, z/w)
 end

src/unitquaternion.jl

@@ -61,7 +61,7 @@ end
 
 function QuatRotation(q::T) where T<:Quaternion
     if q.norm
-        return QuatRotation(q.s, q.v1, q.v2, q.v3, false)
+        return QuatRotation(real(q), imag_part(q)..., false)
     else
         throw(InexactError(nameof(T), T, q))
     end
@@ -125,10 +125,8 @@ end
 
 
 function Base.getindex(q::QuatRotation, i::Int)
-    w = q.q.s
-    x = q.q.v1
-    y = q.q.v2
-    z = q.q.v3
+    w = real(q.q)
+    x, y, z = imag_part(q.q)
 
     if i == 1
         ww = (w * w)
@@ -187,10 +185,8 @@ function Base.getindex(q::QuatRotation, i::Int)
 end
 
 function Base.Tuple(q::QuatRotation)
-    w = q.q.s
-    x = q.q.v1
-    y = q.q.v2
-    z = q.q.v3
+    w = real(q.q)
+    x, y, z = imag_part(q.q)
 
     ww = (w * w)
     xx = (x * x)
@@ -218,7 +214,7 @@ end
 # ~~~~~~~~~~~~~~~ Getters ~~~~~~~~~~~~~~~ #
 @inline scalar(q::QuatRotation) = real(q.q)
 @inline vector(q::QuatRotation) = vector(q.q)
-@inline vector(q::Quaternion) = SVector{3}(q.v1, q.v2, q.v3)
+@inline vector(q::Quaternion) = SVector{3}(imag_part(q))
 
 """
     params(R::Rotation)
@@ -231,7 +227,7 @@ p = MRP(1.0, 2.0, 3.0)
 Rotations.params(p) == @SVector [1.0, 2.0, 3.0]  # true
 ```
 """
-@inline params(q::QuatRotation) = SVector{4}(q.q.s, q.q.v1, q.q.v2, q.q.v3)
+@inline params(q::QuatRotation) = SVector{4}(real(q.q), imag_part(q.q)...)
 
 # ~~~~~~~~~~~~~~~ Initializers ~~~~~~~~~~~~~~~ #
 @inline Base.one(::Type{Q}) where Q <: QuatRotation = Q(1.0, 0.0, 0.0, 0.0)
@@ -243,10 +239,8 @@ Rotations.params(p) == @SVector [1.0, 2.0, 3.0]  # true
 Base.inv(q::Q) where Q <: QuatRotation = Q(conj(q.q))
 
 function _normalize(q::Q) where Q <: QuatRotation
-    w = q.q.s
-    x = q.q.v1
-    y = q.q.v2
-    z = q.q.v3
+    w = real(q.q)
+    x, y, z = imag_part(q.q)
 
     n = norm(params(q))
     Q(w/n, x/n, y/n, z/n)
@@ -279,10 +273,8 @@ function expm(ϕ::AbstractVector)
 end
 
 function _log_as_quat(q::Q, eps=1e-6) where Q <: QuatRotation
-    w = q.q.s
-    x = q.q.v1
-    y = q.q.v2
-    z = q.q.v3
+    w = real(q.q)
+    x, y, z = imag_part(q.q)
 
     # Assumes unit quaternion
     θ = sqrt(x^2 + y^2 + z^2)
@@ -384,10 +376,8 @@ end
 `lmult(q2)*params(q1)` returns a vector equivalent to `q2*q1` (quaternion composition)
 """
 function lmult(q::QuatRotation)
-    w = q.q.s
-    x = q.q.v1
-    y = q.q.v2
-    z = q.q.v3
+    w = real(q.q)
+    x, y, z = imag_part(q.q)
 
     SA[
         w -x -y -z;
@@ -397,11 +387,14 @@ function lmult(q::QuatRotation)
     ]
 end
 function lmult(q::Quaternion)
+    w = real(q)
+    x, y, z = imag_part(q)
+
     SA[
-        q.s  -q.v1 -q.v2 -q.v3;
-        q.v1  q.s  -q.v3  q.v2;
-        q.v2  q.v3  q.s  -q.v1;
-        q.v3 -q.v2  q.v1  q.s;
+        w -x -y -z;
+        x  w -z  y;
+        y  z  w -x;
+        z -y  x  w;
     ]
 end
 lmult(q::StaticVector{4}) = lmult(QuatRotation(q, false))
@@ -413,10 +406,8 @@ lmult(q::StaticVector{4}) = lmult(QuatRotation(q, false))
 `rmult(q1)*params(q2)` return a vector equivalent to `q2*q1` (quaternion composition)
 """
 function rmult(q::QuatRotation)
-    w = q.q.s
-    x = q.q.v1
-    y = q.q.v2
-    z = q.q.v3
+    w = real(q.q)
+    x, y, z = imag_part(q.q)
 
     SA[
         w -x -y -z;
@@ -426,11 +417,14 @@ function rmult(q::QuatRotation)
     ]
 end
 function rmult(q::Quaternion)
+    w = real(q)
+    x, y, z = imag_part(q)
+
     SA[
-        q.s  -q.v1 -q.v2 -q.v3;
-        q.v1  q.s   q.v3 -q.v2;
-        q.v2 -q.v3  q.s   q.v1;
-        q.v3  q.v2 -q.v1  q.s;
+        w -x -y -z;
+        x  w  z -y;
+        y -z  w  x;
+        z  y -x  w;
     ]
 end
 rmult(q::SVector{4}) = rmult(QuatRotation(q, false))
@@ -497,10 +491,8 @@ Useful for converting Jacobians from R⁴ to R³ and
     differential quaternion parameterization are the same up to a constant.
 """
 function ∇differential(q::QuatRotation)
-    w = q.q.s
-    x = q.q.v1
-    y = q.q.v2
-    z = q.q.v3
+    w = real(q.q)
+    x, y, z = imag_part(q.q)
 
     SA[
         -x -y -z;

test/rodrigues_params.jl

@@ -68,7 +68,7 @@ end
     @test ω ≈ 2*vmat()*lmult(q)'qdot
     @test ω ≈ 2*vmat()*lmult(inv(q))*qdot
     q2 = Quaternion(q)*pure_quaternion(ω)
-    @test qdot ≈ SVector(q2.s, q2.v1, q2.v2, q2.v3)/2
+    @test qdot ≈ SVector(real(q2), imag_part(q2)...)/2
 
     # MRPs
     ω = @SVector rand(3)

test/rotation_tests.jl

@@ -205,7 +205,7 @@ all_types = (RotMatrix3, RotMatrix{3}, AngleAxis, RotationVec,
             @test Rotations.params(q2) ≈ -Rotations.params(q) atol = 100 * eps()
             @test q ≈ q2 atol = 100 * eps()
 
-            q3 = QuatRotation(-q.q.s, -q.q.v1, -q.q.v2, -q.q.v3, false) # don't normalize: everything is exact
+            q3 = QuatRotation(-real(q.q), (-).(imag_part(q.q))..., false) # don't normalize: everything is exact
             @test Rotations.params(q3) == -Rotations.params(q)
             @test q == q3