Shortcut for sub2ind indexing

[leviboyles]

I frequently find myself using the sub2ind function in my work, so I created a handy shortcut so that

A[(x, y)] = [A[x[1], y[1]], A[x[2], y[2]] ..] 

That is the indices of x and y are matched in pairs. The code that allows this is

function getindex{T, N}(A::AbstractArray{T,N}, subscript_tuple::Tuple )
    @assert N == length(subscript_tuple)
    for k = 2:length(subscript_tuple)
        @assert length(subscript_tuple[1]) == length(subscript_tuple[k])
    end

    inds = sub2ind(size(A), subscript_tuple...)
    A[inds]
end

function setindex!{T, N}(A::AbstractArray{T,N}, x, subscript_tuple::Tuple )
    @assert N == length(subscript_tuple)
    for k = 2:length(subscript_tuple)
        @assert length(subscript_tuple[1]) == length(subscript_tuple[k])
    end

    inds = sub2ind(size(A), subscript_tuple...)
    A[inds] = x
end

I think this (or some similar syntax) would be useful to many people, and perhaps could be included in base. Right now this definition raises warnings that it conflicts with SharedArray.

[JeffBezanson]

A more efficient way to do this would be [A[x[i],y[i]] for i in 1:length(x)].
We might want to reserve indexing with tuples for something else in the future.

[leviboyles]

Fair enough. One thing about array comprehensions is that only the most basic arguments will give an Array with the correct type. For the one above I get an Array{Any}.

[carlobaldassi]

One thing about array comprehensions is that only the most basic arguments will give an Array with the correct type. For the one above I get an Array{Any}.

I assume you ran the code directly in the REPL prompt? Type inference is much harder there, with global variables; testing within a function normally gives better results (almost surely in this case).
At any rate, you can force the type of the comprehension by putting the type before the brackets, e.g. like this:

(eltype(A))[A[x[i],y[i]] for i in 1:length(x)]

[toivoh]

It seems to me that this is a special case of broadcast_getindex. I.e. what you write as A[(x,y)] would be equivalent to

broadcast_getindex(A, x, y)

I suggested in #2591 to add syntax for this as

A.[x, y]

but this seems to be the first time in a while that someone has asked for something like this :)

[leviboyles]

Ah I forgot that type inference is harder in the REPL. Sorry! I think I will switch to broadcast_getindex. Thanks everyone for the help.