Change AbstractCoordinatePoint to not be a FieldVector

Author: oschulz

src/ConstructiveSolidGeometry/PointsAndVectors/Points.jl

@@ -47,7 +47,29 @@ function CartesianPoint{T}(;
     CartesianPoint{T}(T(x),T(y),T(z))
 end
 
-zero(PT::Type{<:AbstractCoordinatePoint{T}}) where {T} = PT(zero(T),zero(T),zero(T))
+function Base.convert(::Type{CartesianPoint{T}}, pt::CartesianPoint{U}) where {T,U}
+    return CartesianPoint{T}(convert(T, pt.x), convert(T, pt.y), convert(T, pt.z))
+end
+
+
+Base.:(==)(a::CartesianPoint, b::CartesianPoint) = a.x == b.x && a.y == b.y && a.z == b.z
+
+function Base.isapprox(a::CartesianPoint, b::CartesianPoint; kwargs...)
+    return isapprox(a.x, b.x; kwargs...) && isapprox(a.y, b.y; kwargs...) && isapprox(a.z, b.z; kwargs...)
+end
+
+
+@inline Base.:(+)(pt::CartesianPoint, v::CartesianVector) = CartesianPoint(pt.x + v.x, pt.y + v.y, pt.z + v.z)
+@inline Base.:(-)(pt::CartesianPoint, v::CartesianVector) = CartesianPoint(pt.x - v.x, pt.y - v.y, pt.z - v.z)
+@inline Base.:(-)(a::CartesianPoint, b::CartesianPoint) = CartesianVector(a.x - b.x, a.y - b.y, a.z - b.z)
+
+
+Base.:(*)(A::StaticMatrix{3,3}, pt::CartesianPoint) = _ascartpoint(A * _asvector(pt))
+
+@inline _asvector(pt::CartesianPoint{T}) where {T} = SVector(pt.x, pt.y, pt.z)
+@inline _ascartpoint(v::StaticVector{3}) = CartesianPoint(v[1], v[2], v[3])
+
+
 
 """
     struct CylindricalPoint{T} <: AbstractCoordinatePoint{T, Cylindrical}
@@ -109,6 +131,26 @@ end
 @inline _convert_point(pt::AbstractCoordinatePoint, ::Type{Cylindrical}) = CylindricalPoint(pt)
 @inline _convert_point(pt::AbstractCoordinatePoint, ::Type{Cartesian}) = CartesianPoint(pt)
 
+
+function Base.convert(::Type{CylindricalPoint{T}}, pt::CylindricalPoint{U}) where {T,U}
+    return CylindricalPoint{T}(convert(T, pt.r), convert(T, pt.φ), convert(T, pt.z))
+end
+
+
+Base.:(==)(a::CylindricalPoint, b::CylindricalPoint) = a.r == b.r && a.φ == b.φ && a.z == b.z
+
+function Base.isapprox(a::CylindricalPoint, b::CylindricalPoint; kwargs...)
+    return isapprox(a.r, b.r; kwargs...) && isapprox(a.φ, b.φ; kwargs...) && isapprox(a.z, b.z; kwargs...)
+end
+
+
+@inline Base.:(+)(pt::CylindricalPoint, v::CylindricalVector) = CylindricalPoint(pt.r + v.r, pt.φ + v.φ, pt.z + v.z)
+
+@inline Base.:(-)(pt::CylindricalPoint, v::CylindricalVector) = CylindricalPoint(pt.r - v.r, pt.φ - v.φ, pt.z - v.z)
+
+@inline Base.:(-)(a::CylindricalPoint, b::CylindricalPoint) = CylindricalVector(a.r - b.r, a.φ - b.φ, a.z - b.z)
+
+
 # function _Δφ(φ1::T, φ2::T)::T where {T}
 #     δφ = mod(φ2 - φ1, T(2π))
 #     min(δφ, T(2π) - δφ)

src/ConstructiveSolidGeometry/PointsAndVectors/PointsAndVectors.jl

@@ -1,9 +1,20 @@
-abstract type AbstractCoordinatePoint{T, S} <: StaticArrays.FieldVector{3, T} end
+abstract type AbstractCoordinatePoint{T, S} end
+
+zero(PT::Type{<:AbstractCoordinatePoint{T}}) where {T} = PT(zero(T),zero(T),zero(T))
+
+@inline StaticArrays.Size(::PT) where {PT<:AbstractCoordinatePoint} = Size(PT)
+@inline StaticArrays.Size(::Type{PT}) where {PT<:AbstractCoordinatePoint} = Size{(fieldcount(PT),)}()
+@inline Base.length(pt::AbstractCoordinatePoint) = prod(Size(pt))::Int
+@inline Base.size(pt::AbstractCoordinatePoint) = Tuple(Size(pt))
+
+Base.@propagate_inbounds Base.getindex(pt::AbstractCoordinatePoint, i::Int) = getfield(pt, i)
+
+
 abstract type AbstractCoordinateVector{T, S} <: StaticArrays.FieldVector{3, T} end
 
-include("Points.jl")
 include("Vectors.jl")
+include("Points.jl")
 
 @inline distance_squared(v::CartesianVector) = v.x * v.x + v.y * v.y + v.z * v.z
 @inline distance_squared(p1::CartesianPoint{T}, p2::CartesianPoint{T}) where {T <: Real} = distance_squared(CartesianVector(p1 .- p2))
-export distance_squared
+export distance_squared

test/runtests.jl

@@ -7,6 +7,10 @@ using SolidStateDetectors
 
 include("test_utils.jl")
 
+@timed_testset "Basic types" begin
+    include("test_points_and_vectors.jl")
+end
+
 @timed_testset "Comparison to analytic solutions" begin
     include("test_analytic_solutions.jl")
 end

test/test_points_and_vectors.jl

@@ -0,0 +1,42 @@
+# This file is a part of SolidStateDetectors.jl, licensed under the MIT License (MIT).
+
+using Test
+
+using SolidStateDetectors: CartesianPoint, CartesianVector, CylindricalPoint, CylindricalVector
+using StaticArrays: Size, SVector, SMatrix
+
+@testset "points_and_vectors" begin
+    a = CartesianPoint(1.0, 2.0, 3.0)
+    b = CartesianPoint(3.0, 1.0, 2.0)
+    v = CartesianVector(0.1, 0.2, 0.3)
+    A = SMatrix{3,3}(1,2,3,4,5,6,7,8,9)
+
+    @test @inferred(a + v) == CartesianPoint(1.1, 2.2, 3.3)
+    @test @inferred(a - v) == CartesianPoint(0.9, 1.8, 2.7)
+    @test @inferred(a - v) == CartesianPoint(0.9, 1.8, 2.7)
+    @test @inferred(a - b) == CartesianVector(-2.0, 1.0, 1.0)
+    @test @inferred(A * a) == CartesianPoint(30.0, 36.0, 42.0)
+
+    @test @inferred(Size(a)) === Size(v)
+    @test @inferred(size(a)) === size(v)
+    @test @inferred(length(a)) === length(v)
+    @test @inferred(CartesianPoint(a[1], a[2], a[3])) === a
+    @test @inferred(CartesianPoint(a[1], a[2], a[3])) == a
+    @test @inferred(CartesianPoint(a[1], a[2], a[3])) ≈ a
+
+
+    a = CylindricalPoint(1.0, 2.0, 3.0)
+    b = CylindricalPoint(3.0, 1.0, 2.0)
+
+    v = CylindricalVector(0.1, 0.2, 0.3)
+
+    @test  @inferred(a + v) == CylindricalPoint(1.1, 2.2, 3.3)
+    @test  @inferred(a - v) == CylindricalPoint(0.9, 1.8, 2.7)
+    @test  @inferred(a - b) == CylindricalVector(-2.0, 1.0, 1.0)
+    @test  @inferred(Size(a)) === Size(v)
+    @test  @inferred(size(a)) === size(v)
+    @test  @inferred(length(a)) === length(v)
+    @test  @inferred(CylindricalPoint(a[1], a[2], a[3])) === a
+    @test  @inferred(CylindricalPoint(a[1], a[2], a[3])) == a
+    @test  @inferred(CylindricalPoint(a[1], a[2], a[3])) ≈ a
+end