Merge branch 'master' into patch-2

Author: putianyi889

.github/workflows/ci.yml

@@ -12,6 +12,7 @@ jobs:
         version:
           - '1.6'
           - '1'
+          - '^1.11.0-0'          
         os:
           - ubuntu-latest
           - macOS-latest

Project.toml

@@ -1,7 +1,7 @@
 name = "QuasiArrays"
 uuid = "c4ea9172-b204-11e9-377d-29865faadc5c"
 authors = ["Sheehan Olver <[email protected]>"]
-version = "0.11.4"
+version = "0.11.7"
 
 [deps]
 ArrayLayouts = "4c555306-a7a7-4459-81d9-ec55ddd5c99a"
@@ -22,10 +22,11 @@ QuasiArraysSparseArraysExt = "SparseArrays"
 
 [compat]
 ArrayLayouts = "1"
-DomainSets = "0.6, 0.7"
+EltypeExtensions = "0.0.4"
+DomainSets = "0.7.6"
 EltypeExtensions = "0.0.4"
 FillArrays = "1"
-LazyArrays = "1.2"
+LazyArrays = "1.2, 2"
 StaticArrays = "1"
 julia = "1.6"
 

src/calculus.jl

@@ -7,8 +7,7 @@ _sum(V::AbstractQuasiArray, dims) = sum_layout(MemoryLayout(V), V, dims)
 _sum(V::AbstractQuasiArray, ::Colon) = sum_layout(MemoryLayout(V), V, :)
 
 _cumsum(A, dims) = cumsum_layout(MemoryLayout(A), A, dims)
-cumsum(A::AbstractQuasiArray; dims::Integer) = _cumsum(A, dims)
-cumsum(x::AbstractQuasiVector) = cumsum(x, dims=1)
+cumsum(A::AbstractQuasiArray; dims::Integer=1) = _cumsum(A, dims)
 
 # sum is equivalent to hitting by ones(n) on the left or right
 

src/indices.jl

@@ -210,6 +210,8 @@ union(x::Inclusion...) = Inclusion{mapreduce(eltype,promote_type,x)}(_union(map(
 
 checkindex(::Type{Bool}, inds::Inclusion{T}, i::T) where T = i ∈ inds
 checkindex(::Type{Bool}, inds::Inclusion, i) = i ⊆ inds
+checkindex(::Type{Bool}, inds::Inclusion{T}, i::T) where T<:AbstractArray = i ∈ inds
+checkindex(::Type{Bool}, inds::Inclusion, i::AbstractArray) = i ⊆ inds
 checkindex(::Type{Bool}, inds::Inclusion, ::Colon) = true
 checkindex(::Type{Bool}, inds::Inclusion, ::Inclusion) = true
 

src/subquasiarray.jl

@@ -298,6 +298,11 @@ pointer(V::SubQuasiArray, i::Int) = _pointer(V, i)
 _pointer(V::SubQuasiArray{<:Any,1}, i::Int) = pointer(V, (i,))
 _pointer(V::SubQuasiArray, i::Int) = pointer(V, Base._ind2sub(axes(V), i))
 
+convert(::Type{AbstractQuasiArray{T}}, V::SubQuasiArray{T}) where T = V
+convert(::Type{AbstractQuasiArray{T,N}}, V::SubQuasiArray{T,N}) where {T,N} = V
+convert(::Type{AbstractQuasiArray{T}}, V::SubQuasiArray) where T = SubQuasiArray(convert(AbstractQuasiArray{T}, parent(V)), V.indices)
+convert(::Type{AbstractQuasiArray{T,N}}, V::SubQuasiArray{<:Any,N}) where {T,N} = convert(AbstractQuasiArray{T}, V)
+
 
 # indices are taken from the range/vector
 # Since bounds-checking is performance-critical and uses

test/test_calculus.jl

@@ -19,7 +19,7 @@ using QuasiArrays, IntervalSets, Test
         @test sum(ApplyQuasiArray(*, A, B); dims=2) ≈ sum(A*B; dims=2)
 
         @test sum(b) ≈ last(cumsum(b)) ≈ cumsum(b)[2]
-        @test cumsum(B; dims=1)[2:2,:] ≈ sum(B; dims=1)
+        @test cumsum(B)[2:2,:] ≈ cumsum(B; dims=1)[2:2,:] ≈ sum(B; dims=1)
         @test cumsum(B; dims=2)[:,0.5:0.5] ≈ sum(B; dims=2)
 
         @test cumsum(ApplyQuasiArray(*, A, b)) ≈ cumsum(A*b)

test/test_quasisubarray.jl

@@ -315,8 +315,19 @@ using QuasiArrays, Base64, Test
         @test view(A,:,:) == view(A,:,:)
         @test A ≠ view(A,Inclusion(0:0.5:0.5),:)
         @test view(A,Inclusion(0:0.5:0.5),:) ≠ A
-        @test A ≠ view(B,Inclusion(0:0.5:1),:)
-        @test view(B,Inclusion(0:0.5:1),:) ≠ A
-        @test view(B,Inclusion(0:0.5:1),:) ≠ view(A,Inclusion(0:0.5:0.5),:)
+        @test A ≠ view(B,Inclusion(0:0.5:1),:)
+        @test view(B,Inclusion(0:0.5:1),:) ≠ A
+        @test view(B,Inclusion(0:0.5:1),:) ≠ view(A,Inclusion(0:0.5:0.5),:)
+    end
+
+    @testset "SubQuasiArray convert" begin
+        a = QuasiVector(randn(3), 0:0.5:1)
+        v = view(a, :)
+        @test convert(AbstractQuasiVector{Float64}, v) ≡ v
+        @test convert(AbstractQuasiVector{ComplexF64}, v) isa SubQuasiArray{ComplexF64}
+        @test convert(AbstractQuasiVector{ComplexF64}, v) == v
+        @test convert(AbstractQuasiArray{Float64}, v) ≡ v
+        @test convert(AbstractQuasiArray{ComplexF64}, v) isa SubQuasiArray{ComplexF64}
+        @test convert(AbstractQuasiArray{ComplexF64}, v) == v
     end
 end