Do all ranges use 1-based indexing? · helpdesk (published)

Stream: helpdesk (published)

Topic: Do all ranges use 1-based indexing?

Lilith Hafner (Feb 05 2024 at 22:12):

I recall reading somewhere that AbstractRanges must use 1-based indexing, but now I can't find that anywhere. Does anyone know if that is the case?

Jakob Nybo Nissen (Feb 06 2024 at 08:58):

Can't find it either (and if neither of us can find it, it can't really be claimed to be documented).
The default implementation is 1-based.

Mason Protter (Feb 06 2024 at 09:25):

There are non-1 based ranges in OffsetArrays.jl

Mason Protter (Feb 06 2024 at 09:28):

julia> using OffsetArrays

julia> A = OffsetArray(rand(11), -5:5);

julia> I = eachindex(A)
OffsetArrays.IdOffsetRange(values=-5:5, indices=-5:5)

julia> I[-5]
-5

Lilith Hafner (Feb 06 2024 at 15:29):

In that case this doesn't look good:

sortperm(r::AbstractRange) = issorted(r) ? (1:1:length(r)) : (length(r):-1:1)

Jakob Nybo Nissen (Feb 06 2024 at 15:30):

Also won't that method cover step ranges?

Andy Dienes (Feb 06 2024 at 15:34):

Lilith Hafner (Feb 06 2024 at 15:34):

I thought the same thing, but it's sortperm, not sort, and we can assume indexing is consecutive.

Lilith Hafner (Feb 06 2024 at 15:34):

@Andy Dienes Yes, that's why I brought this up

Lilith Hafner (Feb 06 2024 at 15:45):

#53208

Michael Abbott (Feb 06 2024 at 16:41):

After stumbling across this, I wondered whether sortperm is supposed to return indices or a permutation?

Michael Abbott (Feb 06 2024 at 16:42):

sortperm(OffsetArray(randn(5), 10)) does return indices

Andy Dienes (Feb 06 2024 at 16:45):

I think issorted(x[sortperm(x)]) should always be true

Lilith Hafner (Feb 06 2024 at 17:47):

I agree: https://github.com/JuliaLang/julia/pull/53208/commits/150e61bdcd53853a97936bd48f08924dccfd059a

Andy Dienes (Feb 06 2024 at 18:48):

while on the topic, maybe empty should be implemented for most range types?

julia> empty(Base.OneTo(10))
Int64[]

julia> empty(1:10)
Int64[]

julia> empty(1:1:10)
Int64[]

seems like those should arguably return Base.OneTo(0), 1:0 and 1:1:0

Lilith Hafner (Feb 06 2024 at 20:16):

I think the result of empty should be mutable.

  empty(v::AbstractVector, [eltype])

  Create an empty vector similar to v,
  optionally changing the eltype.

similar(array, [element_type=eltype(array)], [dims=size(array)])

  Create an uninitialized mutable array with the
  given element type and size, based upon the
  given source array...

Jishnu Bhattacharya (Feb 07 2024 at 03:12):

A key observation in OffsetArrays is that the axes of an OffsetArray are their own axes. These, therefore, can't be 1-based. Admittedly, offset ranges aren't treated fully consistently in Base (occasionally the offset is ignored, e.g. when comparing the ranges), and Tim Holy had an issue open about handling offset ranges consistently for Julia 2.0

Mason Protter (Feb 07 2024 at 09:57):

Jishnu Bhattacharya said:

A key observation in OffsetArrays is that the axes of an OffsetArray are their own axes. These, therefore, can't be 1-based.

But is there any good reason for that? It seems unnecessary to me

Michael Abbott (Feb 07 2024 at 14:38):

I think Tim Holy thought carefully about what properties to require, at some point? And maybe the key was something like x[axes(x,1)] .== x combined with axes(x[ind]) == axes(ind)? Edit: The docs say the basic axiom is x[inds][j] == x[inds[j]], but don't spend any time arguing for why we must accept this.

Michael Abbott (Feb 07 2024 at 14:38):

Would be happier if there was a different set of nice axioms allowing simple UnitRanges, though.

Last updated: Dec 28 2024 at 04:38 UTC