From 1ae05df2a83e50935147861b2acfda6bd0975898 Mon Sep 17 00:00:00 2001 From: Tim Holy Date: Sun, 17 Jan 2021 11:11:32 -0500 Subject: [PATCH 01/14] Make no_offset_array inferrable This changes the implementation so that the axis *value*s do not affect the type of the output. Technically this is a breaking change, but only at the level of the returned types, not at the level of returned values. --- src/OffsetArrays.jl | 9 +-------- test/runtests.jl | 3 ++- 2 files changed, 3 insertions(+), 9 deletions(-) diff --git a/src/OffsetArrays.jl b/src/OffsetArrays.jl index b57b27ec..24a6d3d6 100644 --- a/src/OffsetArrays.jl +++ b/src/OffsetArrays.jl @@ -423,14 +423,7 @@ julia> A 2 4 6 ``` """ -function no_offset_view(A::AbstractArray) - if Base.has_offset_axes(A) - OffsetArray(A, Origin(1)) - else - A - end -end - +no_offset_view(A::AbstractArray) = OffsetArray(A, Origin(1)) no_offset_view(A::OffsetArray) = no_offset_view(parent(A)) no_offset_view(a::Array) = a diff --git a/test/runtests.jl b/test/runtests.jl index ff816ff2..13a02a97 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -1338,6 +1338,7 @@ end Base.parent(x::PointlessWrapper) = x.parent Base.size(x::PointlessWrapper) = size(parent(x)) Base.axes(x::PointlessWrapper) = axes(parent(x)) +Base.getindex(x::PointlessWrapper, i...) = x.parent[i...] @testset "no offset view" begin # OffsetArray fallback @@ -1350,7 +1351,7 @@ Base.axes(x::PointlessWrapper) = axes(parent(x)) @inferred no_offset_view(O2) P = PointlessWrapper(A) - @test no_offset_view(P) ≡ P + @test @inferred(no_offset_view(P)) == P # generic fallback A = collect(reshape(1:12, 3, 4)) From ab1d1a2cc4d0e9115ddf8cd519eca162ac85395e Mon Sep 17 00:00:00 2001 From: Tim Holy Date: Thu, 21 Jan 2021 16:57:10 -0600 Subject: [PATCH 02/14] don't add wrapper for OneTo axes arrays --- src/OffsetArrays.jl | 5 ++++- test/runtests.jl | 5 ++++- 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/src/OffsetArrays.jl b/src/OffsetArrays.jl index 24a6d3d6..f40ed926 100644 --- a/src/OffsetArrays.jl +++ b/src/OffsetArrays.jl @@ -423,9 +423,12 @@ julia> A 2 4 6 ``` """ -no_offset_view(A::AbstractArray) = OffsetArray(A, Origin(1)) no_offset_view(A::OffsetArray) = no_offset_view(parent(A)) no_offset_view(a::Array) = a +no_offset_view(A::AbstractArray) = _no_offset_view(axes(A), A) +_no_offset_view(::Tuple{}, A::AbstractArray{T,0}) where T = A +_no_offset_view(::Tuple{<:Base.OneTo,Vararg{<:Base.OneTo}}, A::AbstractArray) = A +_no_offset_view(::Any, A::AbstractArray) = OffsetArray(A, Origin(1)) #### # work around for segfault in searchsorted* diff --git a/test/runtests.jl b/test/runtests.jl index 13a02a97..4dbb02f8 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -1351,7 +1351,10 @@ Base.getindex(x::PointlessWrapper, i...) = x.parent[i...] @inferred no_offset_view(O2) P = PointlessWrapper(A) - @test @inferred(no_offset_view(P)) == P + @test @inferred(no_offset_view(P)) === P + @test @inferred(no_offset_view(A)) === A + a0 = reshape([1]) + @test @inferred(no_offset_view(a0)) === a0 # generic fallback A = collect(reshape(1:12, 3, 4)) From 4bcf979c4de1c5a5c615234cbd9a76399862e603 Mon Sep 17 00:00:00 2001 From: Tim Holy Date: Thu, 21 Jan 2021 17:08:21 -0600 Subject: [PATCH 03/14] Improve test coverage --- test/runtests.jl | 2 ++ 1 file changed, 2 insertions(+) diff --git a/test/runtests.jl b/test/runtests.jl index 4dbb02f8..1825271d 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -1355,6 +1355,8 @@ Base.getindex(x::PointlessWrapper, i...) = x.parent[i...] @test @inferred(no_offset_view(A)) === A a0 = reshape([1]) @test @inferred(no_offset_view(a0)) === a0 + a0v = view(a0) + @test @inferred(no_offset_view(a0v)) === a0v # generic fallback A = collect(reshape(1:12, 3, 4)) From 87f15e91ac62314c5f7abe2256754b64ac68b1e1 Mon Sep 17 00:00:00 2001 From: Tim Holy Date: Sun, 7 Feb 2021 07:33:19 -0600 Subject: [PATCH 04/14] Support AbstractUnitRange & SubArrays Closes #198 Co-authored-by: Jishnu Bhattacharya --- src/OffsetArrays.jl | 4 ++++ test/runtests.jl | 24 ++++++++++++++++++++++++ 2 files changed, 28 insertions(+) diff --git a/src/OffsetArrays.jl b/src/OffsetArrays.jl index f40ed926..42f013eb 100644 --- a/src/OffsetArrays.jl +++ b/src/OffsetArrays.jl @@ -424,12 +424,16 @@ julia> A ``` """ no_offset_view(A::OffsetArray) = no_offset_view(parent(A)) +no_offset_view(a::AbstractUnitRange) = UnitRange(a) no_offset_view(a::Array) = a +no_offset_view(i::Number) = i no_offset_view(A::AbstractArray) = _no_offset_view(axes(A), A) _no_offset_view(::Tuple{}, A::AbstractArray{T,0}) where T = A _no_offset_view(::Tuple{<:Base.OneTo,Vararg{<:Base.OneTo}}, A::AbstractArray) = A _no_offset_view(::Any, A::AbstractArray) = OffsetArray(A, Origin(1)) +no_offset_view(S::SubArray) = view(parent(S), map(no_offset_view, parentindices(S))...) + #### # work around for segfault in searchsorted* # https://github.com/JuliaLang/julia/issues/33977 diff --git a/test/runtests.jl b/test/runtests.jl index 1825271d..ec93fc28 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -1364,6 +1364,8 @@ Base.getindex(x::PointlessWrapper, i...) = x.parent[i...] @test N[-3, -4] == 1 V = no_offset_view(N) @test collect(V) == A + A = reshape(view([5], 1, 1)) + @test no_offset_view(A) == A # bidirectional B = BidirectionalVector([1, 2, 3]) @@ -1371,6 +1373,28 @@ Base.getindex(x::PointlessWrapper, i...) = x.parent[i...] OB = OffsetArrays.no_offset_view(B) @test axes(OB, 1) == 1:4 @test collect(OB) == 0:3 + + # issue #198 + offax = axes(OffsetVector(1:10, -5), 1) + noffax = OffsetArrays.no_offset_view(offax) + @test noffax == -4:5 + @test axes(noffax, 1) == 1:10 # ideally covered by the above, but current it isn't + @test isa(noffax, AbstractUnitRange) + + # SubArrays + A = reshape(1:12, 3, 4) + V = view(A, OffsetArrays.IdentityUnitRange(2:3), OffsetArrays.IdentityUnitRange(2:3)) + @test OffsetArrays.no_offset_view(V) == [5 8; 6 9] + V = view(A, OffsetArrays.IdentityUnitRange(2:3), 2) + @test V != [5;6] + @test OffsetArrays.no_offset_view(V) == [5;6] + O = OffsetArray(A, -1:1, 0:3) + V = view(O, 0:1, 1:2) + @test V == OffsetArrays.no_offset_view(V) == [5 8; 6 9] + r1, r2 = OffsetArrays.IdOffsetRange(1:3, -2), OffsetArrays.IdentityUnitRange(2:3) + V = view(O, r1, r2) + @test V != collect(V) + @test OffsetArrays.no_offset_view(V) == collect(V) end @testset "no nesting" begin From a2c4feafdec7cfabb39148b90dd1fbb682dff479 Mon Sep 17 00:00:00 2001 From: Tim Holy Date: Tue, 9 Feb 2021 02:58:25 -0600 Subject: [PATCH 05/14] Preserve IndexStyle for no_offset_views --- src/OffsetArrays.jl | 1 + test/runtests.jl | 2 ++ 2 files changed, 3 insertions(+) diff --git a/src/OffsetArrays.jl b/src/OffsetArrays.jl index 42f013eb..5436cc74 100644 --- a/src/OffsetArrays.jl +++ b/src/OffsetArrays.jl @@ -425,6 +425,7 @@ julia> A """ no_offset_view(A::OffsetArray) = no_offset_view(parent(A)) no_offset_view(a::AbstractUnitRange) = UnitRange(a) +no_offset_view(a::Base.Slice) = Base.Slice(UnitRange(a)) no_offset_view(a::Array) = a no_offset_view(i::Number) = i no_offset_view(A::AbstractArray) = _no_offset_view(axes(A), A) diff --git a/test/runtests.jl b/test/runtests.jl index ec93fc28..8e1dfd7a 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -1395,6 +1395,8 @@ Base.getindex(x::PointlessWrapper, i...) = x.parent[i...] V = view(O, r1, r2) @test V != collect(V) @test OffsetArrays.no_offset_view(V) == collect(V) + V = @view O[:,:] + @test IndexStyle(A) == IndexStyle(O) == IndexStyle(V) == IndexStyle(OffsetArrays.no_offset_view(V)) == IndexLinear() end @testset "no nesting" begin From a630f1e0fa69b4539d46a9596d44d338e9745a9f Mon Sep 17 00:00:00 2001 From: Tim Holy Date: Sun, 17 Jan 2021 11:11:32 -0500 Subject: [PATCH 06/14] Make no_offset_array inferrable This changes the implementation so that the axis *value*s do not affect the type of the output. Technically this is a breaking change, but only at the level of the returned types, not at the level of returned values. --- src/OffsetArrays.jl | 9 +-------- test/runtests.jl | 3 ++- 2 files changed, 3 insertions(+), 9 deletions(-) diff --git a/src/OffsetArrays.jl b/src/OffsetArrays.jl index f3c35758..b136a203 100644 --- a/src/OffsetArrays.jl +++ b/src/OffsetArrays.jl @@ -434,14 +434,7 @@ julia> A 2 4 6 ``` """ -function no_offset_view(A::AbstractArray) - if Base.has_offset_axes(A) - OffsetArray(A, Origin(1)) - else - A - end -end - +no_offset_view(A::AbstractArray) = OffsetArray(A, Origin(1)) no_offset_view(A::OffsetArray) = no_offset_view(parent(A)) no_offset_view(a::Array) = a diff --git a/test/runtests.jl b/test/runtests.jl index f8537736..07efdd56 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -1403,6 +1403,7 @@ end Base.parent(x::PointlessWrapper) = x.parent Base.size(x::PointlessWrapper) = size(parent(x)) Base.axes(x::PointlessWrapper) = axes(parent(x)) +Base.getindex(x::PointlessWrapper, i...) = x.parent[i...] @testset "no offset view" begin # OffsetArray fallback @@ -1415,7 +1416,7 @@ Base.axes(x::PointlessWrapper) = axes(parent(x)) @inferred no_offset_view(O2) P = PointlessWrapper(A) - @test no_offset_view(P) ≡ P + @test @inferred(no_offset_view(P)) == P # generic fallback A = collect(reshape(1:12, 3, 4)) From 5a53eb4e2d29867733cb920df177300fee06b1e8 Mon Sep 17 00:00:00 2001 From: Tim Holy Date: Thu, 21 Jan 2021 16:57:10 -0600 Subject: [PATCH 07/14] don't add wrapper for OneTo axes arrays --- src/OffsetArrays.jl | 5 ++++- test/runtests.jl | 5 ++++- 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/src/OffsetArrays.jl b/src/OffsetArrays.jl index b136a203..927471ac 100644 --- a/src/OffsetArrays.jl +++ b/src/OffsetArrays.jl @@ -434,9 +434,12 @@ julia> A 2 4 6 ``` """ -no_offset_view(A::AbstractArray) = OffsetArray(A, Origin(1)) no_offset_view(A::OffsetArray) = no_offset_view(parent(A)) no_offset_view(a::Array) = a +no_offset_view(A::AbstractArray) = _no_offset_view(axes(A), A) +_no_offset_view(::Tuple{}, A::AbstractArray{T,0}) where T = A +_no_offset_view(::Tuple{<:Base.OneTo,Vararg{<:Base.OneTo}}, A::AbstractArray) = A +_no_offset_view(::Any, A::AbstractArray) = OffsetArray(A, Origin(1)) #### # work around for segfault in searchsorted* diff --git a/test/runtests.jl b/test/runtests.jl index 07efdd56..66fbde14 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -1416,7 +1416,10 @@ Base.getindex(x::PointlessWrapper, i...) = x.parent[i...] @inferred no_offset_view(O2) P = PointlessWrapper(A) - @test @inferred(no_offset_view(P)) == P + @test @inferred(no_offset_view(P)) === P + @test @inferred(no_offset_view(A)) === A + a0 = reshape([1]) + @test @inferred(no_offset_view(a0)) === a0 # generic fallback A = collect(reshape(1:12, 3, 4)) From 0d977a98d82dbb51784371e0a0d544304e2b3316 Mon Sep 17 00:00:00 2001 From: Tim Holy Date: Thu, 21 Jan 2021 17:08:21 -0600 Subject: [PATCH 08/14] Improve test coverage --- test/runtests.jl | 2 ++ 1 file changed, 2 insertions(+) diff --git a/test/runtests.jl b/test/runtests.jl index 66fbde14..4f39e103 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -1420,6 +1420,8 @@ Base.getindex(x::PointlessWrapper, i...) = x.parent[i...] @test @inferred(no_offset_view(A)) === A a0 = reshape([1]) @test @inferred(no_offset_view(a0)) === a0 + a0v = view(a0) + @test @inferred(no_offset_view(a0v)) === a0v # generic fallback A = collect(reshape(1:12, 3, 4)) From 4c11c2d4178cb0eee623d02f3f098a3f185f1e98 Mon Sep 17 00:00:00 2001 From: Tim Holy Date: Sun, 7 Feb 2021 07:33:19 -0600 Subject: [PATCH 09/14] Support AbstractUnitRange & SubArrays Closes #198 Co-authored-by: Jishnu Bhattacharya --- src/OffsetArrays.jl | 4 ++++ test/runtests.jl | 24 ++++++++++++++++++++++++ 2 files changed, 28 insertions(+) diff --git a/src/OffsetArrays.jl b/src/OffsetArrays.jl index 927471ac..f9e081ce 100644 --- a/src/OffsetArrays.jl +++ b/src/OffsetArrays.jl @@ -435,12 +435,16 @@ julia> A ``` """ no_offset_view(A::OffsetArray) = no_offset_view(parent(A)) +no_offset_view(a::AbstractUnitRange) = UnitRange(a) no_offset_view(a::Array) = a +no_offset_view(i::Number) = i no_offset_view(A::AbstractArray) = _no_offset_view(axes(A), A) _no_offset_view(::Tuple{}, A::AbstractArray{T,0}) where T = A _no_offset_view(::Tuple{<:Base.OneTo,Vararg{<:Base.OneTo}}, A::AbstractArray) = A _no_offset_view(::Any, A::AbstractArray) = OffsetArray(A, Origin(1)) +no_offset_view(S::SubArray) = view(parent(S), map(no_offset_view, parentindices(S))...) + #### # work around for segfault in searchsorted* # https://github.com/JuliaLang/julia/issues/33977 diff --git a/test/runtests.jl b/test/runtests.jl index 4f39e103..dc7a3be9 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -1429,6 +1429,8 @@ Base.getindex(x::PointlessWrapper, i...) = x.parent[i...] @test N[-3, -4] == 1 V = no_offset_view(N) @test collect(V) == A + A = reshape(view([5], 1, 1)) + @test no_offset_view(A) == A # bidirectional B = BidirectionalVector([1, 2, 3]) @@ -1436,6 +1438,28 @@ Base.getindex(x::PointlessWrapper, i...) = x.parent[i...] OB = OffsetArrays.no_offset_view(B) @test axes(OB, 1) == 1:4 @test collect(OB) == 0:3 + + # issue #198 + offax = axes(OffsetVector(1:10, -5), 1) + noffax = OffsetArrays.no_offset_view(offax) + @test noffax == -4:5 + @test axes(noffax, 1) == 1:10 # ideally covered by the above, but current it isn't + @test isa(noffax, AbstractUnitRange) + + # SubArrays + A = reshape(1:12, 3, 4) + V = view(A, OffsetArrays.IdentityUnitRange(2:3), OffsetArrays.IdentityUnitRange(2:3)) + @test OffsetArrays.no_offset_view(V) == [5 8; 6 9] + V = view(A, OffsetArrays.IdentityUnitRange(2:3), 2) + @test V != [5;6] + @test OffsetArrays.no_offset_view(V) == [5;6] + O = OffsetArray(A, -1:1, 0:3) + V = view(O, 0:1, 1:2) + @test V == OffsetArrays.no_offset_view(V) == [5 8; 6 9] + r1, r2 = OffsetArrays.IdOffsetRange(1:3, -2), OffsetArrays.IdentityUnitRange(2:3) + V = view(O, r1, r2) + @test V != collect(V) + @test OffsetArrays.no_offset_view(V) == collect(V) end @testset "no nesting" begin From 103a62902f66e60385a4292e64b0ba747e82cdcd Mon Sep 17 00:00:00 2001 From: Tim Holy Date: Tue, 9 Feb 2021 02:58:25 -0600 Subject: [PATCH 10/14] Preserve IndexStyle for no_offset_views --- src/OffsetArrays.jl | 1 + test/runtests.jl | 2 ++ 2 files changed, 3 insertions(+) diff --git a/src/OffsetArrays.jl b/src/OffsetArrays.jl index f9e081ce..64d8d3a3 100644 --- a/src/OffsetArrays.jl +++ b/src/OffsetArrays.jl @@ -436,6 +436,7 @@ julia> A """ no_offset_view(A::OffsetArray) = no_offset_view(parent(A)) no_offset_view(a::AbstractUnitRange) = UnitRange(a) +no_offset_view(a::Base.Slice) = Base.Slice(UnitRange(a)) no_offset_view(a::Array) = a no_offset_view(i::Number) = i no_offset_view(A::AbstractArray) = _no_offset_view(axes(A), A) diff --git a/test/runtests.jl b/test/runtests.jl index dc7a3be9..d462670f 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -1460,6 +1460,8 @@ Base.getindex(x::PointlessWrapper, i...) = x.parent[i...] V = view(O, r1, r2) @test V != collect(V) @test OffsetArrays.no_offset_view(V) == collect(V) + V = @view O[:,:] + @test IndexStyle(A) == IndexStyle(O) == IndexStyle(V) == IndexStyle(OffsetArrays.no_offset_view(V)) == IndexLinear() end @testset "no nesting" begin From 5db24acb6d806d3085c3c4500efefcf71f5b8ffd Mon Sep 17 00:00:00 2001 From: Tim Holy Date: Tue, 9 Feb 2021 03:29:29 -0600 Subject: [PATCH 11/14] Fix Adapt ambiguity Not introduced by this PR, but easily fixed --- test/runtests.jl | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/test/runtests.jl b/test/runtests.jl index d462670f..a5f8c0ff 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -41,7 +41,7 @@ end end @testset "IdOffsetRange" begin - + function check_indexed_by(r, rindx) for i in rindx r[i] @@ -1522,6 +1522,7 @@ end @testset "Adapt" begin # We need another storage type, CUDA.jl defines one but we can't use that for CI # let's define an appropriate method for SArrays + Adapt.adapt_storage(::Type{SA}, xs::Array) where SA<:SArray = convert(SA, xs) # ambiguity Adapt.adapt_storage(::Type{SA}, xs::AbstractArray) where SA<:SArray = convert(SA, xs) arr = OffsetArray(rand(3, 3), -1:1, -1:1) s_arr = adapt(SMatrix{3,3}, arr) From fb653543b075f650dc05002f3e3864fe96f29905 Mon Sep 17 00:00:00 2001 From: Tim Holy Date: Tue, 9 Feb 2021 03:56:32 -0600 Subject: [PATCH 12/14] Restrict Slice specialization to julia > 1.0 In 1.0 Slice doesn't cleanly mean "the whole axis", it's conflated with IdentityUnitRange. --- src/OffsetArrays.jl | 4 +++- test/runtests.jl | 13 ++++++++++--- 2 files changed, 13 insertions(+), 4 deletions(-) diff --git a/src/OffsetArrays.jl b/src/OffsetArrays.jl index 64d8d3a3..c8789117 100644 --- a/src/OffsetArrays.jl +++ b/src/OffsetArrays.jl @@ -436,7 +436,9 @@ julia> A """ no_offset_view(A::OffsetArray) = no_offset_view(parent(A)) no_offset_view(a::AbstractUnitRange) = UnitRange(a) -no_offset_view(a::Base.Slice) = Base.Slice(UnitRange(a)) +if isdefined(Base, :IdentityUnitRange) + no_offset_view(a::Base.Slice) = Base.Slice(UnitRange(a)) +end no_offset_view(a::Array) = a no_offset_view(i::Number) = i no_offset_view(A::AbstractArray) = _no_offset_view(axes(A), A) diff --git a/test/runtests.jl b/test/runtests.jl index a5f8c0ff..7362352b 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -1449,10 +1449,14 @@ Base.getindex(x::PointlessWrapper, i...) = x.parent[i...] # SubArrays A = reshape(1:12, 3, 4) V = view(A, OffsetArrays.IdentityUnitRange(2:3), OffsetArrays.IdentityUnitRange(2:3)) - @test OffsetArrays.no_offset_view(V) == [5 8; 6 9] + if collect(V) == [5 8; 6 9] # julia 1.0 has a bug here + @test OffsetArrays.no_offset_view(V) == [5 8; 6 9] + end V = view(A, OffsetArrays.IdentityUnitRange(2:3), 2) @test V != [5;6] - @test OffsetArrays.no_offset_view(V) == [5;6] + if collect(V) == [5;6] + @test OffsetArrays.no_offset_view(V) == [5;6] + end O = OffsetArray(A, -1:1, 0:3) V = view(O, 0:1, 1:2) @test V == OffsetArrays.no_offset_view(V) == [5 8; 6 9] @@ -1461,7 +1465,10 @@ Base.getindex(x::PointlessWrapper, i...) = x.parent[i...] @test V != collect(V) @test OffsetArrays.no_offset_view(V) == collect(V) V = @view O[:,:] - @test IndexStyle(A) == IndexStyle(O) == IndexStyle(V) == IndexStyle(OffsetArrays.no_offset_view(V)) == IndexLinear() + if isdefined(Base, :IdentityUnitRange) + # If `Slice` is distinguished from `IdentityUnitRange` + @test IndexStyle(A) == IndexStyle(O) == IndexStyle(V) == IndexStyle(OffsetArrays.no_offset_view(V)) == IndexLinear() + end end @testset "no nesting" begin From 2ef6e5319a639617f5a4b62c362f30d97d864953 Mon Sep 17 00:00:00 2001 From: Tim Holy Date: Tue, 9 Feb 2021 05:54:19 -0600 Subject: [PATCH 13/14] Only specialize for SubArray on Julia 1.1+ --- src/OffsetArrays.jl | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/OffsetArrays.jl b/src/OffsetArrays.jl index c8789117..f37f461c 100644 --- a/src/OffsetArrays.jl +++ b/src/OffsetArrays.jl @@ -437,7 +437,8 @@ julia> A no_offset_view(A::OffsetArray) = no_offset_view(parent(A)) no_offset_view(a::AbstractUnitRange) = UnitRange(a) if isdefined(Base, :IdentityUnitRange) - no_offset_view(a::Base.Slice) = Base.Slice(UnitRange(a)) + no_offset_view(a::Base.Slice) = Base.Slice(UnitRange(a)) # valid only if Slice is distinguished from IdentityUnitRange + no_offset_view(S::SubArray) = view(parent(S), map(no_offset_view, parentindices(S))...) end no_offset_view(a::Array) = a no_offset_view(i::Number) = i @@ -446,8 +447,6 @@ _no_offset_view(::Tuple{}, A::AbstractArray{T,0}) where T = A _no_offset_view(::Tuple{<:Base.OneTo,Vararg{<:Base.OneTo}}, A::AbstractArray) = A _no_offset_view(::Any, A::AbstractArray) = OffsetArray(A, Origin(1)) -no_offset_view(S::SubArray) = view(parent(S), map(no_offset_view, parentindices(S))...) - #### # work around for segfault in searchsorted* # https://github.com/JuliaLang/julia/issues/33977 From dac24199c405875385f887a2dc449f47f3a3c3c2 Mon Sep 17 00:00:00 2001 From: Tim Holy Date: Tue, 9 Feb 2021 06:08:14 -0600 Subject: [PATCH 14/14] test alsoJulia 1.0 indexstyle --- test/runtests.jl | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/test/runtests.jl b/test/runtests.jl index 7362352b..a8bbc7ea 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -1465,10 +1465,7 @@ Base.getindex(x::PointlessWrapper, i...) = x.parent[i...] @test V != collect(V) @test OffsetArrays.no_offset_view(V) == collect(V) V = @view O[:,:] - if isdefined(Base, :IdentityUnitRange) - # If `Slice` is distinguished from `IdentityUnitRange` - @test IndexStyle(A) == IndexStyle(O) == IndexStyle(V) == IndexStyle(OffsetArrays.no_offset_view(V)) == IndexLinear() - end + @test IndexStyle(A) == IndexStyle(O) == IndexStyle(V) == IndexStyle(OffsetArrays.no_offset_view(V)) == IndexLinear() end @testset "no nesting" begin