tuples in promoterangespace and friends (#214)

* tuples in promoterangespace and friends

* stricter type inference in _maybetypedmap

Co-authored-by: Jishnu Bhattacharya <[email protected]>

Author: jishnub

src/Operators/general/InterlaceOperator.jl

@@ -110,8 +110,8 @@ function InterlaceOperator(ops::AbstractMatrix{<:Operator},ds::Space,rs::Space)
         l,u = (1-dimension(rs),dimension(ds)-1)  # not banded
     end
 
-
-    InterlaceOperator(ops,ds,rs,
+    opsm = convert(Matrix{Operator{mapreduce(eltype, promote_type, ops)}}, ops)
+    InterlaceOperator(opsm,ds,rs,
                         cache(dsi),
                         cache(rsi),
                         (l,u))
@@ -134,8 +134,8 @@ function InterlaceOperator(ops::Vector{<:Operator},ds::Space,rs::Space)
         l,u = (1-dimension(rs),dimension(ds)-1)  # not banded
     end
 
-
-    InterlaceOperator(ops,ds,rs,
+    opsv = convert(Vector{Operator{mapreduce(eltype, promote_type, ops)}}, ops)
+    InterlaceOperator(opsv,ds,rs,
                         cache(BlockInterlacer(tuple(blocklengths(ds)))),
                         cache(interlacer(rs)),
                         (l,u))
@@ -176,13 +176,22 @@ InterlaceOperator(opsin::AbstractMatrix{<:Operator},::Type{DS}) where {DS<:Space
 InterlaceOperator(opsin::AbstractMatrix,S...) =
     InterlaceOperator(Matrix{Operator{mapreduce(eltype,promote_type,opsin)}}(promotespaces(opsin)),S...)
 
-function InterlaceOperator(opsin::Union{Vector{<:Operator}, Tuple{Operator, Vararg{Operator}}})
-    ops=promotedomainspace(opsin)
-    InterlaceOperator(ops,domainspace(first(ops)),rangespace(ops))
+_convertVector(v::AbstractVector) = convert(Vector, v)
+_convertVector(t::Tuple) = [t...]
+
+function InterlaceOperator(opsin::AbstractVector{<:Operator})
+    ops = promotedomainspace(opsin)
+    opsv = _convertVector(ops)
+    InterlaceOperator(opsv, domainspace(first(ops)), rangespace(opsv))
+end
+function InterlaceOperator(opsin::Tuple{Operator, Vararg{Operator}})
+    ops = promotedomainspace(opsin)
+    opsv = _convertVector(ops)
+    InterlaceOperator(opsv, domainspace(first(ops)), rangespace(opsv))
 end
 
-InterlaceOperator(ops::AbstractArray{T,p}) where {T,p} =
-    InterlaceOperator(Array{Operator{mapreduce(eltype,promote_type,ops)},p}(ops))
+InterlaceOperator(ops::AbstractArray) =
+    InterlaceOperator(Array{Operator{mapreduce(eltype,promote_type,ops)}, ndims(ops)}(ops))
 
 
 function convert(::Type{Operator{T}},S::InterlaceOperator) where T
@@ -450,7 +459,7 @@ __vcat(a::OperatorTypes, b::OperatorTypes...) = (a, __vcat(b...)...)
 __vcat() = ()
 function _vcat(A::OperatorTypes...)
     Av = __vcat(A...)
-    InterlaceOperator(vnocat(Av...))
+    InterlaceOperator(map(x -> convert(Operator, x), Av))
 end
 
 

src/Operators/spacepromotion.jl

@@ -88,32 +88,37 @@ promotedomainspace(P::Operator,sp::Space,cursp::Space) =
 
 const VectorOrTupleOfOp{O<:Operator} = Union{AbstractVector{O}, Tuple{O, Vararg{O}}}
 
+__maybetypedmap(f, k, ops) = map(op->f(op,k), ops)
+_maybetypedmap(f, k, O, ops::AbstractVector) =
+    strictconvert(Vector{O}, __maybetypedmap(f, k, ops))
+_maybetypedmap(f, k, O, ops) = __maybetypedmap(f, k, ops)
+
 function promoterangespace(ops::VectorOrTupleOfOp{O}) where O<:Operator
     isempty(ops) && return strictconvert(Vector{Operator{eltype(O)}}, ops)
     k=findmaxrangespace(ops)
     #TODO: T might be incorrect
     T=mapreduce(eltype,promote_type,ops)
-    Operator{T}[promoterangespace(op,k) for op in ops]
+    _maybetypedmap(promoterangespace, k, Operator{T}, ops)
 end
 function promotedomainspace(ops::VectorOrTupleOfOp{O}) where O<:Operator
     isempty(ops) && return strictconvert(Vector{Operator{eltype(O)}}, ops)
     k=findmindomainspace(ops)
     #TODO: T might be incorrect
     T=mapreduce(eltype,promote_type,ops)
-    Operator{T}[promotedomainspace(op,k) for op in ops]
+    _maybetypedmap(promotedomainspace, k, Operator{T}, ops)
 end
 function promotedomainspace(ops::VectorOrTupleOfOp{O}, S::Space) where O<:Operator
     isempty(ops) && return strictconvert(Vector{Operator{eltype(O)}}, ops)
     k=conversion_type(findmindomainspace(ops),S)
     #TODO: T might be incorrect
     T=promote_type(mapreduce(eltype,promote_type,ops),prectype(S))
-    Operator{T}[promotedomainspace(op,k) for op in ops]
+    _maybetypedmap(promotedomainspace, k, Operator{T}, ops)
 end
 
 
 
 ####
-# choosedomainspace returns a potental domainspace
+# choosedomainspace returns a potential domainspace
 # where the second argument is a target rangespace
 # it defaults to the true domainspace, but if this is ambiguous
 # it tries to decide a space.