improve support for dimension of vector domains

Author: daanhb

src/DomainSets.jl

@@ -51,7 +51,7 @@ export ..
 ## Utils
 
 # from util/common.jl
-export subeltype, dimension, prectype, numtype
+export prectype, numtype
 # from util/tensorproducts.jl
 export cartesianproduct
 
@@ -82,6 +82,7 @@ export CartToPolarMap, PolarToCartMap
 
 # from generic/domain.jl
 export Domain, EuclideanDomain, VectorDomain,
+    dimension,
     approx_in,
     isclosed, iscompact,
     boundary, ∂,

src/domains/ball.jl

@@ -204,7 +204,7 @@ The map `[cos(2πt), sin(2πt)]` from `[0,1)` to the unit circle in `ℝ^2`.
 """
 struct UnitCircleMap{S,T} <: AbstractMap{S,T} end
 
-parameterization(d::UnitCircle) = UnitCircleMap{subeltype(d),eltype(d)}()
+parameterization(d::UnitCircle) = UnitCircleMap{numtype(d),eltype(d)}()
 
 domain(d::UnitCircleMap{S}) where {S} = Interval{:closed,:open,S}(0, 1)
 

src/domains/point.jl

@@ -30,6 +30,8 @@ boundary(d::Point) = d
 
 point_in_domain(d::Point) = d.x
 
+dimension(d::Point{Vector{T}}) where {T} = length(d.x)
+
 for op in (:*,:+,:-)
     @eval begin
         $op(c::Number, d::Point)  = Point($op(c,d.x))

src/generic/domain.jl

@@ -1,16 +1,19 @@
 # Definition of the abstract Domain type and its interface
 
 eltype(::Type{<:Domain{T}}) where {T} = T
-subeltype(::Type{<:Domain{T}}) where {T} = subeltype(T)
 prectype(::Type{<:Domain{T}}) where {T} = prectype(T)
 numtype(::Type{<:Domain{T}}) where {T} = numtype(T)
-dimension(::Type{<:Domain{T}}) where {T} = dimension(T)
 
 Domain(d) = convert(Domain, d)
 
 "A `EuclideanDomain` is any domain whose eltype is `SVector{N,T}`."
 const EuclideanDomain{N,T} = Domain{SVector{N,T}}
 
+"What is the Euclidean dimension of the domain?"
+dimension(::Domain{<:Number}) = 1
+dimension(::EuclideanDomain{N}) where {N} = N
+dimension(::Domain{<:NTuple{N,Any}}) where {N} = N
+
 """
 A `VectorDomain` is any domain whose eltype is `Vector{T}`. In this case
 the dimension of the domain is not included in its type.

src/generic/lazy.jl

@@ -69,6 +69,15 @@ point_in_domain(d::LazyDomain) =
 
 ==(a::D, b::D) where {D<:LazyDomain} = elements(a) == elements(b)
 
+
+const LazyVectorDomain{T} = LazyDomain{Vector{T}}
+
+function dimension(d::LazyVectorDomain)
+	dim = dimension(element(d,1))
+	@assert all(isequal(dim), map(dimension, elements(d)))
+	dim
+end
+
 """
 Combine the outputs of `in` of member domains into a single output of the lazy
 domain.

src/generic/mapped_domain.jl

@@ -31,6 +31,11 @@ elements(d::MappedDomain) = (source(d),)
 tointernalpoint(d::MappedDomain, x) = inverse_map(d) * x
 toexternalpoint(d::MappedDomain, y) = forward_map(d) * y
 
+const MappedVectorDomain{D,T} = MappedDomain{D,Vector{T}}
+
+# TODO: check whether the map alters the dimension
+dimension(d::MappedVectorDomain) = dimension(source(d))
+
 # isopen(d::MappedDomain) = isopen(source(d))
 # isclosed(d::MappedDomain) = isclosed(source(d))
 #

src/generic/productdomain.jl

@@ -113,8 +113,6 @@ function VcatDomain{N,T}(domains) where {N,T}
 	VcatDomain{N,T,DIM,typeof(Tdomains)}(Tdomains)
 end
 
-productdimension(d::VcatDomain{N}) where {N} = N
-
 tointernalpoint(d::VcatDomain{N,T,DIM}, x) where {N,T,DIM} =
 	convert_fromcartesian(x, Val{DIM}())
 toexternalpoint(d::VcatDomain{N,T,DIM}, y) where {N,T,DIM} =
@@ -148,12 +146,12 @@ function VectorProductDomain{T}(domains::Vector) where {T}
 	VectorProductDomain{T,eltype(Tdomains)}(Tdomains)
 end
 
-productdimension(d::VectorProductDomain) = numelements(d)
+dimension(d::VectorProductDomain) = numelements(d)
 
 tointernalpoint(d::VectorProductDomain, x) =
-	(@assert length(x) == productdimension(d); x)
+	(@assert length(x) == dimension(d); x)
 toexternalpoint(d::VectorProductDomain, y) =
-	(@assert length(y) == productdimension(d); y)
+	(@assert length(y) == dimension(d); y)
 
 infimum(d::ProductDomain) = toexternalpoint(d, map(infimum, elements(d)))
 supremum(d::ProductDomain) = toexternalpoint(d, map(supremum, elements(d)))
@@ -187,8 +185,6 @@ function TupleProductDomain{T}(domains) where {T<:Tuple}
 	TupleProductDomain{T,typeof(Tdomains)}(Tdomains)
 end
 
-productdimension(d::TupleProductDomain) = sum(map(dimension, elements(d)))
-
 convert(::Type{Domain{T}}, d::TupleProductDomain{T}) where {T} = d
 convert(::Type{Domain{T}}, d::TupleProductDomain{S}) where {S,T} =
 	TupleProductDomain{T}(elements(d))

src/util/common.jl

@@ -1,36 +1,11 @@
 
 ##############################
-# Booleans in the type domain
+# Promotion helper functions
 ##############################
 
-# We introduce these types to compute with booleans in a type context.
-# They are not exported, but they are necessary when an external package wishes
-# to extend the embeddings and promotions of spaces in this package.
 const True = Val{true}
 const False = Val{false}
 
-# Simple boolean operations on the new types
-(|)(::Type{True}, ::Type{True}) = True
-(|)(::Type{True}, ::Type{False}) = True
-(|)(::Type{False}, ::Type{True}) = True
-(|)(::Type{False}, ::Type{False}) = False
-
-# Return True if one of the arguments is True
-one_of(::Type{True}) = True
-one_of(::Type{False}) = False
-one_of(a::Type{Val{A}}, b::Type{Val{B}}) where {A,B} = |(one_of(a),one_of(b))
-one_of(a::Type{Val{A}}, b::Type{Val{B}}, c::Type{Val{C}}, d...) where {A,B,C} = one_of(a, one_of(b, c, d...))
-
-# Convert the boolean type to a boolean value
-result(::Type{True}) = true
-result(::Type{False}) = false
-
-
-
-##############################
-# Promotion helper functions
-##############################
-
 "Return True if S promotes to T, i.e., if promote_type(S,T) == T."
 promotes_to(S, T) = _promotes_to(S, T, promote_type(S,T))
 _promotes_to(::Type{S}, ::Type{T}, ::Type{T}) where {S,T} = True
@@ -105,25 +80,6 @@ const v = TypeFactory{SVector}()
 
 
 
-###############
-# Subeltype
-###############
-
-"Return the type of the elements of `x`."
-subeltype(x) = subeltype(typeof(x))
-subeltype(::Type{T}) where {T} = eltype(eltype(T))
-
-###############
-# Dimension
-###############
-
-dimension(x) = dimension(typeof(x))
-dimension(::Type{T}) where {T <: Number} = 1
-dimension(::Type{SVector{N,T}}) where {N,T} = N
-dimension(::Type{<:NTuple{N,Any}}) where {N} = N
-dimension(::Type{CartesianIndex{N}}) where {N} = N
-dimension(::Type{T}) where {T} = 1
-
 #################
 # Precision type
 #################
@@ -136,8 +92,9 @@ prectype(::Type{NTuple{N,T}}) where {N,T} = prectype(T)
 prectype(::Type{Tuple{A}}) where {A} = prectype(A)
 prectype(::Type{Tuple{A,B}}) where {A,B} = prectype(A,B)
 prectype(::Type{Tuple{A,B,C}}) where {A,B,C} = prectype(A,B,C)
-prectype(::Type{Tuple{A,B,C,D}}) where {A,B,C,D} = prectype(A,B,C,D)
-prectype(T::Type{<:NTuple{N,Any}}) where {N} = prectype(map(prectype, T.parameters)...)
+@generated function prectype(T::Type{<:Tuple{Vararg}})
+    quote $(promote_type(map(prectype, T.parameters[1].parameters)...)) end
+end
 prectype(::Type{T}) where {T<:AbstractFloat} = T
 prectype(::Type{T}) where {T} = prectype(float(T))
 
@@ -148,10 +105,16 @@ prectype(a, b, c...) = prectype(prectype(a, b), c...)
 # Numeric type
 #################
 
-"The numeric element type used in Euclidean spaces."
+"The numeric element type of x in a Euclidean space."
 numtype(x) = numtype(typeof(x))
 numtype(::Type{T}) where {T<:Number} = T
 numtype(::Type{T}) where {T} = eltype(T)
-numtype(T::Type{<:NTuple{N,Any}}) where {N} = promote_type(map(numtype, T.parameters)...)
+numtype(::Type{NTuple{N,T}}) where {N,T} = T
+numtype(::Type{Tuple{A,B}}) where {A,B} = promote_type(numtype(A), numtype(B))
+numtype(::Type{Tuple{A,B,C}}) where {A,B,C} = promote_type(numtype(A), numtype(B), numtype(C))
+numtype(::Type{Tuple{A,B,C,D}}) where {A,B,C,D} = promote_type(numtype(A), numtype(B), numtype(C), numtype(D))
+@generated function numtype(T::Type{<:Tuple{Vararg}})
+    quote $(promote_type(T.parameters[1].parameters...)) end
+end
 
 numtype(a...) = promote_type(map(numtype, a)...)

test/test_common.jl

@@ -1,50 +1,34 @@
 
-function test_subeltype()
-    @test subeltype([1,2,3]) == Int
-    @test subeltype(([1,2,3], [4,5,6])) == Int
-    @test subeltype(Array{Float64,2}) == Float64
-    @test subeltype(Array{Array{BigFloat,1},2}) == BigFloat
-end
-
-function test_dimension()
-    @test dimension(Int) == 1
-    @test dimension(SVector(1,2)) == 2
-    @test dimension(SVector{2,Float64}) == 2
-    @test dimension((1,2)) == 2
-    @test dimension((1,2,3,4,5)) == 5
-    @test dimension(Tuple{Int,Int,Float64,Float64,BigFloat}) == 5
-    @test dimension((1,2,3,4,5)) == 5
-    @test dimension(CartesianIndex(1,2)) == 2
-end
-
-const SystemFloat = typeof(1.0)
-
 function test_prectype()
-    @test prectype(1.0) == SystemFloat
+    @test prectype(1.0) == Float64
     @test prectype(big(1.0)) == BigFloat
     @test prectype(1) == typeof(float(1))
     @test prectype(SVector(1,2)) == typeof(float(1))
     @test prectype(SVector(1,big(2))) == typeof(float(big(2)))
-    @test prectype(1.0+2.0im) == SystemFloat
-    @test prectype([1.0+2.0im, 3.0]) == SystemFloat
-    @test prectype((1.0, 2.0, 3.0)) == SystemFloat
+    @test prectype(1.0+2.0im) == Float64
+    @test prectype([1.0+2.0im, 3.0]) == Float64
+    @test prectype((1.0, 2.0, 3.0)) == Float64
     @test prectype((1.0, big(2.0), 3.0+im)) == BigFloat
+    @test @inferred(prectype(1, 2.0)) == Float64
+    @test @inferred(prectype((1, 2.0, 3, 40+im))) == Float64
 end
 
 function test_numtype()
-    @test numtype(1.0) == SystemFloat
+    @test numtype(1.0) == Float64
     @test numtype(big(1.0)) == BigFloat
     @test numtype(1) == Int
+    @test numtype([1,2,3], [4,5,6]) == Int
     @test numtype(SVector(1,2)) == Int
     @test numtype(SVector(1,big(2))) == BigInt
-    @test numtype(1.0+2.0im) == Complex{SystemFloat}
-    @test numtype([1.0+2.0im, 3.0]) == Complex{SystemFloat}
-    @test numtype((1.0, 2.0, 3.0)) == SystemFloat
+    @test numtype(Array{Float64,2}) == Float64
+    @test numtype(1.0+2.0im) == Complex{Float64}
+    @test numtype([1.0+2.0im, 3.0]) == Complex{Float64}
+    @test numtype((1.0, 2.0, 3.0)) == Float64
     @test numtype(1.0, big(2.0), 3.0+im) == Complex{BigFloat}
     @test numtype((1.0, big(2.0), 3.0+im)) == Complex{BigFloat}
+    @test @inferred(numtype(1, 2.0)) == Float64
+    @test @inferred(numtype((1, 2.0, 3, 40+im))) == Complex{Float64}
 end
 
-test_subeltype()
-test_dimension()
 test_prectype()
 test_numtype()

test/test_generic_domain.jl

@@ -8,8 +8,8 @@ widen_eltype(::Type{Vector{T}}) where {T<:Number} = Vector{widen(T)}
 # These tests check whether the given domain correctly implements the
 # interface of a domain.
 function test_generic_domain(d::Domain)
-    @test eltype(eltype(d)) == subeltype(d)
-    @test isreal(d) == isreal(subeltype(d))
+    @test isreal(d) == isreal(eltype(d))
+    @test isreal(d) == isreal(numtype(d))
 
     if !isempty(d)
         x = point_in_domain(d)

test/test_specific_domains.jl

@@ -102,6 +102,8 @@ end
 
         @test convert(Domain{Float64}, Point(1)) ≡ Point(1.0)
         @test Number(Point(1)) ≡ convert(Number, Point(1)) ≡ convert(Int, Point(1)) ≡ 1
+
+        @test dimension(Point([1,2,3]))==3
     end
 
     @testset "intervals" begin
@@ -683,6 +685,9 @@ end
         D = rotate((-1.5.. 2.2) × (0.5 .. 0.7) × (-3.0 .. -1.0), π, π, π, v[.35, .65, -2.])
         @test v[0.9, 0.6, -2.5] ∈ D
         @test v[0.0, 0.6, 0.0] ∉ D
+
+        B = 2VectorUnitBall(10)
+        @test dimension(B) == 10
     end
 
     @testset "simplex" begin
@@ -872,6 +877,7 @@ end
             d1 = ProductDomain([0..1.0, 0..2.0])
             @test d1 isa VectorDomain{Float64}
             @test d1.domains isa Vector
+            @test dimension(d1) == 2
             @test [0.1,0.2] ∈ d1
             @test v[0.1,0.2] ∈ d1
             @test point_in_domain(d1) ∈ d1
@@ -881,12 +887,14 @@ end
 
             # Test an integer type as well
             d2 = ProductDomain([0..1, 0..2])
+            @test dimension(d2) == 2
             @test [0.1,0.2] ∈ d2
             @test point_in_domain(d2) ∈ d2
 
             bnd = boundary(d1)
             @test bnd isa VectorDomain
             @test bnd isa UnionDomain
+            @test dimension(bnd) == 2
             @test [0.0, 0.5] ∈ bnd
             @test [1.0, 0.5] ∈ bnd
             @test [0.2, 0.0] ∈ bnd
@@ -899,6 +907,7 @@ end
             @test d1 isa TupleProductDomain
             @test d1.domains isa Tuple
             @test eltype(d1) == Tuple{Float64,Float64}
+            @test dimension(d1) == 2
             @test (0.2,0.6) ∈ d1
             @test (0.2,0.8) ∉ d1
             @test (true,0.6) ∉ d1
@@ -913,13 +922,15 @@ end
             d2 = ProductDomain([true,false], 0..1)
             @test d2 isa TupleProductDomain
             @test d2.domains isa Tuple
+            @test dimension(d2) == 2
             @test eltype(d2) == Tuple{Bool,Int}
             @test (true,0.4) ∈ d2
             @test (false,1.5) ∉ d2
 
             bnd = boundary(d1)
             @test eltype(bnd) == Tuple{Float64,Float64}
             @test bnd isa UnionDomain
+            @test dimension(bnd) == 2
             @test (0.0, 0.5) ∈ bnd
             @test (0.5, 0.5) ∈ bnd
             @test (0.3, 0.2) ∉ bnd
@@ -942,6 +953,8 @@ end
 
         u1 = d1 ∪ d2
         u2 = u1 ∪ d3
+        @test dimension(u1) == 2
+        @test dimension(u2) == 2
 
         u3 = d3 ∪ u1
         u4 = u1 ∪ u2
@@ -997,6 +1010,8 @@ end
         i2 = d1 & d2
         show(io,i2)
         @test String(take!(io)) == "the intersection of 2 domains:\n\t1.\t: the 2-dimensional closed unit ball\n\t2.\t: -0.4..0.4 x -0.4..0.4\n"
+        @test dimension(i1) == 2
+        @test dimension(i2) == 2
 
         i3 = d3 & i2
         i4 = i2 & d3
@@ -1027,6 +1042,7 @@ end
         d = d1\d2
         show(io,d)
         @test String(take!(io)) == "the difference of 2 domains:\n\t1.\t: the 2-dimensional closed unit ball\n\t2.\t: -0.5..0.5 x -0.1..0.1\n"
+        @test dimension(d) == 2
 
         x = SVector(0.,.74)
         y = SVector(0.,.25)