use IdentityMap constructor more often

Author: daanhb

src/concrete/basic.jl

@@ -7,7 +7,7 @@ IdentityMap() = StaticIdentityMap()
 IdentityMap(::Val{N}) where {N} = StaticIdentityMap(Val(N))
 
 IdentityMap{T}(n::Int) where {T} = DynamicIdentityMap{T}(n)
-IdentityMap{T}(n::Int) where {T<:StaticTypes} = StaticIdentityMap{T}()
+IdentityMap{T}(n::Int) where {T<:StaticTypes} = StaticIdentityMap{T}(n)
 IdentityMap{T}(::Val{N}) where {N,T} = StaticIdentityMap{T}(Val(N))
 IdentityMap{T}() where {T} = StaticIdentityMap{T}()
 
@@ -50,10 +50,14 @@ end
 StaticIdentityMap() = StaticIdentityMap{Float64}()
 StaticIdentityMap(::Val{N}) where {N} = StaticIdentityMap{SVector{N,Float64}}()
 
-StaticIdentityMap{T}(n::Int) where {T} =
-    (@assert n == euclideandimension(T); StaticIdentityMap{T}())
-StaticIdentityMap{T}(::Val{N}) where {N,T} =
-    (@assert N == euclideandimension(T); StaticIdentityMap{T}())
+function StaticIdentityMap{T}(n::Int) where {T}
+    n == euclideandimension(T) || throw(ArgumentError("Provided dimension of static map is inconsistent with static type"))
+    StaticIdentityMap{T}()
+end
+function StaticIdentityMap{T}(::Val{N}) where {N,T}
+    N == euclideandimension(T) || throw(ArgumentError("Provided dimension of static map is inconsistent with static type"))
+    StaticIdentityMap{T}()
+end
 
 similarmap(m::StaticIdentityMap, ::Type{T}) where {T<:StaticTypes} = StaticIdentityMap{T}()
 similarmap(m::StaticIdentityMap, ::Type{T}) where {T} =

test/test_affine.jl

@@ -50,7 +50,7 @@ function test_linearmap(T)
     @test mw1.A isa widen(T)
     @test jacobian(m1) isa ConstantMap{T}
     @test jacobian(m1, 1) == 2
-    @test LinearMap(one(T)) == StaticIdentityMap{T}()
+    @test LinearMap(one(T)) == IdentityMap{T}()
 
     m2 = LinearMap(2)
     @test domaintype(m2) == Int
@@ -60,15 +60,15 @@ function test_linearmap(T)
     @test jacobian(m2, 1) == 2
     @test jacobian(m2) isa ConstantMap{Int}
     @test jacobian(m2, 1) == 2
-    @test LinearMap(1) == StaticIdentityMap{T}()
+    @test LinearMap(1) == IdentityMap{T}()
 
     m3 = LinearMap(SMatrix{2,2}(one(T), 2one(T), 3one(T), 4one(T)))
     @test m3 isa LinearMap{SVector{2,T}}
     @test m3 === StaticLinearMap(m3.A)
     @test m3(SVector(1,2)) == SVector(7, 10)
     @test m3(SVector{2,T}(1,2)) == SVector{2,T}(7, 10)
     @test m3 ∘ m3 isa LinearMap
-    @test LinearMap(SA[1 0; 0 1]) == StaticIdentityMap{domaintype(m3)}()
+    @test LinearMap(SA[1 0; 0 1]) == IdentityMap{domaintype(m3)}()
 
     A = rand(T,2,2)
     m4 = LinearMap(A)

test/test_basic.jl

@@ -58,15 +58,17 @@ function test_scaling_maps(T)
 end
 
 function test_identity_map(T)
-    i1 = StaticIdentityMap{T}()
-    i2 = StaticIdentityMap{SVector{2,T}}()
+    i1 = IdentityMap{T}()
+    @test i1 isa FunctionMaps.StaticIdentityMap
+    i2 = IdentityMap{SVector{2,T}}()
+    @test i2 isa FunctionMaps.StaticIdentityMap
     test_generic_map(i1)
     test_generic_map(i2)
     @test i1 == i2
     @test hash(i1) == hash(i2)
     @test islinearmap(i1)
     @test isaffinemap(i1)
-    @test convert(StaticIdentityMap{SVector{2,T}}, i1) === i2
+    @test convert(FunctionMaps.StaticIdentityMap{SVector{2,T}}, i1) === i2
     @test jacobian(i1) isa ConstantMap
     @test jacobian(i1, 1) == 1
     @test jacdet(i1, 1) == 1
@@ -78,13 +80,19 @@ function test_identity_map(T)
     @test m2 isa LinearMap{T}
     @test jacdet(m2, 1) == 1
 
-    i3 = VectorIdentityMap{T}(10)
+    i3 = IdentityMap{Vector{T}}(10)
+    @test i3 isa FunctionMaps.VectorIdentityMap
     test_generic_map(i3)
     r = rand(T, 10)
     @test i3(r) ≈ r
-    @test hash(i3) == hash(VectorIdentityMap{Int}(10))
+    @test hash(i3) == hash(IdentityMap{Vector{Int}}(10))
 
     @test IdentityMap() ∘ LinearMap(2) == LinearMap(2.0)
+
+    @test_throws ArgumentError IdentityMap{Float64}(10)
+    @test_throws ArgumentError IdentityMap{Float64}(Val(2))
+    @test IdentityMap{Float64}(1) isa Map
+    @test IdentityMap{Float64}(Val(1)) isa Map
 end
 
 function test_basic_maps(T)

test/test_maps.jl

@@ -1,7 +1,7 @@
 
 maps_to_test(T) = [
-    StaticIdentityMap{T}(),
-    VectorIdentityMap{T}(10),
+    IdentityMap{T}(),
+    IdentityMap{Vector{T}}(10),
     ConstantMap{T}(one(T)),
     ConstantMap{T}(SVector{2,T}(1,2)),
     ZeroMap{T}(),
@@ -108,7 +108,7 @@ function test_composite_map(T)
     b = T(1)
     c = T(2)
     d = T(3)
-    ma = StaticIdentityMap{T}()
+    ma = IdentityMap{T}()
     mb = interval_map(a, b, c, d)
 
     r = suitable_point_to_map(ma)

test/test_product.jl

@@ -1,5 +1,5 @@
 function test_product_map(T)
-    ma = StaticIdentityMap{T}()
+    ma = IdentityMap{T}()
     mb = interval_map(T(0), T(1), T(2), T(3))
 
     r1 = suitable_point_to_map(ma)