float ranges: if `a+n*s == b`, `length(a:s:b)` should be `n+1`

[StefanKarpinski]

See http://stackoverflow.com/questions/41985718/why-the-values-are-not-correctly-iterated-using-range-arrays/41986875#41986875.

Example:

julia> a, s, b = 3*0.05, 0.05, 4*0.05
(0.15000000000000002,0.05,0.2)

julia> a + 1*s == b
true

julia> length(a:s:b)
1

Rational lifting doesn't address this case since 0.15000000000000002 != 3/20 == 0.15.

[timholy]

Interestingly, this does work with #18777 (comment). That might introduce problems of its own, of course. A more conservative version is

function mycolon(a, s, b)
    len_est = (b-a)/s + 1
    len_test = floor(Int, len_est+10*eps(len_est))
    len = a+(len_test-1)*s <= b ? len_test : len_test-1  # needs modification for s < 0
    StepRangeLen(a, s, len)
end

[StefanKarpinski]

I can't find the comment that links to – there's way too many. Which proposal fixes it?

[StefanKarpinski]

Why not this:

n = ceil(Int, (b-a)/s)
a + n*s <= b || (n -= 1)
StepRangeLen(a, s, n+1)

In case you haven't figured it out, I'm vehemently against arbitrary ulp fuzzing. Why is 10 the correct number of ulps?

[JeffBezanson]

For this case would it be enough to check whether adding 1 to the length exactly hits b, no eps needed?

[StefanKarpinski]

Agree – that's all that's needed, I think.

[timholy]

The problem comes if you've already committed to rational approximation of the inputs---at that point you may need some ulp fuzzing.

[timholy]

I don't disagree with your vehement distaste for arbitrary constants, however.

[StefanKarpinski]

If you've already committed to rational approximation, then you do that – that guarantees hitting the endpoint exactly or you would bail out. This is a slightly better way of picking the length in the case where rational lifting has already failed.

[timholy]

Yeah, you're probably right. Seems like it should work, and it would be a very simple tweak. Are you trying it, or should I?

[StefanKarpinski]

I'm trying it already. In other words, just this:

diff --git a/base/twiceprecision.jl b/base/twiceprecision.jl
index 80d1917ea..05c7d1153 100644
--- a/base/twiceprecision.jl
+++ b/base/twiceprecision.jl
@@ -149,6 +149,7 @@ function colon{T<:Union{Float16,Float32,Float64}}(start::T, step::T, stop::T)
         end
     end
     # Fallback, taking start and step literally
+    start + len*step <= stop && (len += 1)
     StepRangeLen(TwicePrecision(start, zero(T)), twiceprecision(step, nbitslen(T, len, 1)), len)
 end

Not sure where else I'd need to apply this, though.

[timholy]

That's probably it. I think the only other place with similar logic is for range and linspace, but there len is provided directly.

[StefanKarpinski]

I also just noticed that the definition of len at the top is dead code...

[timholy]

? If you're looking at the same function, here's a resetting of len later but you only get there if early steps of rational approximation succeed. It would be clearer if moved to the end, however, and might indeed avoid corner cases where the re-computation of len overflows...so that would be a strict improvement.