Cleanup (#232)

* cleanup Symbol definition

* replace `function (*)(...)` with `function Base.:*(...)`

* update LaTeX code in docstring

* update tests with `@testset`

* remove unused function `vee`

* add tests for r\v

* fix typo

* add missing ω

* add repeats in kinematics testset

* fix testset in principal_value_tests.jl

* update threshold in principal_value_tests.jl

* replace `for =` with `for in`

Author: hyrodium

src/core_types.jl

@@ -91,7 +91,7 @@ end
 @inline RotMatrix{N,T,L}(t::Tuple) where {N,T,L} = RotMatrix(SArray{Tuple{N,N},T}(t))
 
 # Create aliases RotMatrix2{T} = RotMatrix{2,T,4} and RotMatrix3{T} = RotMatrix{3,T,9}
-for N = 2:3
+for N in 2:3
     L = N*N
     RotMatrixN = Symbol(:RotMatrix, N)
     @eval begin
@@ -261,7 +261,7 @@ function Base.show(io::IO, ::MIME"text/plain", X::Rotation)
     if !isa(X, RotMatrix)
         n_fields = length(fieldnames(typeof(X)))
         print(io, "(")
-        for i = 1:n_fields
+        for i in 1:n_fields
             print(io, getfield(X, i))
             if i < n_fields
                 print(io, ", ")
@@ -274,4 +274,3 @@ function Base.show(io::IO, ::MIME"text/plain", X::Rotation)
     io = IOContext(io, :typeinfo => eltype(X))
     Base.print_array(io, X)
 end
-

src/derivatives.jl

@@ -160,7 +160,7 @@ end
 #######################################################
 
 # Note: this is *not* projected into the orthogonal matrix tangent space.
-# can do this by projecting each 3×3 matrix (row of 9) by (jacobian[i] - r * jacabian[i]' * r) / 2   (for i = 1:3)
+# can do this by projecting each 3×3 matrix (row of 9) by (jacobian[i] - r * jacabian[i]' * r) / 2   (for i in 1:3)
 function jacobian(r::RotMatrix{3}, X::AbstractVector)
     @assert length(X) === 3
     T = promote_type(eltype(r), eltype(X))

src/euler_types.jl

@@ -10,7 +10,7 @@
 #########################
 
 for axis in [:X, :Y, :Z]
-    RotType = Symbol("Rot" * string(axis))
+    RotType = Symbol(:Rot, axis)
     @eval begin
         struct $RotType{T} <: Rotation{3,T}
             theta::T
@@ -203,11 +203,11 @@ end
 ######################
 
 for axis1 in [:X, :Y, :Z]
-    Rot1Type = Symbol("Rot" * string(axis1))
+    Rot1Type = Symbol(:Rot, axis1)
     for axis2 in filter(axis -> axis != axis1, [:X, :Y, :Z])
-        Rot2Type = Symbol("Rot" * string(axis2))
-        RotType = Symbol("Rot" * string(axis1) * string(axis2))
-        InvRotType = Symbol("Rot" * string(axis2) * string(axis1))
+        Rot2Type = Symbol(:Rot, axis2)
+        RotType = Symbol(:Rot, axis1, axis2)
+        InvRotType = Symbol(:Rot, axis2, axis1)
 
         @eval begin
             struct $RotType{T} <: Rotation{3,T}
@@ -474,20 +474,20 @@ end
 ########################
 
 for axis1 in [:X, :Y, :Z]
-    Rot1Type = Symbol("Rot" * string(axis1))
+    Rot1Type = Symbol(:Rot, axis1)
     for axis2 in filter(axis -> axis != axis1, [:X, :Y, :Z])
-        Rot2Type = Symbol("Rot" * string(axis2))
-        Rot12Type = Symbol("Rot" * string(axis1) * string(axis2))
+        Rot2Type = Symbol(:Rot, axis2)
+        Rot12Type = Symbol(:Rot, axis1, axis2)
         for axis3 in filter(axis -> axis != axis2, [:X, :Y, :Z])
-            Rot3Type = Symbol("Rot" * string(axis3))
-            Rot23Type = Symbol("Rot" * string(axis2) * string(axis3))
-            Rot13Type = Symbol("Rot" * string(axis1) * string(axis3))
-            RotType = Symbol("Rot" * string(axis1) * string(axis2) * string(axis3))
-            InvRotType = Symbol("Rot" * string(axis3) * string(axis2) * string(axis1))
+            Rot3Type = Symbol(:Rot, axis3)
+            Rot23Type = Symbol(:Rot, axis2, axis3)
+            Rot13Type = Symbol(:Rot, axis1, axis3)
+            RotType = Symbol(:Rot, axis1, axis2, axis3)
+            InvRotType = Symbol(:Rot, axis3, axis2, axis1)
 
             # Note that axis0 is used only if axis1==axis3
             axis0 = setdiff!([:X, :Y, :Z], [axis1, axis2])[1]
-            Rot0Type = Symbol("Rot" * string(axis0))
+            Rot0Type = Symbol(:Rot, axis0)
 
             @eval begin
                 struct $RotType{T} <: Rotation{3,T}

src/mean.jl

@@ -32,7 +32,7 @@ equivalently minimizes `sum_i=1:n (sin(ϕ[i] / 2))^2`, where `ϕ[i] = rotation_a
 function Statistics.mean(qvec::AbstractVector{QuatRotation{T}}, method::Integer = 0) where T
     #if (method == 0)
         M = zeros(4, 4)
-        for i = 1:length(qvec)
+        for i in 1:length(qvec)
             q = qvec[i]
             Qi = @SVector [q.w, q.x, q.y, q.z]  # convert types to ensure we don't get quaternion multiplication
             M .+= Qi * (Qi')

src/mrps.jl

@@ -51,12 +51,12 @@ end
 Base.inv(p::MRP) = MRP(-p.x, -p.y, -p.z)
 
 # ~~~~~~~~~~~~~~~ Composition ~~~~~~~~~~~~~~~ #
-function (*)(p2::MRP, p1::MRP)
+function Base.:*(p2::MRP, p1::MRP)
     p2, p1 = params(p2), params(p1)
     MRP(((1-p2'p2)*p1 + (1-p1'p1)*p2 - cross(2p1, p2) ) / (1+p1'p1*p2'p2 - 2p1'p2))
 end
 
-function (\)(p1::MRP, p2::MRP)
+function Base.:\(p1::MRP, p2::MRP)
     q1,q2 = params(p1), params(p2)
     n1,n2 = q1'q1, q2'q2
     θ = 1/((1+n1)*(1+n2))
@@ -70,7 +70,7 @@ function (\)(p1::MRP, p2::MRP)
     return MRP(v*M)
 end
 
-function (/)(p1::MRP, p2::MRP)
+function Base.:/(p1::MRP, p2::MRP)
     q1,q2 = params(p1), params(p2)
     n1,n2 = q1'q1, q2'q2
     θ = 1/((1+n1)*(1+n2))
@@ -86,8 +86,8 @@ end
 
 
 # ~~~~~~~~~~~~~~~ Rotation ~~~~~~~~~~~~~~~ #
-@inline (*)(p::MRP, r::StaticVector) = QuatRotation(p)*r
-@inline (\)(p::MRP, r::StaticVector) = QuatRotation(p)\r
+@inline Base.:*(p::MRP, r::StaticVector) = QuatRotation(p)*r
+@inline Base.:\(p::MRP, r::StaticVector) = QuatRotation(p)\r
 
 
 # ~~~~~~~~~~~~~~~ Kinematics ~~~~~~~~~~~~~~~ #

src/rodrigues_params.jl

@@ -47,27 +47,27 @@ end
 Base.inv(p::RodriguesParam) = RodriguesParam(-p.x, -p.y, -p.z)
 
 # ~~~~~~~~~~~~~~~ Composition ~~~~~~~~~~~~~~~ #
-function (*)(g2::RodriguesParam, g1::RodriguesParam)
+function Base.:*(g2::RodriguesParam, g1::RodriguesParam)
     g2 = params(g2)
     g1 = params(g1)
     RodriguesParam((g2+g1 + g2 × g1)/(1-g2'g1))
 end
 
-function (\)(g1::RodriguesParam, g2::RodriguesParam)
+function Base.:\(g1::RodriguesParam, g2::RodriguesParam)
     g2 = params(g2)
     g1 = params(g1)
     RodriguesParam((g2-g1 + g2 × g1)/(1+g1'g2))
 end
 
-function (/)(g1::RodriguesParam, g2::RodriguesParam)
+function Base.:/(g1::RodriguesParam, g2::RodriguesParam)
     g2 = params(g2)
     g1 = params(g1)
     RodriguesParam((g1-g2 + g2 × g1)/(1+g1'g2))
 end
 
 # ~~~~~~~~~~~~~~~ Rotation ~~~~~~~~~~~~~~~ #
-(*)(g::RodriguesParam, r::StaticVector) = QuatRotation(g)*r
-(\)(g::RodriguesParam, r::StaticVector) = inv(QuatRotation(g))*r
+Base.:*(g::RodriguesParam, r::StaticVector) = QuatRotation(g)*r
+Base.:\(g::RodriguesParam, r::StaticVector) = inv(QuatRotation(g))*r
 
 
 # ~~~~~~~~~~~~~~~ Kinematics ~~~~~~~~~~~~~~~ #

src/rotation_generator.jl

@@ -58,7 +58,7 @@ RotMatrixGenerator(x::SMatrix{N,N,T,L}) where {N,T,L} = RotMatrixGenerator{N,T,L
 Base.zero(::Type{RotMatrixGenerator}) = error("The dimension of rotation is not specified.")
 
 # These functions (plus size) are enough to satisfy the entire StaticArrays interface:
-for N = 2:3
+for N in 2:3
     L = N*N
     RotMatrixGeneratorN = Symbol(:RotMatrixGenerator, N)
     @eval begin
@@ -234,7 +234,7 @@ function Base.show(io::IO, ::MIME"text/plain", X::RotationGenerator)
     if !isa(X, RotMatrixGenerator)
         n_fields = length(fieldnames(typeof(X)))
         print(io, "(")
-        for i = 1:n_fields
+        for i in 1:n_fields
             print(io, getfield(X, i))
             if i < n_fields
                 print(io, ", ")

src/unitquaternion.jl

@@ -1,5 +1,3 @@
-import Base: *, /, \, exp, ≈, ==
-
 """
     QuatRotation{T} <: Rotation
 
@@ -305,7 +303,7 @@ rmult(w) * SVector(q)
 
 Sets the output mapping equal to the mapping of `w`
 """
-function (*)(q1::QuatRotation, q2::QuatRotation)
+function Base.:*(q1::QuatRotation, q2::QuatRotation)
     return QuatRotation(q1.q*q2.q)
 end
 
@@ -323,8 +321,8 @@ function Base.:*(q::QuatRotation, r::StaticVector)  # must be StaticVector to av
     (w^2 - v'v)*r + 2*v*(v'r) + 2*w*cross(v,r)
 end
 
-(\)(q1::QuatRotation, q2::QuatRotation) = inv(q1)*q2
-(/)(q1::QuatRotation, q2::QuatRotation) = q1*inv(q2)
+Base.:\(q1::QuatRotation, q2::QuatRotation) = inv(q1)*q2
+Base.:/(q1::QuatRotation, q2::QuatRotation) = q1*inv(q2)
 
 """
     rotation_between(from, to)
@@ -349,14 +347,18 @@ end
 
 The time derivative of the rotation R, according to the definition
 
-``Ṙ = \\lim_{Δt → 0} \\frac{R(t + Δt) - R(t)}{Δt}``
+```math
+Ṙ = \\lim_{Δt → 0} \\frac{R(t + Δt) - R(t)}{Δt}
+```
 
 where `ω` is the angular velocity. This is equivalent to
 
-``Ṙ = \\lim_{Δt → 0} \\frac{R δR - R}{Δt}``
+```math
+Ṙ = \\lim_{Δt → 0} \\frac{R δR - R}{Δt}
+```
 
 where ``δR`` is some small rotation, parameterized by a small rotation ``δθ`` about
-an axis ``r``, such that ``lim_{Δt → 0} \\frac{δθ r}{Δt} = ω``
+an axis ``r``, such that ``\\lim_{Δt → 0} \\frac{δθ r}{Δt} = ω``
 
 The kinematics are extremely useful when computing the dynamics of rigid bodies, since
 `Ṙ = kinematics(R,ω)` is the first-order ODE for the evolution of the attitude dynamics.

src/util.jl

@@ -12,14 +12,14 @@ function perpendicular_vector(vec::SVector{3})
     absvec = abs.(vec)
     ind1 = argmax(absvec) # index of largest element
     tmin = typemin(T)
-    @inbounds absvec2 = @SVector [ifelse(i == ind1, tmin, absvec[i]) for i = 1 : 3] # set largest element to typemin(T)
+    @inbounds absvec2 = @SVector [ifelse(i == ind1, tmin, absvec[i]) for i in 1 : 3] # set largest element to typemin(T)
     ind2 = argmax(absvec2) # index of second-largest element
 
     # perp[ind1] = -vec[ind2], perp[ind2] = vec[ind1], set remaining element to zero:
     @inbounds perpind1 = -vec[ind2]
     @inbounds perpind2 = vec[ind1]
     tzero = zero(T)
-    perp = @SVector [ifelse(i == ind1, perpind1, ifelse(i == ind2, perpind2, tzero)) for i = 1 : 3]
+    perp = @SVector [ifelse(i == ind1, perpind1, ifelse(i == ind2, perpind2, tzero)) for i in 1 : 3]
 end
 
 @noinline length_error(v, len) =
@@ -38,10 +38,6 @@ function skew(v::AbstractVector)
              -v[2] v[1]  0]
 end
 
-function vee(S::AbstractMatrix)
-    return @SVector [S[3,2], S[1,3], S[2,1]]
-end
-
 """
 The element type for a rotation matrix with a given angle type is composed of
 trigonometric functions of that type.

test/2d.jl

@@ -76,7 +76,7 @@ using Unitful
         for R in [RotMatrix{2,Float64}, Angle2d{Float64}]
             I = one(R)
             Random.seed!(0)
-            for i = 1:repeats
+            for i in 1:repeats
                 r = rand(R)
                 @test isrotation(r)
                 @test inv(r) == adjoint(r)
@@ -96,7 +96,7 @@ using Unitful
         for R in [RotMatrix{2,Float64}, Angle2d{Float64}]
             I = one(R)
             Random.seed!(0)
-            for i = 1:repeats
+            for i in 1:repeats
                 r = rand(R)
                 @test norm(r) ≈ norm(Matrix(r))
                 @test normalize(r) ≈ normalize(Matrix(r))
@@ -114,7 +114,7 @@ using Unitful
         repeats = 100
         for R in [RotMatrix{2}, Angle2d]
             Random.seed!(0)
-            for i = 1:repeats
+            for i in 1:repeats
                 r = rand(R)
                 m = SMatrix(r)
                 v = randn(SVector{2})
@@ -136,7 +136,7 @@ using Unitful
         repeats = 100
         for R in [RotMatrix{2}, Angle2d]
             Random.seed!(0)
-            for i = 1:repeats
+            for i in 1:repeats
                 r = rand(R)
                 m = SMatrix(r)
                 v = randn(SVector{2}) * u"m"
@@ -163,7 +163,7 @@ using Unitful
         repeats = 100
         for R in [RotMatrix{2}, Angle2d]
             Random.seed!(0)
-            for i = 1:repeats
+            for i in 1:repeats
                 r1 = rand(R)
                 m1 = SMatrix(r1)