make BlockMap/UniformScalingMap typing consistent with rest, inference tests

Author: dkarrasch

src/blockmap.jl

@@ -1,11 +1,16 @@
 struct BlockMap{T,As<:Tuple{Vararg{LinearMap}},Rs<:Tuple{Vararg{Int}}} <: LinearMap{T}
     maps::As
     rows::Rs
-    function BlockMap(maps::R, rows::S) where {T, R<:Tuple{Vararg{LinearMap{T}}}, S<:Tuple{Vararg{Int}}}
-        new{T,R,S}(maps, rows)
+    function BlockMap{T,R,S}(As::R, rows::S) where {T, R<:Tuple{Vararg{LinearMap}}, S<:Tuple{Vararg{Int}}}
+        for A in As
+            promote_type(T, eltype(A)) == T || throw(InexactError())
+        end
+        new{T,R,S}(As, rows)
     end
 end
 
+BlockMap{T}(maps::As, rows::S) where {T,As<:Tuple{Vararg{LinearMap}},S} = BlockMap{T,As,S}(maps, rows)
+
 firstindices(maps::Tuple{Vararg{LinearMap}}, dim) = cumsum([1, map(m -> size(m, dim), maps)...,])
 
 function check_dims(maps::Tuple{Vararg{LinearMap}}, k)
@@ -42,12 +47,6 @@ function Base.hcat(As::Union{LinearMap,UniformScaling}...)
     T = promote_type(map(eltype, As)...)
     nbc = length(As)
 
-    for A in As
-        if !(A isa UniformScaling)
-            eltype(A) == T || throw(ArgumentError("eltype mismatch in hcat of linear maps"))
-        end
-    end
-
     nrows = 0
     # find first non-UniformScaling to detect number of rows
     for A in As
@@ -60,7 +59,7 @@ function Base.hcat(As::Union{LinearMap,UniformScaling}...)
 
     maps = promote_to_lmaps(ntuple(i->nrows, nbc), 1, T, As...)
     check_dims(maps, 1)
-    return BlockMap(maps, (length(As),))
+    return BlockMap{T}(maps, (length(As),))
 end
 
 ############
@@ -71,12 +70,6 @@ function Base.vcat(As::Union{LinearMap,UniformScaling}...)
     T = promote_type(map(eltype, As)...)
     nbr = length(As)
 
-    for A in As
-        if !(A isa UniformScaling)
-            eltype(A) == T || throw(ArgumentError("eltype type mismatch in vcat of linear maps"))
-        end
-    end
-
     ncols = 0
     # find first non-UniformScaling to detect number of columns
     for A in As
@@ -89,7 +82,7 @@ function Base.vcat(As::Union{LinearMap,UniformScaling}...)
 
     maps = promote_to_lmaps(ntuple(i->ncols, nbr), 1, T, As...)
     check_dims(maps, 2)
-    return BlockMap(maps, ntuple(i->1, length(As)))
+    return BlockMap{T}(maps, ntuple(i->1, length(As)))
 end
 
 ############
@@ -148,7 +141,7 @@ function Base.hvcat(rows::NTuple{nr,Int}, As::Union{LinearMap,UniformScaling}...
         end
     end
 
-    return BlockMap(promote_to_lmaps(n, 1, T, As...), rows)
+    return BlockMap{T}(promote_to_lmaps(n, 1, T, As...), rows)
 end
 
 promote_to_lmaps_(n::Int, ::Type{T}, J::UniformScaling) where {T} = UniformScalingMap(convert(T, J.λ), n)

src/uniformscalingmap.jl

@@ -1,4 +1,4 @@
-struct UniformScalingMap{T} <: LinearMap{T} # T will be determined from maps to which this is added
+struct UniformScalingMap{T} <: LinearMap{T}
     λ::T
     M::Int
 end
@@ -38,11 +38,7 @@ At_mul_B!(y::AbstractVector, A::UniformScalingMap, x::AbstractVector) = A_mul_B!
 Ac_mul_B!(y::AbstractVector, A::UniformScalingMap, x::AbstractVector) = A_mul_B!(y, adjoint(A), x)
 
 # combine LinearMap and UniformScaling objects in linear combinations
-Base.:(+)(A1::LinearMap, A2::UniformScaling) =
-    A1 + UniformScalingMap(convert(promote_type(eltype(A1), eltype(A2)), A2.λ), size(A1, 1))
-Base.:(+)(A1::UniformScaling, A2::LinearMap) =
-    UniformScalingMap(convert(promote_type(eltype(A1), eltype(A2)), A1.λ), size(A2, 1)) + A2
-Base.:(-)(A1::LinearMap, A2::UniformScaling) =
-    A1 - UniformScalingMap(convert(promote_type(eltype(A1), eltype(A2)), A2.λ), size(A1, 1))
-Base.:(-)(A1::UniformScaling, A2::LinearMap) =
-    UniformScalingMap(convert(promote_type(eltype(A1), eltype(A2)), A1.λ), size(A2, 1)) - A2
+Base.:(+)(A1::LinearMap, A2::UniformScaling) = A1 + UniformScalingMap(A2.λ, size(A1, 1))
+Base.:(+)(A1::UniformScaling, A2::LinearMap) = UniformScalingMap(A1.λ, size(A2, 1)) + A2
+Base.:(-)(A1::LinearMap, A2::UniformScaling) = A1 - UniformScalingMap(A2.λ, size(A1, 1))
+Base.:(-)(A1::UniformScaling, A2::LinearMap) = UniformScalingMap(A1.λ, size(A2, 1)) - A2

test/runtests.jl

@@ -11,8 +11,8 @@ V = rand(ComplexF64, 10, 3)
 W = rand(ComplexF64, 20, 3)
 α = rand()
 β = rand()
-M = LinearMap(A)
-N = LinearMap(M)
+M = @inferred LinearMap(A)
+N = @inferred LinearMap(M)
 
 @testset "LinearMaps.jl" begin
     @test eltype(M) == eltype(A)
@@ -74,7 +74,7 @@ end
     @test @inferred LinearMap(M')' * v == A * v
     @test @inferred transpose(transpose(M)) == M
     @test (M')' == M
-    Mherm = LinearMap(A'A)
+    Mherm = @inferred LinearMap(A'A)
     @test @inferred ishermitian(Mherm)
     @test @inferred !issymmetric(Mherm)
     @test @inferred !issymmetric(transpose(Mherm))
@@ -98,11 +98,11 @@ end
     @test @inferred mul!(copy(V), transpose(M), W) ≈ transpose(A) * W
     @test @inferred mul!(copy(V), adjoint(M), W) ≈ A' * W
 
-    B = LinearMap(Symmetric(rand(10, 10)))
+    B = @inferred LinearMap(Symmetric(rand(10, 10)))
     @test transpose(B) == B
     @test B == transpose(B)
 
-    B = LinearMap(Hermitian(rand(ComplexF64, 10, 10)))
+    B = @inferred LinearMap(Hermitian(rand(ComplexF64, 10, 10)))
     @test adjoint(B) == B
     @test B == B'
 end
@@ -121,40 +121,40 @@ end
         end
         return w
     end
-    MyFT = LinearMap{ComplexF64}(myft, N) / sqrt(N)
+    MyFT = @inferred LinearMap{ComplexF64}(myft, N) / sqrt(N)
     U = Matrix(MyFT) # will be a unitary matrix
     @test @inferred U'U ≈ Matrix{eltype(U)}(I, N, N)
 
-    CS = LinearMap(cumsum, 2)
+    CS = @inferred LinearMap(cumsum, 2)
     @test size(CS) == (2, 2)
     @test @inferred !issymmetric(CS)
     @test @inferred !ishermitian(CS)
     @test @inferred !isposdef(CS)
     @test @inferred !(LinearMaps.ismutating(CS))
     @test @inferred Matrix(CS) == [1. 0.; 1. 1.]
     @test @inferred Array(CS) == [1. 0.; 1. 1.]
-    CS = LinearMap(cumsum, 10; ismutating=false)
+    CS = @inferred LinearMap(cumsum, 10; ismutating=false)
     v = rand(10)
     cv = cumsum(v)
     @test CS * v == cv
     @test *(CS, v) == cv
     @test_throws ErrorException CS' * v
-    CS = LinearMap(cumsum, x -> cumsum(reverse(x)), 10; ismutating=false)
+    CS = @inferred LinearMap(cumsum, x -> cumsum(reverse(x)), 10; ismutating=false)
     cv = cumsum(v)
     @test @inferred CS * v == cv
     @test @inferred *(CS, v) == cv
     @test @inferred CS' * v == cumsum(reverse(v))
     @test @inferred mul!(similar(v), transpose(CS), v) == cumsum(reverse(v))
 
-    CS! = LinearMap(cumsum!, 10; ismutating=true)
+    CS! = @inferred LinearMap(cumsum!, 10; ismutating=true)
     @test @inferred LinearMaps.ismutating(CS!)
     @test @inferred CS! * v == cv
     @test @inferred *(CS!, v) == cv
     @test @inferred mul!(similar(v), CS!, v) == cv
     @test_throws ErrorException CS!'v
     @test_throws ErrorException transpose(CS!) * v
 
-    CS! = LinearMap{ComplexF64}(cumsum!, 10; ismutating=true)
+    CS! = @inferred LinearMap{ComplexF64}(cumsum!, 10; ismutating=true)
     v = rand(ComplexF64, 10)
     cv = cumsum(v)
     @test @inferred LinearMaps.ismutating(CS!)
@@ -173,17 +173,17 @@ end
     @test @inferred mul!(similar(v), adjoint(CS), v) == cumsum(reverse(v))
 
     # Test fallback methods:
-    L = LinearMap(x -> x, x -> x, 10)
+    L = @inferred LinearMap(x -> x, x -> x, 10)
     v = randn(10)
     @test @inferred (2 * L)' * v ≈ 2 * v
     @test @inferred transpose(2 * L) * v ≈ 2 * v
-    L = LinearMap{ComplexF64}(x -> x, x -> x, 10)
+    L = @inferred LinearMap{ComplexF64}(x -> x, x -> x, 10)
     v = rand(ComplexF64, 10)
     @test @inferred (2 * L)' * v ≈ 2 * v
     @test @inferred transpose(2 * L) * v ≈ 2 * v
 end
 
-CS! = LinearMap(cumsum!, 10; ismutating=true)
+CS! = @inferred LinearMap(cumsum!, 10; ismutating=true)
 v = rand(10)
 u = similar(v)
 b = @benchmarkable mul!(u, CS!, v)
@@ -196,9 +196,9 @@ b = @benchmarkable mul!(u, L, v)
 
 A = 2 * rand(ComplexF64, (10, 10)) .- 1
 B = rand(size(A)...)
-M = LinearMap(A)
-N = LinearMap(B)
-LC = M + N
+M = @inferred LinearMap(A)
+N = @inferred LinearMap(B)
+LC = @inferred M + N
 v = rand(ComplexF64, 10)
 w = similar(v)
 b = @benchmarkable mul!(w, M, v)
@@ -251,11 +251,11 @@ Base.:(*)(A::Union{SimpleFunctionMap,SimpleComplexFunctionMap}, v::Vector) = A.f
 mul!(y::Vector, A::Union{SimpleFunctionMap,SimpleComplexFunctionMap}, x::Vector) = copyto!(y, *(A, x))
 
 @testset "composition" begin
-    F = LinearMap(cumsum, 10; ismutating=false)
+    F = @inferred LinearMap(cumsum, 10; ismutating=false)
     A = 2 * rand(ComplexF64, (10, 10)) .- 1
     B = rand(size(A)...)
-    M = 1 * LinearMap(A)
-    N = LinearMap(B)
+    M = @inferred 1 * LinearMap(A)
+    N = @inferred LinearMap(B)
     @test @inferred (F * F) * v == @inferred F * (F * v)
     @test @inferred (F * A) * v == @inferred F * (A * v)
     @test @inferred (A * F) * v == @inferred A * (F * v)
@@ -276,20 +276,21 @@ mul!(y::Vector, A::Union{SimpleFunctionMap,SimpleComplexFunctionMap}, x::Vector)
     @test @inferred transpose(M * F) == @inferred transpose(F) * transpose(M)
     @test @inferred (4*((-3*M)*2)) == @inferred -12M*2
     @test @inferred (4*((3*(-M))*2)*(-5)) == @inferred -12M*(-10)
-    L = 3 * F + 1im * A + F * M' * F
+    L = @inferred 3 * F + 1im * A + F * M' * F
     LF = 3 * Matrix(F) + 1im * A + Matrix(F) * Matrix(M)' * Matrix(F)
     @test Array(L) ≈ LF
     R1 = rand(ComplexF64, 10, 10); L1 = LinearMap(R1)
     R2 = rand(ComplexF64, 10, 10); L2 = LinearMap(R2)
     R3 = rand(ComplexF64, 10, 10); L3 = LinearMap(R3)
     CompositeR = prod(R -> LinearMap(R), [R1, R2, R3])
-    @test transpose(CompositeR) == transpose(L3) * transpose(L2) * transpose(L1)
-    @test adjoint(CompositeR) == L3' * L2' * L1'
-    @test adjoint(adjoint((CompositeR))) == CompositeR
+    @test @inferred L1 * L2 * L3 == CompositeR
+    @test @inferred transpose(CompositeR) == transpose(L3) * transpose(L2) * transpose(L1)
+    @test @inferred adjoint(CompositeR) == L3' * L2' * L1'
+    @test @inferred adjoint(adjoint((CompositeR))) == CompositeR
     @test transpose(transpose((CompositeR))) == CompositeR
-    Lt = transpose(LinearMap(CompositeR))
+    Lt = @inferred transpose(LinearMap(CompositeR))
     @test Lt * v ≈ transpose(R3) * transpose(R2) * transpose(R1) * v
-    Lc = adjoint(LinearMap(CompositeR))
+    Lc = @inferred adjoint(LinearMap(CompositeR))
     @test Lc * v ≈ R3' * R2' * R1' * v
 
     # test inplace operations
@@ -360,9 +361,9 @@ A = rand(10, 20)
 B = rand(ComplexF64, 10, 20)
 SA = A'A + I
 SB = B'B + I
-L = LinearMap{Float64}(A)
-MA = LinearMap(SA)
-MB = LinearMap(SB)
+L = @inferred LinearMap{Float64}(A)
+MA = @inferred LinearMap(SA)
+MB = @inferred LinearMap(SB)
 @testset "wrapped maps" begin
     @test size(L) == size(A)
     @test @inferred !issymmetric(L)
@@ -375,12 +376,12 @@ end
 A = 2 * rand(ComplexF64, (10, 10)) .- 1
 B = rand(size(A)...)
 M = @inferred 1 * LinearMap(A)
-N = LinearMap(B)
-LC = M + N
+N = @inferred LinearMap(B)
+LC = @inferred M + N
 v = rand(ComplexF64, 10)
 w = similar(v)
 @testset "identity/scaling map" begin
-    Id = LinearMaps.UniformScalingMap(1, 10)
+    Id = @inferred LinearMaps.UniformScalingMap(1, 10)
     @test_throws ErrorException LinearMaps.UniformScalingMap(1, 10, 20)
     @test_throws ErrorException LinearMaps.UniformScalingMap(1, (10, 20))
     @test size(Id) == (10, 10)
@@ -538,16 +539,16 @@ end
             @test size(L) == size(A)
             @test L * x ≈ A * x
             @test Matrix(L) ≈ A
-            Lt = transform(L)
+            Lt = @inferred transform(L)
             @test Lt isa LinearMaps.LinearMap{elty}
             @test Lt * x ≈ transform(A) * x
-            Lt = transform(LinearMap(L))
+            Lt = @inferred transform(LinearMap(L))
             @test Lt * x ≈ transform(A) * x
             @test Matrix(Lt) ≈ Matrix(transform(A))
             A21 = rand(elty, 10, 10)
             A = [I A12; A21 I]
             L = [I LinearMap(A12); LinearMap(A21) I]
-            Lt = transform(L)
+            Lt = @inferred transform(L)
             @test Lt isa LinearMaps.LinearMap{elty}
             @test Lt * x ≈ transform(A) * x
             @test Matrix(Lt) ≈ Matrix(transform(A))