Retain Vector{Operator{T}} in convert (#292)

* retain Vector{Operator{T}} in convert

* Add tests

* Fix scope issue

Author: jishnub

Project.toml

@@ -1,6 +1,6 @@
 name = "ApproxFunBase"
 uuid = "fbd15aa5-315a-5a7d-a8a4-24992e37be05"
-version = "0.7.40"
+version = "0.7.41"
 
 [deps]
 AbstractFFTs = "621f4979-c628-5d54-868e-fcf4e3e8185c"

src/Operators/general/algebra.jl

@@ -47,14 +47,20 @@ for (OP,mn) in ((:colstart,:min),(:colstop,:max),(:rowstart,:min),(:rowstop,:max
     end
 end
 
+# We assume that a Vector{Operator{T}} occurs when incompatible operators are added
+# in this case, we may retain the container
+_convertops(::Type{Operator{T}}, ops) where {T} =
+    map(x -> strictconvert(Operator{T}, x), ops)
+_convertops(::Type{Operator{T}}, ops::Vector{Operator{S}}) where {T,S} =
+    Operator{T}[strictconvert(Operator{T}, op) for op in ops]
 function convert(::Type{Operator{T}}, P::PlusOperator) where T
     if T==eltype(P)
         P
     else
         ops = P.ops
-        PlusOperator(ops isa AbstractVector{<:Operator{T}} ? ops :
-                map(x -> strictconvert(Operator{T}, x), ops),
-            P.bandwidths,P.sz)::Operator{T}
+        PlusOperator(eltype(ops) <: Operator{T} ? ops :
+                _convertops(Operator{T}, ops),
+            P.bandwidths, P.sz)::Operator{T}
     end
 end
 
@@ -272,8 +278,8 @@ function convert(::Type{Operator{T}},P::TimesOperator) where T
         P
     else
         ops = P.ops
-        TimesOperator(ops isa AbstractVector{<:Operator{T}} ? ops :
-                map(x -> strictconvert(Operator{T}, x), ops) ,
+        TimesOperator(eltype(ops) <: Operator{T} ? ops :
+                _convertops(Operator{T}, ops) ,
             bandwidths(P), size(P))
     end
 end

test/runtests.jl

@@ -235,7 +235,22 @@ end
             @test (@inferred Z + Z + Z) == Z
             @test (@inferred Z + Z + Z + Z) == Z
 
-            @inferred (() -> (D = Derivative(); D + D))()
+            @inferred (() -> (local D = Derivative(); D + D))()
+
+            A = @inferred M + M
+            @test A * f ≈ 2 * (M * f)
+            M = Multiplication(f, space(f))
+            A = M + M
+            @test A * f ≈ 2 * (M * f)
+            B = @inferred convert(Operator{ComplexF64}, A)
+            @test eltype(B) == ComplexF64
+            @test B * f ≈ 2 * (M * f)
+
+            C = @inferred 2M
+            D = M + C
+            E = @inferred convert(Operator{ComplexF64}, D)
+            @test eltype(E) == ComplexF64
+            @test E * f ≈ 3 * (M * f)
         end
     end