Use union with ChebyshevInterval (#79)

* use union for ChebyshevInterval

* v0.8.2

* add tests

* fix tests, add converteltype

* Fix array-valued isapprox

* fix broadcasting with vectors

* Update Project.toml

Author: dlfivefifty

Project.toml

@@ -1,7 +1,7 @@
 name = "QuasiArrays"
 uuid = "c4ea9172-b204-11e9-377d-29865faadc5c"
 authors = ["Sheehan Olver <[email protected]>"]
-version = "0.8.1"
+version = "0.8.2"
 
 [deps]
 ArrayLayouts = "4c555306-a7a7-4459-81d9-ec55ddd5c99a"
@@ -12,10 +12,10 @@ LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 
 [compat]
-ArrayLayouts = "0.7"
+ArrayLayouts = "0.7.6"
 DomainSets = "0.5"
-FillArrays = "0.11, 0.12"
-LazyArrays = "0.21.5, 0.22"
+FillArrays = "0.12"
+LazyArrays = "0.22.2"
 StaticArrays = "1"
 julia = "1.6"
 

src/QuasiArrays.jl

@@ -27,7 +27,7 @@ import Base: Array, Matrix, Vector
 import Base: union, intersect, sort, sort!
 import Base: conj, real, imag
 # reducedim.jl imports
-import Base: prod, sum, cumsum, diff, add_sum, mul_prod, mapreduce, max, min, count, _count, any, _any, all, _all, _sum, _prod, _mapreduce, reduced_index, check_reducedims
+import Base: prod, sum, cumsum, diff, add_sum, mul_prod, mapreduce, max, min, count, _count, any, _any, all, _all, _sum, _prod, _mapreduce, reduced_index, check_reducedims, mapfoldl_impl
 import Base: BitInteger, IEEEFloat, uniontypes, _InitialValue, safe_tail, reducedim1, _simple_count
 
 import Base: ones, zeros, one, zero, fill
@@ -107,7 +107,7 @@ include("dense.jl")
 include("quasikron.jl")
 
 promote_leaf_eltypes(x::AbstractQuasiArray{T}) where {T<:Number} = T
-promote_leaf_eltypes(x::AbstractQuasiArray) = mapreduce(promote_leaf_eltypes, promote_type, x; init=Bool)
+promote_leaf_eltypes(x::AbstractQuasiArray) = eltype(eltype(x)) #mapreduce(promote_leaf_eltypes, promote_type, x; init=Bool)
 
 
 function isapprox(x::AbstractQuasiArray, y::AbstractQuasiArray;

src/indices.jl

@@ -193,7 +193,9 @@ Base.issubset(S::Inclusion, d::Inclusion) = S.domain ⊆ d.domain
 
 intersect(x::Inclusion...) = Inclusion{mapreduce(eltype,promote_type,x)}(intersect(map(domain,x)...))
 # use UnionDomain to support intervals
-union(x::Inclusion...) = Inclusion{mapreduce(eltype,promote_type,x)}(UnionDomain(map(domain,x)...))
+_union(a::ClosedInterval...) = UnionDomain(a...)
+_union(a...) = union(a...)
+union(x::Inclusion...) = Inclusion{mapreduce(eltype,promote_type,x)}(_union(map(domain,x)...))
 
 checkindex(::Type{Bool}, inds::Inclusion{T}, i::T) where T = i ∈ inds
 checkindex(::Type{Bool}, inds::Inclusion, i) = i ⊆ inds

src/inv.jl

@@ -53,5 +53,5 @@ pinv(A::PInvQuasiMatrix) = first(A.args)
 ## QuasiArray special case
 inv(A::QuasiMatrix) = QuasiArray(inv(A.parent), reverse(A.axes))
 
-_factorize(_, A) = error("Overload for $(typeof(A))")
-factorize(A::AbstractQuasiArray) = _factorize(MemoryLayout(A), A)
+_factorize(lay, A, dims...; kws...) = error("Overload for $(typeof(A))")
+factorize(A::AbstractQuasiArray, dims...; kws...) = _factorize(MemoryLayout(A), A, dims...; kws...)

src/multidimensional.jl

@@ -414,8 +414,8 @@ end
 to_indices(A::AbstractQuasiArray, I::Tuple{Any}) = (@_inline_meta; to_indices(A, axes(A), I))
 # But some index types require more context spanning multiple indices
 # QuasiCartesianIndexes are simple; they just splat out
-@inline to_indices(A::AbstractQuasiArray, inds, I::Tuple{QuasiCartesianIndex, Vararg{Any}}) =
-    to_indices(A, inds, (I[1].I..., tail(I)...))
+@inline to_indices(A, inds, I::Tuple{QuasiCartesianIndex, Vararg{Any}}) = to_indices(A, inds, (I[1].I..., tail(I)...))
+@inline to_indices(A::AbstractQuasiArray, inds, I::Tuple{QuasiCartesianIndex, Vararg{Any}}) = to_indices(A, inds, (I[1].I..., tail(I)...))
 @inline to_indices(A::AbstractQuasiArray, I::Tuple{Vararg{Union{Integer, CartesianIndex}}}) = to_indices(A, axes(A), I)
 @inline to_indices(A::AbstractQuasiArray, I::Tuple{Vararg{Integer}}) = to_indices(A, axes(A), I)
 @inline to_indices(A::AbstractQuasiArray, I::Tuple{Vararg{Int}}) = to_indices(A, axes(A), I)
@@ -424,6 +424,10 @@ to_indices(A::AbstractQuasiArray, I::Tuple{Any}) = (@_inline_meta; to_indices(A,
     _, indstail = IteratorsMD.split(inds, Val(N))
     (to_index(A, I[1]), to_indices(A, indstail, tail(I))...)
 end
+@inline function to_indices(A, inds, I::Tuple{AbstractArray{QuasiCartesianIndex{N}}, Vararg{Any}}) where N
+    _, indstail = IteratorsMD.split(inds, Val(N))
+    (to_index(A, I[1]), to_indices(A, indstail, tail(I))...)
+end
 Base.to_indices(A::AbstractQuasiArray, I::Tuple{Vararg{Union{Integer, CartesianIndex, StaticArray{<:Tuple,Int}}}}) =
     to_indices(A, axes(A), I)
 

src/quasibroadcast.jl

@@ -81,6 +81,8 @@ BroadcastStyle(a::AbstractQuasiArrayStyle{N}, ::DefaultArrayStyle{0}) where N =
 BroadcastStyle(a::AbstractQuasiArrayStyle{N}, ::DefaultQuasiArrayStyle{N}) where N = a
 BroadcastStyle(a::AbstractQuasiArrayStyle{M}, ::DefaultQuasiArrayStyle{N}) where {M,N} =
     typeof(a)(Val(max(M, N)))
+BroadcastStyle(a::AbstractQuasiArrayStyle{M}, ::AbstractArrayStyle{N}) where {M,N} =
+    typeof(a)(Val(max(M, N)))
 
 Base.similar(bc::Broadcasted{DefaultQuasiArrayStyle{N}}, ::Type{ElType}) where {N,ElType} =
     similar(QuasiArray{ElType}, axes(bc))
@@ -191,3 +193,6 @@ _broadcasted_mul(A::Tuple{AbstractQuasiMatrix,Vararg{Any}}, B::AbstractQuasiMatr
 _broadcasted_mul(A::AbstractQuasiMatrix, b::Tuple{Number,Vararg{Any}}) = (sum(A; dims=2)*first(b)[1], _broadcasted_mul(A, tail(b))...)
 _broadcasted_mul(A::AbstractQuasiMatrix, b::Tuple{AbstractQuasiVector,Vararg{Any}}) = (size(first(b),1) == 1 ? (sum(A; dims=2)*first(b)[1]) : (A*first(b)), _broadcasted_mul(A, tail(b))...)
 _broadcasted_mul(A::AbstractQuasiMatrix, B::Tuple{AbstractQuasiMatrix,Vararg{Any}}) = (size(first(B),1) == 1 ? (sum(A; dims=2) * first(B)) : (A * first(B)), _broadcasted_mul(A, tail(B))...)
+
+
+LazyArrays.converteltype(::Type{T}, A::AbstractQuasiArray) where T = convert(AbstractQuasiArray{T}, A)

src/quasiconcat.jl

@@ -23,7 +23,7 @@ function getindex(f::ApplyQuasiMatrix{T,typeof(hcat)}, k::Number, j::Number) whe
     throw(BoundsError(f, (k,j)))
 end
 
-\(A::AbstractQuasiArray, H::ApplyQuasiMatrix{<:Any,typeof(hcat)}) = hcat((Ref(A) .\ H.args)...)
+# \(A::AbstractQuasiArray, H::ApplyQuasiMatrix{<:Any,typeof(hcat)}) = hcat((Ref(A) .\ H.args)...)
 
 function ==(A::ApplyQuasiMatrix{<:Any,typeof(hcat)}, B::ApplyQuasiMatrix{<:Any,typeof(hcat)})
     axes.(A.args,2) == axes.(B.args,2) && return all(A.args .== B.args)

test/test_continuous.jl

@@ -1,4 +1,4 @@
-using QuasiArrays, IntervalSets, Test
+using QuasiArrays, IntervalSets, DomainSets, Test
 import QuasiArrays: ApplyQuasiArray
 
 @testset "Continuous" begin
@@ -32,6 +32,12 @@ import QuasiArrays: ApplyQuasiArray
         @test findfirst(isequal(2.3), Inclusion(0.0..1)) ≡ findlast(isequal(2.3), Inclusion(0..1)) ≡ nothing
         @test findall(isequal(0.1), Inclusion(0.0..1)) == [0.1]
         @test findall(isequal(2.3), Inclusion(0.0..1)) == Float64[]
+
+        @test 2.3 in union(x, Inclusion(2..3))
+        y = Inclusion(ChebyshevInterval())
+        @test union(y,y) ≡ y
+        z = Inclusion(UnitInterval())
+        @test union(z,z) ≡ z
     end
 
     @testset "QuasiDiagonal" begin

test/test_quasibroadcast.jl

@@ -172,6 +172,15 @@ import QuasiArrays: QuasiCartesianIndex, QuasiCartesianIndices, DefaultQuasiArra
             @test stringmime("text/plain", x ./ x) == "Inclusion(0.0:0.5:1.0) ./ Inclusion(0.0:0.5:1.0)"
             @test stringmime("text/plain", x .\ x) == "Inclusion(0.0:0.5:1.0) .\\ Inclusion(0.0:0.5:1.0)"
         end
+
+        @testset "x .* (1:10)'" begin
+            x = Inclusion([0.1,0.2])
+            B = x .* (1:10)'
+            @test B[0.1,2] == 0.2
+            @test B[0.1,1:3] == 0.1*(1:3)
+            @test B[[0.1,0.2],2] == 2*[0.1,0.2]
+            @test B[[0.1,0.2],2:3] == [0.1,0.2] * (2:3)'
+        end
     end
 
     @testset "SubQuasi Broadcast" begin

test/test_quasiconcat.jl

@@ -35,7 +35,7 @@ import QuasiArrays: ApplyQuasiMatrix, UnionVcat
             a = QuasiVector(randn(5), 0:0.5:2)
             b = QuasiVector([5,6,8], [1,3,4])
             c = UnionVcat(a,b)
-            @test axes(c,1) == Inclusion(UnionDomain(0:0.5:2, [1,3,4]))
+            @test axes(c,1) == Inclusion(union(0:0.5:2, [1,3,4]))
             @test c[0.5] ≡ a[0.5]
             @test c[3] ≡ c[3.0] ≡ 6.0
             @test_throws BoundsError c[2.5]