CompatHelper: bump compat for "InfiniteArrays" to "0.11" (#77)

* CompatHelper: bump compat for "InfiniteArrays" to "0.11"

* Move issubset to DomainSets.jl

* Fixes for DomainSets v0.5

* more bug fixes

* Update multivariate.jl

* tests pass

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: Sheehan Olver <[email protected]>

Author: github-actions[bot]

Project.toml

@@ -1,6 +1,6 @@
 name = "ApproxFunBase"
 uuid = "fbd15aa5-315a-5a7d-a8a4-24992e37be05"
-version = "0.4.6"
+version = "0.5"
 
 [deps]
 AbstractFFTs = "621f4979-c628-5d54-868e-fcf4e3e8185c"
@@ -15,6 +15,7 @@ FFTW = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341"
 FastGaussQuadrature = "442a2c76-b920-505d-bb47-c5924d526838"
 FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b"
 InfiniteArrays = "4858937d-0d70-526a-a4dd-2d5cb5dd786c"
+InfiniteLinearAlgebra = "cde9dba0-b1de-11e9-2c62-0bab9446c55c"
 IntervalSets = "8197267c-284f-5f27-9208-e0e47529a953"
 LazyArrays = "5078a376-72f3-5289-bfd5-ec5146d43c02"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
@@ -33,12 +34,13 @@ BlockArrays = "0.14, 0.15, 0.16"
 BlockBandedMatrices = "0.10"
 Calculus = "0.5"
 DSP = "0.6, 0.7"
-DomainSets = "0.4, 0.5"
+DomainSets = "0.5"
 DualNumbers = "0.6.2"
 FFTW = "0.3, 1"
 FastGaussQuadrature = "0.4"
 FillArrays = "0.11, 0.12"
-InfiniteArrays = "0.10"
+InfiniteArrays = "0.11"
+InfiniteLinearAlgebra = "0.5"
 IntervalSets = "0.5"
 LazyArrays = "0.20, 0.21"
 LowRankApprox = "0.2, 0.3, 0.4, 0.5"

src/ApproxFunBase.jl

@@ -1,12 +1,13 @@
 module ApproxFunBase
-    using Base, BlockArrays, BandedMatrices, BlockBandedMatrices, DomainSets, IntervalSets,
+    using Base: AnyDict
+using Base, BlockArrays, BandedMatrices, BlockBandedMatrices, DomainSets, IntervalSets,
             SpecialFunctions, AbstractFFTs, FFTW, SpecialFunctions, DSP, DualNumbers, 
-            LinearAlgebra, SparseArrays, LowRankApprox, FillArrays, InfiniteArrays #, Arpack
+            LinearAlgebra, SparseArrays, LowRankApprox, FillArrays, InfiniteArrays, InfiniteLinearAlgebra #, Arpack
 import StaticArrays, Calculus
 
 import DomainSets: Domain, indomain, UnionDomain, ProductDomain, FullSpace, Point, elements, DifferenceDomain,
             Interval, ChebyshevInterval, boundary, ∂, rightendpoint, leftendpoint,
-            dimension, WrappedDomain, VcatDomain
+            dimension, WrappedDomain, VcatDomain, component, components, ncomponents
 
 
 

src/Caching/bandedblockbanded.jl

@@ -25,7 +25,7 @@ function resizedata!(B::CachedOperator{T,<:BandedBlockBandedMatrix{T}}, ::Colon,
 
         # B.data = _BandedBlockBandedMatrix(PseudoBlockArray
 
-        blocks = PseudoBlockArray(pad(B.data.data.blocks,:,(l+u+1)*sum(cols)), rows, cols)
+        blocks = PseudoBlockArray(pad(B.data.data.blocks,:,(l+u+1)*sum(cols)), (axes(B.data.data,1), blockedrange(cols)))
         B.data = _BandedBlockBandedMatrix(blocks, rows, cols, (l, u), (λ, μ))
 
         jr=B.datasize[2]+1:col

src/Domain.jl

@@ -18,6 +18,9 @@ prectype(d::Domain) = prectype(typeof(d))
 struct AnyDomain <: Domain{UnsetNumber} end
 struct EmptyDomain <: Domain{Nothing} end
 
+==(::AnyDomain, ::AnyDomain) = true
+==(::EmptyDomain, ::EmptyDomain) = true
+
 isambiguous(::AnyDomain) = true
 dimension(::AnyDomain) = 1
 dimension(::EmptyDomain) = 0
@@ -82,13 +85,6 @@ function indomain(x,d::SegmentDomain)
         -100eps(T)/sc ≤ iy ≤ 100eps(T)/sc
 end
 
-ncomponents(s::Domain) = 1
-components(s::Domain) = [s]
-function components(s::Domain,k)
-    k ≠ 1 && throw(BoundsError())
-    s
-end
-
 issubcomponent(a::Domain,b::Domain) = a in components(b)
 
 
@@ -109,8 +105,6 @@ maps the point `x` in `d` to a point in `canonical(d,x)`
 """
 function tocanonical end
 
-issubset(a::Domain,b::Domain) = a==b
-
 
 ## conveninece routines
 
@@ -185,3 +179,6 @@ struct Integers <: Domain{Int} end
 
 const ℕ = PositiveIntegers()
 const ℤ = Integers()
+
+==(::PositiveIntegers, ::PositiveIntegers) = true
+==(::Integers, ::Integers) = true

src/Domains/ProductDomain.jl

@@ -1,18 +1,20 @@
 
-canonicaldomain(d::ProductDomain) = ProductDomain(map(canonicaldomain,d.domains)...)
+nfactors(d::ProductDomain) = length(components(d))
+factors(d::ProductDomain) = components(d)
+factor(d::ProductDomain,k::Integer) = component(d,k)
+
+canonicaldomain(d::ProductDomain) = ProductDomain(map(canonicaldomain,factors(d))...)
 
 
 # product domains are their own canonical domain
 for OP in (:fromcanonical,:tocanonical)
     @eval begin
-        $OP(d::ProductDomain, x::Vec) = Vec(map($OP,d.domains,x)...)
-        $OP(d::ProductDomain, x::Vec{2}) = Vec($OP(first(d.domains), first(x)), $OP(last(d.domains), last(x)))
+        $OP(d::ProductDomain, x::Vec) = Vec(map($OP,factors(d),x)...)
+        $OP(d::ProductDomain, x::Vec{2}) = Vec($OP(first(factors(d)), first(x)), $OP(last(factors(d)), last(x)))
     end
 end
 
-nfactors(d::ProductDomain) = length(d.domains)
-factors(d::ProductDomain) = d.domains
-factor(d::ProductDomain,k::Integer) = d.domains[k]
+
 
 function pushappendpts!(ret, xx, pts)
     if isempty(pts)
@@ -26,23 +28,23 @@ function pushappendpts!(ret, xx, pts)
 end
 
 function checkpoints(d::ProductDomain)
-    pts = checkpoints.(d.domains)
-    ret=Vector{Vec{sum(dimension.(d.domains)),float(promote_type(eltype.(eltype.(d.domains))...))}}(undef, 0)
+    pts = checkpoints.(factors(d))
+    ret=Vector{Vec{sum(dimension.(factors(d))),float(promote_type(eltype.(eltype.(factors(d)))...))}}(undef, 0)
 
     pushappendpts!(ret,(),pts)
     ret
 end
 
 function points(d::ProductDomain,n::Tuple)
-    @assert length(d.domains) == length(n)
-    pts=map(points,d.domains,n)
-    ret=Vector{Vec{length(d.domains),mapreduce(eltype,promote_type,d.domains)}}(undef, 0)
+    @assert length(factors(d)) == length(n)
+    pts=map(points,factors(d),n)
+    ret=Vector{Vec{length(factors(d)),mapreduce(eltype,promote_type,factors(d))}}(undef, 0)
     pushappendpts!(ret,Vec(x),pts)
     ret
 end
 
-reverseorientation(d::ProductDomain) = ProductDomain(map(reverseorientation, d.domains))
+reverseorientation(d::ProductDomain) = ProductDomain(map(reverseorientation, factors(d)))
 
 domainscompatible(a::ProductDomain,b::ProductDomain) =
-                        length(a.domains)==length(b.domains) &&
-                        all(map(domainscompatible,a.domains,b.domains))
+                        length(factors(a))==length(factors(b)) &&
+                        all(map(domainscompatible,factors(a),factors(b)))

src/Domains/UnionDomain.jl

@@ -10,13 +10,10 @@ convert(::Type{IT},::AnyDomain) where {IT<:UnionDomain} = UnionDomain(tuple())
 
 #support tuple set
 components(d::AbstractVector) = d
-components(d::UnionDomain) = elements(d)
-component(d::UnionDomain,k) = components(d)[k]
-ncomponents(d::UnionDomain) = length(elements(d))
 
-pieces(d::UnionDomain) = elements(d)
+pieces(d::UnionDomain) = components(d)
 piece(d::UnionDomain,k) = pieces(d)[k]
-npieces(d::UnionDomain) = length(elements(d))
+npieces(d::UnionDomain) = length(components(d))
 
 
 union(::AnyDomain, d::UnionDomain) = d
@@ -27,8 +24,8 @@ arclength(d::UnionDomain) = mapreduce(arclength,+,d.domains)
 
 reverseorientation(d::UnionDomain) = UnionDomain(reverse(map(reverseorientation,d.domains)))
 
-leftendpoint(d::UnionDomain) = leftendpoint(first(elements(d)))
-rightendpoint(d::UnionDomain) = rightendpoint(last(elements(d)))
+leftendpoint(d::UnionDomain) = leftendpoint(first(components(d)))
+rightendpoint(d::UnionDomain) = rightendpoint(last(components(d)))
 
 # determine the number of points per piece
 function components_npoints(d, n::Int)

src/Domains/multivariate.jl

@@ -3,7 +3,7 @@ include("ProductDomain.jl")
 
 ## boundary
 
-const RectDomain{T,A<:IntervalOrSegment,B<:IntervalOrSegment} = VcatDomain{2,T,(1,1),Tuple{A,B}}
+const RectDomain = Union{DomainSets.FixedIntervalProduct{2}, DomainSets.Rectangle, VcatDomain{2,<:Any,(1,1),<:Tuple}}
 
 boundary(d::RectDomain) =
     PiecewiseSegment([Vec(leftendpoint(factor(d,1)),leftendpoint(factor(d,2))),

src/Multivariate/LowRankFun.jl

@@ -195,7 +195,7 @@ LowRankFun(f::Function,S::TensorSpace{SV,DD,RR};kwds...) where {SV,DD<:Euclidean
 LowRankFun(f::Function,dx::Domain,dy::Domain;kwds...) =
     LowRankFun(dynamic(f),Space(dx),Space(dy);kwds...)
 LowRankFun(f::Function,d::ProductDomain;kwds...) =
-    LowRankFun(dynamic(f),d.domains...;kwds...)
+    LowRankFun(dynamic(f),factors(d)...;kwds...)
 
 LowRankFun(f::Function;kwds...) = LowRankFun(dynamic(f),ChebyshevInterval(),ChebyshevInterval();kwds...)
 

src/Multivariate/TensorSpace.jl

@@ -238,9 +238,9 @@ end
 canonicalspace(T::TensorSpace) = TensorSpace(map(canonicalspace,T.spaces))
 
 
-
+TensorSpace(A::SVector{N,<:Space}) where N = TensorSpace(tuple(A...))
 TensorSpace(A...) = TensorSpace(tuple(A...))
-TensorSpace(A::ProductDomain) = TensorSpace(tuple(map(Space,A.domains)...))
+TensorSpace(A::ProductDomain) = TensorSpace(tuple(map(Space,components(A))...))
 ⊗(A::TensorSpace,B::TensorSpace) = TensorSpace(A.spaces...,B.spaces...)
 ⊗(A::TensorSpace,B::Space) = TensorSpace(A.spaces...,B)
 ⊗(A::Space,B::TensorSpace) = TensorSpace(A,B.spaces...)

src/specialfunctions.jl

@@ -54,6 +54,9 @@ end
 midpoints(d::IntervalOrSegment) = [mean(d)]
 midpoints(d::Union{UnionDomain,PiecewiseSegment}) = mapreduce(midpoints,vcat,components(d))
 
+_UnionDomainIfMultiple(d::IntervalOrSegment) = d
+_UnionDomainIfMultiple(d) = UnionDomain(components(d))
+
 for OP in (:sign,:angle)
     @eval function $OP(f::Fun{S,T}) where {S<:RealUnivariateSpace,T<:Real}
         d=domain(f)
@@ -65,7 +68,7 @@ for OP in (:sign,:angle)
         else
             d = split(d , pts)
             midpts = midpoints(d)
-            Fun(UnionDomain(components(d)), $OP.(f.(midpts)))
+            Fun(_UnionDomainIfMultiple(d), $OP.(f.(midpts)))
         end
     end
 end