Unitful compatibility

- Add separate type parameter for the angle
- Promote types for combinations of AbstractFloat and Integer

Author: SebastianM-C

Project.toml

@@ -13,8 +13,9 @@ StaticArrays = "0.11,0.12"
 julia = "1"
 
 [extras]
+Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d"
 ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["Test", "ForwardDiff"]
+test = ["Test", "ForwardDiff", "Unitful"]

src/coordinatesystems.jl

@@ -2,16 +2,18 @@
 ### 2D Coordinate systems ###
 #############################
 """
-`Polar{T}(r::T, θ::T)` - 2D polar coordinates
+`Polar{T,A}(r::T, θ::A)` - 2D polar coordinates
 """
-struct Polar{T}
+struct Polar{T,A}
     r::T
-    θ::T
+    θ::A
 end
+Polar(r::T, θ::A) where {T<:AbstractFloat, A<:Integer} = Polar(promote(r, θ)...)
+Polar(r::T, θ::A) where {T<:Integer, A<:AbstractFloat} = Polar(promote(r, θ)...)
 Base.show(io::IO, x::Polar) = print(io, "Polar(r=$(x.r), θ=$(x.θ) rad)")
 Base.isapprox(p1::Polar, p2::Polar; kwargs...) = isapprox(p1.r, p2.r; kwargs...) && isapprox(p1.θ, p2.θ; kwargs...)
-Base.eltype(::Polar{T}) where {T} = T
-Base.eltype(::Type{Polar{T}}) where {T} = T
+Base.eltype(::Polar{T,A}) where {T,A} = promote_type(T, A)
+Base.eltype(::Type{Polar{T,A}}) where {T,A} = promote_type(T, A)
 
 "`PolarFromCartesian()` - transformation from `AbstractVector` of length 2 to `Polar` type"
 struct PolarFromCartesian <: Transformation; end
@@ -67,28 +69,34 @@ Base.convert(::Type{Polar}, v::AbstractVector) = PolarFromCartesian()(v)
 """
 Spherical(r, θ, ϕ) - 3D spherical coordinates
 """
-struct Spherical{T}
+struct Spherical{T,A}
     r::T
-    θ::T
-    ϕ::T
+    θ::A
+    ϕ::A
 end
+Spherical(r::T, θ::A, ϕ::A) where {T<:AbstractFloat, A<:Integer} = Spherical(promote(r, θ, ϕ)...)
+Spherical(r::T, θ::A, ϕ::A) where {T<:Integer, A<:AbstractFloat} = Spherical(promote(r, θ, ϕ)...)
 Base.show(io::IO, x::Spherical) = print(io, "Spherical(r=$(x.r), θ=$(x.θ) rad, ϕ=$(x.ϕ) rad)")
 Base.isapprox(p1::Spherical, p2::Spherical; kwargs...) = isapprox(p1.r, p2.r; kwargs...) && isapprox(p1.θ, p2.θ; kwargs...) && isapprox(p1.ϕ, p2.ϕ; kwargs...)
-Base.eltype(::Spherical{T}) where {T} = T
-Base.eltype(::Type{Spherical{T}}) where {T} = T
+Base.eltype(::Spherical{T,A}) where {T,A} = promote_type(T, A)
+Base.eltype(::Type{Spherical{T,A}}) where {T,A} = promote_type(T, A)
 
 """
 Cylindrical(r, θ, z) - 3D cylindrical coordinates
 """
-struct Cylindrical{T}
+struct Cylindrical{T,A}
     r::T
-    θ::T
+    θ::A
     z::T
 end
+Cylindrical(r::T1, θ::A, z::T2) where {T1<:AbstractFloat, T2<:Integer, A<:Integer} = Cylindrical(promote(r, θ, z)...)
+Cylindrical(r::T1, θ::A, z::T2) where {T1<:Integer, T2<:AbstractFloat, A<:Integer} = Cylindrical(promote(r, θ, z)...)
+Cylindrical(r::T1, θ::A, z::T2) where {T1<:AbstractFloat, T2<:Integer, A<:AbstractFloat} = Cylindrical(promote(r, θ, z)...)
+Cylindrical(r::T1, θ::A, z::T2) where {T1<:Integer, T2<:AbstractFloat, A<:AbstractFloat} = Cylindrical(promote(r, θ, z)...)
 Base.show(io::IO, x::Cylindrical) = print(io, "Cylindrical(r=$(x.r), θ=$(x.θ) rad, z=$(x.z))")
 Base.isapprox(p1::Cylindrical, p2::Cylindrical; kwargs...) = isapprox(p1.r, p2.r; kwargs...) && isapprox(p1.θ, p2.θ; kwargs...) && isapprox(p1.z, p2.z; kwargs...)
-Base.eltype(::Cylindrical{T}) where {T} = T
-Base.eltype(::Type{Cylindrical{T}}) where {T} = T
+Base.eltype(::Cylindrical{T,A}) where {T,A} = promote_type(T, A)
+Base.eltype(::Type{Cylindrical{T,A}}) where {T,A} = promote_type(T, A)
 
 "`SphericalFromCartesian()` - transformation from 3D point to `Spherical` type"
 struct SphericalFromCartesian <: Transformation; end

test/coordinatesystems.jl

@@ -99,6 +99,34 @@
                     partials(xy_gn[2], 1) partials(xy_gn[2], 2) ]
         m = transform_deriv(c_from_p, rθ)
         @test m ≈ m_gn
+
+        @testset "Common types" begin
+            xy = SVector(1.0, 2.0)
+            xy_i = SVector(1,2)
+            p1 = Polar(1, 2.0f0)
+            p2 = Polar(1.0, 2)
+            rθ = Polar(2.23606797749979, 1.1071487177940904)
+
+            @test eltype(p1) == Float32
+            @test typeof(p1.r) == typeof(p1.θ)
+            @test eltype(p2) == Float64
+            @test typeof(p2.r) == typeof(p2.θ)
+            @test eltype(p_from_c(xy_i)) == Float64
+
+            @test p_from_c(xy_i) ≈ rθ
+            @test p_from_c(xy) ≈ rθ
+            @test p_from_c(collect(xy)) ≈ rθ
+            @test c_from_p(rθ) ≈ xy
+        end
+
+        @testset "Units" begin
+            xy = SVector(1.0, 2.0)u"m"
+            rθ = Polar(2.23606797749979u"m", 1.1071487177940904)
+
+            @test p_from_c(xy) ≈ rθ
+            @test p_from_c(collect(xy)) ≈ rθ
+            @test c_from_p(rθ) ≈ xy
+        end
     end
 
     @testset "3D" begin
@@ -435,5 +463,69 @@
 #        @test isapprox(m, m_gn; atol = 1e-12)
         @test m ≈ m_gn
 
+        @testset "Common types" begin
+            xyz = SVector(1.0, 2.0, 3.0)
+            xyz_i = SVector(1, 2, 3)
+
+            @testset "Spherical" begin
+                rθϕ = Spherical(3.7416573867739413, 1.1071487177940904, 0.9302740141154721)
+
+                @test s_from_cart(xyz) ≈ rθϕ
+                @test s_from_cart(xyz_i) ≈ rθϕ
+                @test s_from_cart(collect(xyz)) ≈ rθϕ
+                @test cart_from_s(rθϕ) ≈ xyz
+
+                s1 = Spherical(1, 2.0, 3.0)
+                s2 = Spherical(1.0, 2, 3)
+
+                @test eltype(s1) == Float64
+                @test typeof(s1.r) == typeof(s1.θ) == typeof(s1.ϕ)
+                @test eltype(s2) == Float64
+                @test typeof(s2.r) == typeof(s2.θ) == typeof(s2.ϕ)
+                @test eltype(s_from_cart(xyz_i)) == Float64
+            end
+
+            @testset "Cylindrical" begin
+                rθz = Cylindrical(2.23606797749979, 1.1071487177940904, 3.0)
+
+                @test cyl_from_cart(xyz) ≈ rθz
+                @test cyl_from_cart(xyz_i) ≈ rθz
+                @test cyl_from_cart(collect(xyz)) ≈ rθz
+                @test cart_from_cyl(rθz) ≈ xyz
+
+                c1 = Cylindrical(1, 2.0, 3)
+                c2 = Cylindrical(1.0, 2, 3.0)
+                c3 = Cylindrical(1, 2, 3)
+
+                @test eltype(c1) == Float64
+                @test typeof(c1.r) == typeof(c1.z)
+                @test typeof(c1.θ) == Float64
+                @test eltype(c2) == Float64
+                @test typeof(c2.r) == typeof(c2.z)
+                @test typeof(c2.θ) == Int
+                @test eltype(cyl_from_cart(xyz_i)) == Float64
+            end
+        end
+
+        @testset "Units" begin
+            xyz = SVector(1.0, 2.0, 3.0)u"m"
+
+            @testset "Shperical" begin
+                rθϕ = Spherical(3.7416573867739413u"m", 1.1071487177940904, 0.9302740141154721)
+
+                @test s_from_cart(xyz) ≈ rθϕ
+                @test typeof(s_from_cart(xyz)) == typeof(rθϕ)
+                @test s_from_cart(collect(xyz)) ≈ rθϕ
+                @test cart_from_s(rθϕ) ≈ xyz
+            end
+            @testset "Cylindrical" begin
+                rθz = Cylindrical(2.23606797749979u"m", 1.1071487177940904, 3.0u"m")
+
+                @test cyl_from_cart(xyz) ≈ rθz
+                @test typeof(cyl_from_cart(xyz)) == typeof(rθz)
+                @test cyl_from_cart(collect(xyz)) ≈ rθz
+                @test cart_from_cyl(rθz) ≈ xyz
+            end
+        end
     end
 end

test/runtests.jl

@@ -3,6 +3,7 @@ using LinearAlgebra
 using CoordinateTransformations
 using ForwardDiff: Dual, partials
 using StaticArrays
+using Unitful
 
 @testset "CoordinateTransformations" begin