Skip to content

Commit

Permalink
remove NoSlice
Browse files Browse the repository at this point in the history
  • Loading branch information
@simonbyrne
simonbyrne committed Jun 17, 2016
1 parent 96efd0d commit 9ab7c8f
Show file tree
Hide file tree
Showing 4 changed files with 12 additions and 46 deletions.
40 changes: 6 additions & 34 deletions base/subarray.jl
View file
Original file line number Diff line number Diff line change
Expand Up @@ -32,40 +32,16 @@ end
check_parent_index_match{T,N}(parent::AbstractArray{T,N}, indexes::NTuple{N}) = nothing
check_parent_index_match(parent, indexes) = throw(ArgumentError("number of indices ($(length(indexes))) must match the parent dimensionality ($(ndims(parent)))"))

# The NoSlice one-element vector type keeps dimensions without losing performance
immutable NoSlice <: AbstractVector{Int}
i::Int
end
size(::NoSlice) = (1,)
length(::NoSlice) = 1
linearindexing(::Type{NoSlice}) = LinearFast()
function getindex(N::NoSlice, i::Int)
@_inline_meta
@boundscheck i == 1 || throw_boundserror(N, i)
N.i
end
function getindex(N::NoSlice, i::NoSlice)
@_inline_meta
@boundscheck i.i == 1 || throw_boundserror(N, i)
N
end
getindex(N::NoSlice, ::Colon) = N
function getindex(N::NoSlice, r::Range{Int})
@_inline_meta
@boundscheck checkbounds(N, r)
N
end

# This computes the linear indexing compatability for a given tuple of indices
viewindexing() = LinearFast()
# Leading scalar indexes simply increase the stride
viewindexing(I::Tuple{Union{Real, NoSlice}, Vararg{Any}}) = (@_inline_meta; viewindexing(tail(I)))
viewindexing(I::Tuple{Real, Vararg{Any}}) = (@_inline_meta; viewindexing(tail(I)))
# Colons may begin a section which may be followed by any number of Colons
viewindexing(I::Tuple{Colon, Colon, Vararg{Any}}) = (@_inline_meta; viewindexing(tail(I)))
# A UnitRange can follow Colons, but only if all other indices are scalar
viewindexing(I::Tuple{Colon, UnitRange, Vararg{Union{Real, NoSlice}}}) = LinearFast()
viewindexing(I::Tuple{Colon, UnitRange, Vararg{Real}}) = LinearFast()
# In general, ranges are only fast if all other indices are scalar
viewindexing(I::Tuple{Union{Range, Colon}, Vararg{Union{Real, NoSlice}}}) = LinearFast()
viewindexing(I::Tuple{Union{Range, Colon}, Vararg{Real}}) = LinearFast()
# All other index combinations are slow
viewindexing(I::Tuple{Vararg{Any}}) = LinearSlow()
# Of course, all other array types are slow
Expand Down Expand Up @@ -214,7 +190,6 @@ substrides(parent, I::Tuple) = substrides(1, parent, 1, I)
substrides(s, parent, dim, ::Tuple{}) = ()
substrides(s, parent, dim, I::Tuple{Real, Vararg{Any}}) = (substrides(s*size(parent, dim), parent, dim+1, tail(I))...)
substrides(s, parent, dim, I::Tuple{AbstractCartesianIndex, Vararg{Any}}) = substrides(s, parent, dim, (I[1].I..., tail(I)...))
substrides(s, parent, dim, I::Tuple{NoSlice, Vararg{Any}}) = (s, substrides(s*size(parent, dim), parent, dim+1, tail(I))...)
substrides(s, parent, dim, I::Tuple{Colon, Vararg{Any}}) = (s, substrides(s*size(parent, dim), parent, dim+1, tail(I))...)
substrides(s, parent, dim, I::Tuple{Range, Vararg{Any}}) = (s*step(I[1]), substrides(s*size(parent, dim), parent, dim+1, tail(I))...)
substrides(s, parent, dim, I::Tuple{Any, Vararg{Any}}) = throw(ArgumentError("strides is invalid for SubArrays with indices of type $(typeof(I[1]))"))
Expand All @@ -223,7 +198,7 @@ stride(V::SubArray, d::Integer) = d <= ndims(V) ? strides(V)[d] : strides(V)[end

compute_stride1(parent, I::Tuple) = compute_stride1(1, parent, 1, I)
compute_stride1(s, parent, dim, I::Tuple{}) = s
compute_stride1(s, parent, dim, I::Tuple{Union{DroppedScalar, NoSlice}, Vararg{Any}}) =
compute_stride1(s, parent, dim, I::Tuple{DroppedScalar, Vararg{Any}}) =
(@_inline_meta; compute_stride1(s*size(parent, dim), parent, dim+1, tail(I)))
compute_stride1(s, parent, dim, I::Tuple{Range, Vararg{Any}}) = s*step(I[1])
compute_stride1(s, parent, dim, I::Tuple{Colon, Vararg{Any}}) = s
Expand Down Expand Up @@ -263,8 +238,6 @@ compute_offset1(parent, stride1::Integer, dims, inds, I::Tuple) = compute_linind
compute_linindex(parent, I) = compute_linindex(1, 1, parent, 1, I)
compute_linindex(f, s, parent, dim, I::Tuple{Real, Vararg{Any}}) =
(@_inline_meta; compute_linindex(f + (I[1]-first(indices(parent,dim)))*s, s*size(parent, dim), parent, dim+1, tail(I)))
compute_linindex(f, s, parent, dim, I::Tuple{NoSlice, Vararg{Any}}) =
(@_inline_meta; compute_linindex(f + (I[1].i-first(indices(parent,dim)))*s, s*size(parent, dim), parent, dim+1, tail(I)))
# Just splat out the cartesian indices and continue
compute_linindex(f, s, parent, dim, I::Tuple{AbstractCartesianIndex, Vararg{Any}}) =
(@_inline_meta; compute_linindex(f, s, parent, dim, (I[1].I..., tail(I)...)))
Expand All @@ -277,18 +250,17 @@ compute_linindex(f, s, parent, dim, I::Tuple{}) = f
find_extended_dims(I) = (@_inline_meta; _find_extended_dims((), (), 1, I...))
_find_extended_dims(dims, inds, dim) = dims, inds
_find_extended_dims(dims, inds, dim, ::Real, I...) = _find_extended_dims(dims, inds, dim+1, I...)
_find_extended_dims(dims, inds, dim, ::NoSlice, I...) = _find_extended_dims(dims, inds, dim+1, I...)
_find_extended_dims(dims, inds, dim, i1::AbstractCartesianIndex, I...) = _find_extended_dims(dims, inds, dim, i1.I..., I...)
_find_extended_dims(dims, inds, dim, i1, I...) = _find_extended_dims((dims..., dim), (inds..., i1), dim+1, I...)

unsafe_convert{T,N,P,I<:Tuple{Vararg{Union{RangeIndex, NoSlice}}}}(::Type{Ptr{T}}, V::SubArray{T,N,P,I}) =
unsafe_convert{T,N,P,I<:Tuple{Vararg{RangeIndex}}}(::Type{Ptr{T}}, V::SubArray{T,N,P,I}) =
unsafe_convert(Ptr{T}, V.parent) + (first_index(V)-1)*sizeof(T)

pointer(V::FastSubArray, i::Int) = pointer(V.parent, V.offset1 + V.stride1*i)
pointer(V::FastContiguousSubArray, i::Int) = pointer(V.parent, V.offset1 + i)
pointer(V::SubArray, i::Int) = pointer(V, smart_ind2sub(shape(V), i))

function pointer{T,N,P<:Array,I<:Tuple{Vararg{Union{RangeIndex, NoSlice}}}}(V::SubArray{T,N,P,I}, is::Tuple{Vararg{Int}})
function pointer{T,N,P<:Array,I<:Tuple{Vararg{RangeIndex}}}(V::SubArray{T,N,P,I}, is::Tuple{Vararg{Int}})
index = first_index(V)
strds = strides(V)
for d = 1:length(is)
Expand Down
6 changes: 3 additions & 3 deletions base/sysimg.jl
View file
Original file line number Diff line number Diff line change
Expand Up @@ -117,9 +117,9 @@ include("iterator.jl")

# Definition of StridedArray
typealias StridedReshapedArray{T,N,A<:DenseArray} ReshapedArray{T,N,A}
typealias StridedArray{T,N,A<:Union{DenseArray,StridedReshapedArray},I<:Tuple{Vararg{Union{RangeIndex, NoSlice, AbstractCartesianIndex}}}} Union{DenseArray{T,N}, SubArray{T,N,A,I}, StridedReshapedArray{T,N}}
typealias StridedVector{T,A<:Union{DenseArray,StridedReshapedArray},I<:Tuple{Vararg{Union{RangeIndex, NoSlice, AbstractCartesianIndex}}}} Union{DenseArray{T,1}, SubArray{T,1,A,I}, StridedReshapedArray{T,1}}
typealias StridedMatrix{T,A<:Union{DenseArray,StridedReshapedArray},I<:Tuple{Vararg{Union{RangeIndex, NoSlice, AbstractCartesianIndex}}}} Union{DenseArray{T,2}, SubArray{T,2,A,I}, StridedReshapedArray{T,2}}
typealias StridedArray{T,N,A<:Union{DenseArray,StridedReshapedArray},I<:Tuple{Vararg{Union{RangeIndex, AbstractCartesianIndex}}}} Union{DenseArray{T,N}, SubArray{T,N,A,I}, StridedReshapedArray{T,N}}
typealias StridedVector{T,A<:Union{DenseArray,StridedReshapedArray},I<:Tuple{Vararg{Union{RangeIndex, AbstractCartesianIndex}}}} Union{DenseArray{T,1}, SubArray{T,1,A,I}, StridedReshapedArray{T,1}}
typealias StridedMatrix{T,A<:Union{DenseArray,StridedReshapedArray},I<:Tuple{Vararg{Union{RangeIndex, AbstractCartesianIndex}}}} Union{DenseArray{T,2}, SubArray{T,2,A,I}, StridedReshapedArray{T,2}}
typealias StridedVecOrMat{T} Union{StridedVector{T}, StridedMatrix{T}}

# For OS specific stuff
Expand Down
8 changes: 1 addition & 7 deletions doc/stdlib/arrays.rst
View file
Original file line number Diff line number Diff line change
Expand Up @@ -377,7 +377,7 @@ Indexing, Assignment, and Concatenation
Returns a subset of array ``A`` as specified by ``inds``\ , where each ``ind`` may be an ``Int``\ , a ``Range``\ , or a ``Vector``\ . See the manual section on :ref:`array indexing <man-array-indexing>` for details.

.. function:: sub(A, inds...)
.. function:: view(A, inds...)

.. Docstring generated from Julia source
Expand All @@ -401,12 +401,6 @@ Indexing, Assignment, and Concatenation
Return all the data of ``A`` where the index for dimension ``d`` equals ``i``\ . Equivalent to ``A[:,:,...,i,:,:,...]`` where ``i`` is in position ``d``\ .

.. function:: slice(A, inds...)

.. Docstring generated from Julia source
Returns a view of array ``A`` with the given indices like :func:`sub`\ , but drops all dimensions indexed with scalars.

.. function:: setindex!(A, X, inds...)

.. Docstring generated from Julia source
Expand Down
4 changes: 2 additions & 2 deletions test/subarray.jl
View file
Original file line number Diff line number Diff line change
Expand Up @@ -333,7 +333,7 @@ A = copy(reshape(1:120, 3, 5, 8))
sA = view(A, 2:2, 1:5, :)
@test strides(sA) == (1, 3, 15)
@test parent(sA) == A
@test parentindexes(sA) == (Base.NoSlice(2), 1:5, :)
@test parentindexes(sA) == (2:2, 1:5, :)
@test Base.parentdims(sA) == [1:3;]
@test size(sA) == (1, 5, 8)
@test sA[1, 2, 1:8][:] == [5:15:120;]
Expand Down Expand Up @@ -463,5 +463,5 @@ let A = rand(10), sA = view(copy(A), :)
end

# the following segfaults with LLVM 3.8 on Windows, ref #15417
@test collect(view(view(reshape(1:13^3, 13, 13, 13), 3:7, 6, :), 1:2:5, :, 1:2:5)) ==
@test collect(view(view(reshape(1:13^3, 13, 13, 13), 3:7, 6:6, :), 1:2:5, :, 1:2:5)) ==
cat(3,[68,70,72],[406,408,410],[744,746,748])

0 comments on commit 9ab7c8f

Please sign in to comment.