🎨 Apply the BlueStyle and improve docstrings

Author: ronisbr

src/ReferenceFrameRotations.jl

@@ -17,15 +17,15 @@ using StaticArrays
 # Re-export `I` from LinearAlgebra.
 export I
 
-################################################################################
-#                             Types & Conversions
-################################################################################
+############################################################################################
+#                                  Types and Conversions                                   #
+############################################################################################
 
 include("types.jl")
 
-################################################################################
-#                                  Constants
-################################################################################
+############################################################################################
+#                                        Constants                                         #
+############################################################################################
 
 # Pre-defined crayons.
 const _reset_crayon = Crayon(reset = true)
@@ -41,9 +41,9 @@ const _g = _crayon_g
 const _y = _crayon_y
 const _u = _crayon_u
 
-################################################################################
-#                                   Includes
-################################################################################
+############################################################################################
+#                                         Includes                                         #
+############################################################################################
 
 include("angle.jl")
 include("angleaxis.jl")

src/angle.jl

@@ -1,18 +1,15 @@
-# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+## Description #############################################################################
 #
-# Description
-# ==============================================================================
+# Functions related to the Euler angles.
 #
-#   Functions related to the Euler angles.
-#
-# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+############################################################################################
 
-################################################################################
-#                                  Operations
-################################################################################
+############################################################################################
+#                                        Operations                                        #
+############################################################################################
 
 """
-    *(Θ₂::EulerAngles, Θ₁::EulerAngles)
+    *(Θ₂::EulerAngles, Θ₁::EulerAngles) -> EulerAngles
 
 Compute the composed rotation of `Θ₁ -> Θ₂`.
 
@@ -51,13 +48,12 @@ EulerAngles{Float64}:
 end
 
 """
-    inv(Θ::EulerAngles)
+    inv(Θ::EulerAngles) -> EulerAngles
 
 Return the Euler angles that represent the inverse rotation of `Θ`.
 
-The rotation sequence of the result will be the inverse of the input. Hence, if
-the input rotation sequence is, for example, `:XYZ`, then the result will be
-represented using `:ZYX`.
+The rotation sequence of the result will be the inverse of the input. Hence, if the input
+rotation sequence is, for example, `:XYZ`, then the result will be represented using `:ZYX`.
 
 # Examples
 
@@ -97,9 +93,9 @@ function inv(Θ::EulerAngles)
     return EulerAngles(-Θ.a3, -Θ.a2, -Θ.a1, inv_rot_seq)
 end
 
-################################################################################
-#                                      IO
-################################################################################
+############################################################################################
+#                                            IO                                            #
+############################################################################################
 
 function show(io::IO, Θ::EulerAngles{T}) where T
     # Get if `io` request a compact printing, defaulting to true.
@@ -166,9 +162,9 @@ function show(io::IO, mime::MIME"text/plain", Θ::EulerAngles{T}) where T
     return nothing
 end
 
-################################################################################
-#                                  Julia API
-################################################################################
+############################################################################################
+#                                        Julia API                                         #
+############################################################################################
 
 Base.eltype(::Type{EulerAngles{T}}) where T = T
 

src/angleaxis.jl

@@ -1,18 +1,15 @@
-# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+## Description #############################################################################
 #
-# Description
-# ==============================================================================
+# Functions related to the Euler angle and axis.
 #
-#   Functions related to the Euler angle and axis.
-#
-# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+############################################################################################
 
-################################################################################
-#                                  Operations
-################################################################################
+############################################################################################
+#                                        Operations                                        #
+############################################################################################
 
 """
-    *(av₂::EulerAngleAxis{T1}, av₁::EulerAngleAxis{T2}) where {T1,T2}
+    *(av₂::EulerAngleAxis{T1}, av₁::EulerAngleAxis{T2}) where {T1, T2} -> EulerAngleAxis{T3}
 
 Compute the composed rotation of `av₁ -> av₂`.
 
@@ -23,6 +20,10 @@ range `[0, π] rad`.
 Notice that the vector representing the axis in `av₁` and `av₂` must be unitary.
 This function neither verifies this nor normalizes the vector.
 
+!!! note
+
+    The output type `T3` is obtained by promoting `T1` and `T2` to a float.
+
 # Examples
 
 ```jldoctest
@@ -80,12 +81,11 @@ function *(av₂::EulerAngleAxis{T1}, av₁::EulerAngleAxis{T2}) where {T1, T2}
 end
 
 """
-    inv(av::EulerAngleAxis)
+    inv(av::EulerAngleAxis) -> EulerAngleAxis
 
 Compute the inverse rotation of the Euler angle and axis `av`.
 
-The Euler angle returned by this function will always be in the interval `[0, π]
-rad`.
+The Euler angle returned by this function will always be in the interval `[0, π]` rad.
 
 # Examples
 
@@ -126,9 +126,9 @@ EulerAngleAxis{Float64}:
     return EulerAngleAxis(θ, s * av.v)
 end
 
-################################################################################
-#                                      IO
-################################################################################
+############################################################################################
+#                                            IO                                            #
+############################################################################################
 
 function show(io::IO, av::EulerAngleAxis{T}) where T
     # Get if `io` request a compact printing, defaulting to true.
@@ -180,9 +180,9 @@ function show(io::IO, mime::MIME"text/plain", av::EulerAngleAxis{T}) where T
     return nothing
 end
 
-################################################################################
-#                                  Julia API
-################################################################################
+############################################################################################
+#                                        Julia API                                         #
+############################################################################################
 
 Base.eltype(::Type{EulerAngleAxis{T}}) where T = T
 

src/compose_rotations.jl

@@ -1,23 +1,20 @@
-# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+## Description #############################################################################
 #
-# Description
-# ==============================================================================
+# Generic function to compose rotations.
 #
-#   Generic function to compose rotations.
-#
-# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+############################################################################################
 
 export compose_rotation
 
-################################################################################
-#                              Compose Rotations
-################################################################################
+############################################################################################
+#                                    Compose Rotations                                     #
+############################################################################################
 
 """
-    compose_rotation(R1, [, R2, R3, R4, R5, ...])
+    compose_rotation(R1::T, [, R2::T, R3::T, R4::T, R5::T, ...]) -> T
 
-Compute a composed rotation using the rotations `R1`, `R2`, `R3`, `R4`, ..., in
-the following order:
+Compute a composed rotation using the rotations `R1`, `R2`, `R3`, `R4`, ..., in the
+following order:
 
      First rotation
      |
@@ -34,8 +31,7 @@ The rotations can be described by:
 - A set of Euler angles ([`EulerAngles`](@ref)); or
 - A quaternion ([`Quaternion`](@ref)).
 
-Notice, however, that all rotations **must be** of the same type (DCM or
-quaternion).
+Notice, however, that all rotations **must be** of the same type (DCM or quaternion).
 
 The output will have the same type as the inputs.
 
@@ -98,13 +94,9 @@ end
 #
 #   https://discourse.julialang.org/t/improve-the-performance-of-multiplication-of-an-arbitrary-number-of-matrices/10835/24
 
-# Operator: ∘
-# ==============================================================================
+# == Operator: ∘ ===========================================================================
 
-function ∘(R2::T1, R1::T2) where {
-    T1<:ReferenceFrameRotation,
-    T2<:ReferenceFrameRotation
-}
+function ∘(R2::T1, R1::T2) where {T1<:ReferenceFrameRotation, T2<:ReferenceFrameRotation}
     R1c = convert(T1, R1)
     return compose_rotation(R1c, R2)
 end

src/conversions/angle_to_angle.jl

@@ -1,28 +1,23 @@
-# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+## Description #############################################################################
 #
-# Description
-# ==============================================================================
+# Functions related to the conversion between Euler angles.
 #
-#   Functions related to the conversion between Euler angles.
-#
-# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+############################################################################################
 
 export angle_to_angle
 
 """
-    angle_to_angle(θ₁::Number, θ₂::Number, θ₃::Number, rot_seq_orig::Symbol, rot_seq_dest::Symbol)
-    angle_to_angle(Θ::EulerAngles, rot_seq_dest::Symbol)
+    angle_to_angle(θ₁::Number, θ₂::Number, θ₃::Number, rot_seq_orig::Symbol, rot_seq_dest::Symbol) -> EulerAngles
+    angle_to_angle(Θ::EulerAngles, rot_seq_dest::Symbol) -> EulerAngles
 
 Convert the Euler angles `θ₁`, `θ₂`, and `θ₃` [rad] with the rotation sequence
-`rot_seq_orig` to a new set of Euler angles with rotation sequence
-`rot_seq_dest`.
+`rot_seq_orig` to a new set of Euler angles with rotation sequence `rot_seq_dest`.
 
-The input values of the origin Euler angles can also be passed inside the
-structure `Θ` (see [`EulerAngles`](@ref)).
+The input values of the origin Euler angles can also be passed inside the structure `Θ` (see
+[`EulerAngles`](@ref)).
 
-The rotation sequence is defined by a `:Symbol`. The possible values are:
-`:XYX`, `XYZ`, `:XZX`, `:XZY`, `:YXY`, `:YXZ`, `:YZX`, `:YZY`, `:ZXY`, `:ZXZ`,
-`:ZYX`, and `:ZYZ`.
+The rotation sequence is defined by a `:Symbol`. The possible values are: `:XYX`, `XYZ`,
+`:XZX`, `:XZY`, `:YXY`, `:YXZ`, `:YZX`, `:YZY`, `:ZXY`, `:ZXZ`, `:ZYX`, and `:ZYZ`.
 
 # Example
 

src/conversions/angle_to_angleaxis.jl

@@ -1,28 +1,23 @@
-# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+## Description #############################################################################
 #
-# Description
-# ==============================================================================
+# Functions related to the conversion from Euler angle to Euler angle and axis.
 #
-#   Functions related to the conversion from Euler angle to Euler angle and
-#   axis.
-#
-# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+############################################################################################
 
 export angle_to_angleaxis
 
 """
-    angle_to_angleaxis(θ₁::Number, θ₂::Number, θ₃::Number, rot_seq::Symbol = :ZYX)
-    angle_to_angleaxis(Θ::EulerAngles)
+    angle_to_angleaxis(θ₁::Number, θ₂::Number, θ₃::Number, rot_seq::Symbol = :ZYX) -> EulerAngleAxis
+    angle_to_angleaxis(Θ::EulerAngles) -> EulerAngleAxis
 
-Convert the Euler angles `θ₁`, `θ₂`, and `θ₃` [rad] with the rotation sequence
-`rot_seq` to an Euler angle and axis representation.
+Convert the Euler angles `θ₁`, `θ₂`, and `θ₃` [rad] with the rotation sequence `rot_seq` to
+an Euler angle and axis representation.
 
-Those values can also be passed inside the structure `Θ` (see
-[`EulerAngles`](@ref)).
+Those values can also be passed inside the structure `Θ` (see [`EulerAngles`](@ref)).
 
-The rotation sequence is defined by a `:Symbol`. The possible values are:
-`:XYX`, `XYZ`, `:XZX`, `:XZY`, `:YXY`, `:YXZ`, `:YZX`, `:YZY`, `:ZXY`, `:ZXZ`,
-`:ZYX`, and `:ZYZ`. If no value is specified, then it defaults to `:ZYX`.
+The rotation sequence is defined by a `:Symbol`. The possible values are: `:XYX`, `XYZ`,
+`:XZX`, `:XZY`, `:YXY`, `:YXZ`, `:YZX`, `:YZY`, `:ZXY`, `:ZXZ`, `:ZYX`, and `:ZYZ`. If no
+value is specified, it defaults to `:ZYX`.
 
 # Example
 

src/conversions/angle_to_dcm.jl

@@ -1,37 +1,33 @@
-# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+## Description #############################################################################
 #
-# Description
-# ==============================================================================
+# Functions related to the conversion from Euler angles to DCM.
 #
-#   Functions related to the conversion from Euler angles to DCM.
-#
-# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+############################################################################################
 
 export angle_to_dcm
 
 """
-    angle_to_dcm(θ₁::Number[, θ₂::Number[, θ₃::Number]], rot_seq::Symbol = :ZYX)
-    angle_to_dcm(Θ::EulerAngles)
+    angle_to_dcm(θ₁::Number[, θ₂::Number[, θ₃::Number]], rot_seq::Symbol = :ZYX) -> DCM
+    angle_to_dcm(Θ::EulerAngles) -> DCM
 
-Create a direction cosine matrix that perform a set of rotations (`θ₁`, `θ₂`,
-`θ₃`) about the coordinate axes specified in `rot_seq`.
+Create a direction cosine matrix that perform a set of rotations (`θ₁`, `θ₂`, `θ₃`) about
+the coordinate axes specified in `rot_seq`.
 
-The input values of the origin Euler angles can also be passed inside the
-structure `Θ` (see [`EulerAngles`](@ref)).
+The input values of the origin Euler angles can also be passed inside the structure `Θ` (see
+[`EulerAngles`](@ref)).
 
-The rotation sequence is defined by a `Symbol` specifing the rotation axes. The
-possible values depends on the number of rotations as follows:
+The rotation sequence is defined by a `Symbol` specifing the rotation axes. The possible
+values depends on the number of rotations as follows:
 
 - **1 rotation** (`θ₁`): `:X`, `:Y`, or `:Z`.
 - **2 rotations** (`θ₁`, `θ₂`): `:XY`, `:XZ`, `:YX`, `:YZ`, `:ZX`, or `:ZY`.
-- **3 rotations** (`θ₁`, `θ₂`, `θ₃`): `:XYX`, `XYZ`, `:XZX`, `:XZY`, `:YXY`,
-    `:YXZ`, `:YZX`, `:YZY`, `:ZXY`, `:ZXZ`, `:ZYX`, or `:ZYZ`
+- **3 rotations** (`θ₁`, `θ₂`, `θ₃`): `:XYX`, `XYZ`, `:XZX`, `:XZY`, `:YXY`, `:YXZ`, `:YZX`,
+    `:YZY`, `:ZXY`, `:ZXZ`, `:ZYX`, or `:ZYZ`
 
 # Remarks
 
-This function assigns `dcm = A3 * A2 * A1` in which `Ai` is the DCM related with
-the *i*-th rotation, `i Є [1,2,3]`. If the *i*-th rotation is not specified,
-then `Ai = I`.
+This function assigns `dcm = A3 * A2 * A1` in which `Ai` is the DCM related with the _i_-th
+rotation, `i ∈ [1,2,3]`. If the _i_-th rotation is not specified, then `Ai = I`.
 
 # Example
 
@@ -87,11 +83,7 @@ function angle_to_dcm(θ::Number, rot_seq::Symbol)
     end
 end
 
-function angle_to_dcm(
-    θ₁::T1,
-    θ₂::T2,
-    rot_seq::Symbol
-) where {T1<:Number, T2<:Number}
+function angle_to_dcm(θ₁::T1, θ₂::T2, rot_seq::Symbol) where {T1<:Number, T2<:Number}
     T = promote_type(T1, T2)
 
     # Compute the sines and cosines.