Stop of a range with length 0

abs · June 5, 2023, 2:25am

Just curious:

For the following kind of ranges of length 0, please note the submitted stop and returned

julia> 12:1:**3**
12:1:**11**

julia> range(12,**stop=3**;step = 1)
12:1:**11**

Is this by design?

_range(start::Any , step::Any , stop::Any , len::Nothing) = range_start_step_stop(start, step, stop)

github.com

JuliaLang/julia/blob/8e630552924eac54c809aa7bc30871c7df1582d3/base/range.jl#L164


      
          _range(start::Nothing, step::Any    , stop::Nothing, len::Nothing) = range_error(start, step, stop, len)
          _range(start::Nothing, step::Any    , stop::Nothing, len::Any    ) = range_error(start, step, stop, len)
          _range(start::Nothing, step::Any    , stop::Any    , len::Nothing) = range_error(start, step, stop, len)
          _range(start::Nothing, step::Any    , stop::Any    , len::Any    ) = range_step_stop_length(step, stop, len)
          _range(start::Any    , step::Nothing, stop::Nothing, len::Nothing) = range_error(start, step, stop, len)
          _range(start::Any    , step::Nothing, stop::Nothing, len::Any    ) = range_start_length(start, len)
          _range(start::Any    , step::Nothing, stop::Any    , len::Nothing) = range_start_stop(start, stop)
          _range(start::Any    , step::Nothing, stop::Any    , len::Any    ) = range_start_stop_length(start, stop, len)
          _range(start::Any    , step::Any    , stop::Nothing, len::Nothing) = range_error(start, step, stop, len)
          _range(start::Any    , step::Any    , stop::Nothing, len::Any    ) = range_start_step_length(start, step, len)
          _range(start::Any    , step::Any    , stop::Any    , len::Nothing) = range_start_step_stop(start, step, stop)
          _range(start::Any    , step::Any    , stop::Any    , len::Any    ) = range_error(start, step, stop, len)
          
          
# Length as the only argument
          range_length(len::Integer) = OneTo(len)
          
          
# Stop as the only argument
          range_stop(stop) = range_start_stop(oftype(stop, 1), stop)
          range_stop(stop::Integer) = range_length(stop)
          
          
function range_step_stop_length(step, a, len::Integer)

range_start_step_stop(start, step, stop) = start:step:stop

github.com

JuliaLang/julia/blob/8e630552924eac54c809aa7bc30871c7df1582d3/base/range.jl#L216


      
          
          
function range_start_step_length(a, step, len::Integer)
              stop = a + step * (len - oneunit(len))
              if stop isa Signed
                  # overflow in recomputing length from stop is okay
                  return StepRange{typeof(stop),typeof(step)}(convert(typeof(stop), a), step, stop)
              end
              return StepRangeLen{typeof(stop),typeof(a),typeof(step)}(a, step, len)
          end
          
          
range_start_step_stop(start, step, stop) = start:step:stop
          
          
function range_error(start, step, stop, length)
              hasstart  = start !== nothing
              hasstep   = step  !== nothing
              hasstop   = stop  !== nothing
              haslength = start !== nothing
          
          
    hint = if hasstart && hasstep && hasstop && haslength
                  "Try specifying only three arguments"
              elseif !hasstop && !haslength

Thanks.

Benny · June 5, 2023, 3:30am

Yes, the StepRange constructor calls steprange_last(start, step, stop) to recompute the stop value. The purpose is to have 1 unique instance represent each non-empty sequence; this makes comparisons 1:2:4 === 1:2:3 easier, which helps things like hashing. An empty sequence does not have 1 unique instance, but that call does limit the variability of stop relative to start.

abs · June 5, 2023, 4:07am

So all ranges of length zero, regardless of their start, stop and step values, are considered equal - the reasons make sense, thanks.

Good to be aware not to expect range stop getting round-tripped under all conditions.

Thanks!

albheim · June 5, 2023, 6:49am

You get equal for all zero length ranges since they represent the same value (a range with no items).
You get identical only for zero length ranges with the same start and step, since they are stored exactly the same.

julia> 5:2:4 == 5:2:3
true

julia> 4:2:3 == 5:2:3
true

julia> 5:1:4 == 5:2:4
true

julia> 5:2:4 === 5:2:3
true

julia> 4:2:3 === 5:2:3
false

julia> 5:1:4 === 5:2:4
false