Tuple recursion in KroneckerOperator banded checks (#343)

* tuple recursion in kronop banded checks

* Version bump to v0.7.61

* fix isbandedblockbanded

Author: jishnub

Project.toml

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

src/Multivariate/TensorSpace.jl

@@ -305,7 +305,7 @@ dimension(sp::TensorSpace) = mapreduce(dimension,*,sp.spaces)
 conversion_rule(a::TensorSpace{<:NTuple{2,Space}}, b::TensorSpace{<:NTuple{2,Space}}) =
     conversion_type(a.spaces[1],b.spaces[1]) ⊗ conversion_type(a.spaces[2],b.spaces[2])
 
-maxspace(a::TensorSpace{<:NTuple{2,Space}}, b::TensorSpace{<:NTuple{2,Space}}) =
+maxspace_rule(a::TensorSpace{<:NTuple{2,Space}}, b::TensorSpace{<:NTuple{2,Space}}) =
     maxspace(a.spaces[1],b.spaces[1]) ⊗ maxspace(a.spaces[2],b.spaces[2])
 
 function spacescompatible(A::TensorSpace{<:NTuple{N,Space}}, B::TensorSpace{<:NTuple{N,Space}}) where {N}
@@ -319,7 +319,7 @@ end
 canonicalspace(T::TensorSpace) = TensorSpace(map(canonicalspace,T.spaces))
 
 
-TensorSpace(A::SVector{N,<:Space}) where N = TensorSpace(tuple(A...))
+TensorSpace(A::SVector{<:Any,<:Space}) = TensorSpace(Tuple(A))
 TensorSpace(A...) = TensorSpace(A)
 TensorSpace(A::ProductDomain) = TensorSpace(tuple(map(Space,components(A))...))
 ⊗(A::TensorSpace,B::TensorSpace) = TensorSpace(A.spaces...,B.spaces...)

src/PDE/KroneckerOperator.jl

@@ -105,11 +105,22 @@ end
 
 bandwidths(K::KroneckerOperator) = (ℵ₀,ℵ₀)
 
-isblockbanded(K::KroneckerOperator) = all(isblockbanded,K.ops)
-isbandedblockbanded(K::KroneckerOperator) =
-    all(op->isbanded(op) && isinf(size(op,1)) && isinf(size(op,2)),K.ops)
-israggedbelow(K::KroneckerOperator) = all(israggedbelow,K.ops)
-
+for f in [:isblockbanded, :israggedbelow]
+    _f = Symbol(:_, f)
+    @eval begin
+        $f(K::KroneckerOperator) = $(_f)(K.ops)
+        function $(_f)(ops::Tuple)
+            $f(first(ops)) && $(_f)(Base.tail(ops))
+        end
+        $(_f)(::Tuple{}) = true
+    end
+end
+isbandedblockbanded(K::KroneckerOperator) = _isbandedblockbanded(K.ops)
+isbandedblockbandedcheck(op) = isbanded(op) && isinf(size(op,1)) && isinf(size(op,2))
+function _isbandedblockbanded(ops::Tuple)
+    isbandedblockbandedcheck(first(ops)) && _isbandedblockbanded(Base.tail(ops))
+end
+_isbandedblockbanded(::Tuple{}) = true
 
 blockbandwidths(K::KroneckerOperator) =
     (blockbandwidth(K.ops[1],1)+blockbandwidth(K.ops[2],1),

src/Space.jl

@@ -329,7 +329,7 @@ union(a::Space, bs::Space...) = foldl(union, bs, init = a)
 """
     hasconversion(a,b)
 
-Test whether a banded `Conversion` operator exists.
+Test whether a banded `Conversion` operator exists from `a` to `b`.
 """
 hasconversion(a,b) = maxspace(a,b) == b
 
@@ -369,8 +369,6 @@ _Fun(v, sp) = Fun(v, sp)
 _maybeconvert(inplace::Val{true}, f, v) = v
 _maybeconvert(inplace::Val{false}, f::AbstractVector, v) = strictconvert(Vector{float(eltype(f))}, v)
 function defaultcoefficients(f,a,b,inplace = Val(false))
-    ct=conversion_type(a,b) # gives a space that has a banded conversion to both a and b
-
     x = if spacescompatible(a,b)
         f
     elseif hasconversion(a,b)