Dl/arraylayouts02 (#30)

* Support ArrayLayouts 0.2

* Update Project.toml

* Update Project.toml

* remove unused _getindex

* Fix SubQuasiArray indexing

* Update multidimensional.jl

* Update multidimensional.jl

* remove more unused, test for fill!

Author: dlfivefifty

Project.toml

@@ -1,16 +1,16 @@
 name = "QuasiArrays"
 uuid = "c4ea9172-b204-11e9-377d-29865faadc5c"
 authors = ["Sheehan Olver <[email protected]>"]
-version = "0.2"
+version = "0.2.0"
 
 [deps]
 ArrayLayouts = "4c555306-a7a7-4459-81d9-ec55ddd5c99a"
 LazyArrays = "5078a376-72f3-5289-bfd5-ec5146d43c02"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 
 [compat]
-ArrayLayouts = "0.1.5"
-LazyArrays = "0.15"
+ArrayLayouts = "0.2.4"
+LazyArrays = "0.16.3"
 julia = "1.3"
 
 [extras]

src/QuasiArrays.jl

@@ -40,7 +40,7 @@ import LazyArrays: MemoryLayout, UnknownLayout, Mul, ApplyLayout, BroadcastLayou
                     rowsupport, colsupport, tuple_type_memorylayouts, applylayout, broadcastlayout,
                     LdivApplyStyle, most, InvLayout, PInvLayout, sub_materialize,
                     _mul, rowsupport, DiagonalLayout, adjointlayout, transposelayout, conjlayout,
-                    sublayout, call, combine_mul_styles, result_mul_style, LazyArrayStyle, lazy_getindex
+                    sublayout, call, combine_mul_styles, result_mul_style, LazyArrayStyle, layout_getindex
 
 import Base.IteratorsMD
 

src/abstractquasiarray.jl

@@ -385,7 +385,8 @@ function unsafe_getindex(A::AbstractQuasiArray, I...)
 end
 
 ## Internal definitions
-_getindex(_, ::IndexStyle, A::AbstractQuasiArray, I) = lazy_getindex(A, I...)
+_getindex(_, ::IndexStyle, A::AbstractQuasiArray, I) = 
+    layout_getindex(A, I...)
 
 
 ## IndexCartesian Scalar indexing: Canonical method is full dimensionality of indices
@@ -426,16 +427,12 @@ _to_subscript_indices(A::AbstractQuasiArray{T,N}, I::Vararg{Any,N}) where {T,N}
 ## Setindex! is defined similarly. We first dispatch to an internal _setindex!
 # function that allows dispatch on array storage
 
+setindex!(A::AbstractQuasiArray, v, I...) = _setindex!(indextype(A), A, v, I)
 
-function setindex!(A::AbstractQuasiArray, v, I...)
+function _setindex!(::Type{IND}, A::AbstractQuasiArray, v, I) where IND
     @_propagate_inbounds_meta
     error_if_canonical_setindex(IndexStyle(A), A, I)
-    _setindex!(indextype(A), IndexStyle(A), A, v, to_indices(A, I))
-end
-function unsafe_setindex!(A::AbstractQuasiArray, v, I...)
-    @_inline_meta
-    @inbounds r = setindex!(A, v, I...)
-    r
+    _setindex!(IND, IndexStyle(A), A, v, to_indices(A, I))
 end
 
 error_if_canonical_setindex(::IndexCartesian, A::AbstractQuasiArray{T,N}, I::Tuple) where {T,N} =

src/multidimensional.jl

@@ -423,17 +423,7 @@ to_indices(A::AbstractQuasiArray, I::Tuple{Any}) = (@_inline_meta; to_indices(A,
     (to_index(A, I[1]), to_indices(A, indstail, tail(I))...)
 end
 
-# Colons get converted to slices by `uncolon`
-const CI0 = Union{QuasiCartesianIndex{0}, AbstractArray{QuasiCartesianIndex{0}}}
-
-### From abstractarray.jl: Internal multidimensional indexing definitions ###
-getindex(x::Number, i::QuasiCartesianIndex{0}) = x
-getindex(t::Tuple,  i::QuasiCartesianIndex{1}) = getindex(t, i.I[1])
-
-@inline function _getindex(l::IndexStyle, A::AbstractQuasiArray, I::Union{Any, AbstractArray}...)
-    @boundscheck checkbounds(A, I...)
-    return _unsafe_getindex(l, _maybe_reshape(l, A, I...), I...)
-end
+### From abstractarray.jl: Internal multidimensional indexing definitions ###   
 
 @inline index_dimsum(::AbstractQuasiArray{Bool}, I...) = (true, index_dimsum(I...)...)
 @inline function index_dimsum(::AbstractQuasiArray{<:Any,N}, I...) where N
@@ -442,35 +432,6 @@ end
 
 Slice(d::AbstractQuasiVector) = Inclusion(d)
 
-
-_maybe_reshape(::IndexLinear, A::AbstractQuasiArray, I...) = A
-_maybe_reshape(::IndexCartesian, A::AbstractQuasiVector, I...) = A
-@inline _maybe_reshape(::IndexCartesian, A::AbstractQuasiArray, I...) = __maybe_reshape(A, index_ndims(I...))
-@inline __maybe_reshape(A::AbstractQuasiArray{T,N}, ::NTuple{N,Any}) where {T,N} = A
-@inline __maybe_reshape(A::AbstractQuasiArray, ::NTuple{N,Any}) where {N} = reshape(A, Val(N))
-
-_unsafe_getindex(::IndexStyle, A::AbstractQuasiArray, I::Vararg{Union{Any, AbstractArray}, N}) where N =
-    lazy_getindex(A, I...)
-    
-# Always index with the exactly indices provided.
-@generated function _unsafe_getindex!(dest::Union{AbstractArray,AbstractQuasiArray}, src::AbstractQuasiArray, I::Vararg{Union{Any, AbstractArray}, N}) where N
-    quote
-        @_inline_meta
-        D = eachindex(dest)
-        Dy = iterate(D)
-        @inbounds @nloops $N j d->I[d] begin
-            # This condition is never hit, but at the moment
-            # the optimizer is not clever enough to split the union without it
-            Dy === nothing && return dest
-            (idx, state) = Dy
-            dest[idx] = @ncall $N getindex src j
-            Dy = iterate(D, state)
-        end
-        return dest
-    end
-end
-
-
 function fill!(A::AbstractQuasiArray{T}, x) where T
     xT = convert(T, x)
     for I in eachindex(A)

src/quasiarray.jl

@@ -49,12 +49,12 @@ _inclusion(d) = Inclusion(d)
 axes(A::QuasiArray) = _inclusion.(A.axes)
 parent(A::QuasiArray) = A.parent
 
-@propagate_inbounds @inline function _getindex(::Type{IND}, A::QuasiArray{<:Any,N}, I::IND) where {N,IND}
+@propagate_inbounds @inline function _getindex(::Type{IND}, A::QuasiArray, I::IND) where IND
     @boundscheck checkbounds(A, I...)
     A.parent[findfirst.(isequal.(I), A.axes)...]
 end
 
-@propagate_inbounds @inline function setindex!(A::QuasiArray{<:Any,N}, v, I::Vararg{Number,N}) where N
+@propagate_inbounds @inline function _setindex!(::Type{IND}, A::QuasiArray, v, I::IND) where IND
     @boundscheck checkbounds(A, I...)
     @inbounds A.parent[findfirst.(isequal.(I), A.axes)...] = v
     A

src/subquasiarray.jl

@@ -220,50 +220,20 @@ end
 
 # In general, we simply re-index the parent indices by the provided ones
 SlowSubQuasiArray{T,N,P,I} = SubQuasiArray{T,N,P,I,false}
-function getindex(V::SlowSubQuasiArray{T,N}, I::Vararg{Number,N}) where {T,N}
+function _getindex(::Type{IND}, V::SlowSubQuasiArray, I::IND) where IND
     @_inline_meta
     @boundscheck checkbounds(V, I...)
     @inbounds r = V.parent[reindex(V.indices, I)...]
     r
 end
 
-FastSubQuasiArray{T,N,P,I} = SubQuasiArray{T,N,P,I,true}
-function getindex(V::FastSubQuasiArray, i::Number)
-    @_inline_meta
-    @boundscheck checkbounds(V, i)
-    @inbounds r = V.parent[V.offset1 + V.stride1*i]
-    r
-end
-# We can avoid a multiplication if the first parent index is a Colon or AbstractUnitRange
-FastContiguousSubQuasiArray{T,N,P,I<:Tuple{Union{Slice, AbstractUnitRange}, Vararg{Any}}} = SubQuasiArray{T,N,P,I,true}
-function getindex(V::FastContiguousSubQuasiArray, i::Number)
-    @_inline_meta
-    @boundscheck checkbounds(V, i)
-    @inbounds r = V.parent[V.offset1 + i]
-    r
-end
-
-function setindex!(V::SlowSubQuasiArray{T,N}, x, I::Vararg{Number,N}) where {T,N}
+function _setindex!(::Type{IND}, V::SlowSubQuasiArray, x, I::IND) where IND
     @_inline_meta
     @boundscheck checkbounds(V, I...)
     @inbounds V.parent[reindex(V.indices, I)...] = x
     V
 end
 
-function setindex!(V::FastSubQuasiArray, x, i::Number)
-    @_inline_meta
-    @boundscheck checkbounds(V, i)
-    @inbounds V.parent[V.offset1 + V.stride1*i] = x
-    V
-end
-function setindex!(V::FastContiguousSubQuasiArray, x, i::Number)
-    @_inline_meta
-    @boundscheck checkbounds(V, i)
-    @inbounds V.parent[V.offset1 + i] = x
-    V
-end
-
-IndexStyle(::Type{<:FastSubQuasiArray}) = IndexLinear()
 IndexStyle(::Type{<:SubQuasiArray}) = IndexCartesian()
 
 # Strides are the distance in memory between adjacent elements in a given dimension
@@ -278,11 +248,6 @@ compute_stride1(parent::AbstractQuasiArray, I::NTuple{N,Any}) where {N} =
 
 elsize(::Type{<:SubQuasiArray{<:Any,<:Any,P}}) where {P} = elsize(P)
 
-iscontiguous(A::SubQuasiArray) = iscontiguous(typeof(A))
-iscontiguous(::Type{<:SubQuasiArray}) = false
-iscontiguous(::Type{<:FastContiguousSubQuasiArray}) = true
-
-first_index(V::FastSubQuasiArray) = V.offset1 + V.stride1 # cached for fast linear SubQuasiArrays
 function first_index(V::SubQuasiArray)
     P, I = parent(V), V.indices
     s1 = compute_stride1(P, I)
@@ -325,8 +290,6 @@ find_extended_inds() = ()
 unsafe_convert(::Type{Ptr{T}}, V::SubQuasiArray{T,N,P,<:Tuple{Vararg{RangeIndex}}}) where {T,N,P} =
     unsafe_convert(Ptr{T}, V.parent) + (first_index(V)-1)*sizeof(T)
 
-pointer(V::FastSubQuasiArray, i::Int) = pointer(V.parent, V.offset1 + V.stride1*i)
-pointer(V::FastContiguousSubQuasiArray, i::Int) = pointer(V.parent, V.offset1 + i)
 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))

test/test_abstractquasiarray.jl

@@ -102,6 +102,9 @@ import QuasiArrays: QuasiCartesianIndex
         v = QuasiArray([1, 2, 3],(0:0.5:1,))
         @test axes(v) == axes(v[:]) == axes(v[Inclusion(0:0.5:1)]) == (Inclusion(0:0.5:1),)
         @test v[0.5] == v[:][0.5] == v[Inclusion(0:0.5:1)][0.5] == 2
+
+        A = QuasiArray(rand(3,2), (0:0.5:1,[1,3]))
+        @test A[1,[1,3]] == A[:,[1,3]][1,:]
     end
 
     @testset "Vec indexing" begin

test/test_arrayops.jl

@@ -88,4 +88,9 @@ using QuasiArrays, Test
         @test X[Y[end],0.0] == 5
         @test X[end,Y[end]] == 11
     end
+
+    @testset "fill" begin
+        a = QuasiArray(fill(1.,2,2),(0:0.5:0.5,1:0.5:1.5))
+        @test fill!(similar(a), 1.0) == a
+    end
 end

test/test_quasisubarray.jl

@@ -33,6 +33,22 @@ using QuasiArrays, Test
         @test axes(sA) === (Base.OneTo(2), Base.OneTo(2), Base.OneTo(2))
     end
 
+    @testset "FastSubQuasiArray" begin
+        a = QuasiArray(randn(5), (1:0.5:3,))
+        v = view(a, Inclusion(1.5:0.5:2))
+        @test axes(v) == (Inclusion(1.5:0.5:2),)
+        @test v[1.5] == a[1.5]
+        @test_throws BoundsError v[1]
+        v[1.5] = 3
+        @test a[1.5] === 3.0
+
+        a = QuasiArray(randn(2), ([[1,2],[3,4]],))
+        v = view(a, Inclusion([[1,2],[3,4]]))
+        @test v[[1,2]] == a[[1,2]]
+        v[[1,2]] = 3
+        @test a[[1,2]] == 3.0
+    end
+
     # @testset "logical indexing #4763" begin
     #     A = view(QuasiVector(1:5,range(0,2;length=5)), 0.5:0.5:1.5)
     #     A[Inclusion(0.5:0.5:1.0)]