better operator definitions for largest unsigned integer

[JeffBezanson]

Currently we get:

julia> div(typemax(Uint64),1)
-1
julia> div(typemax(Uint64),2)
0
julia> typemax(Uint64)-1
-2

For these cases it would probably be better to give the right answer if representable and an error otherwise.
I believe the only problematic cases involve combining Uint64 with signed integers.

[StefanKarpinski]

Maybe we should more generally treat unsigned integers as slightly less arithmetic types than signed integers. They really have limited applicability, so it seems acceptable to limit their functionality somewhat.

[JeffBezanson]

LLVM has +, -, and * that can detect overflow efficiently.

[StefanKarpinski]

Oh, that's pretty awesome. Should we throw an error on overflow then?

[JeffBezanson]

We need to decide whether the promotion type should switch to Uint64 or stay as Int64, then add logic to give an error if the result would not be representable. Unfortunately I don't think this is the same as detecting overflow. If n = uint64(typemax(Int64))+uint64(2) then n-1 is not representable as Int64 but n-2 is, even though n-2 causes overflow and n-1 does not. At least some kind of additional logic is needed.

Comparisons also need a new approach. >(x::Uint64,y::Int) should first return true if y is negative, etc.

[StefanKarpinski]

I feel like we should punt on this for v1.0, although of course this isn't marked as a v1.0 issue.

[JeffBezanson]

Yeah, posting "wrong answers" like the ones I wrote always seems scary, but the fact is we always get the right answer as long as the Uint64s involved are <= typemax(Int64), which is certainly the common case by far.

[JeffBezanson]

Commit 2175a8b made these operations promote to Uint64, which fixes the examples listed here. Commit 6b7ede3 fixed comparisons with Uint64. So I think we're OK now.

[timholy]

Here's something a little strange:
julia> x = convert(Uint8,2)
0x02

julia> -x
0xfffffffe

julia> x = zeros(Uint8,5)
[0x00, 0x00, 0x00, 0x00, 0x00]

julia> for i = 1:5; x[i] = i-1; end

julia> -x
[0x00, 0xff, 0xfe, 0xfd, 0xfc]

Note that a scalar gets promoted to Uint64, while the vector of Uint8 does not.

[StefanKarpinski]

Actually the promotion happens both times, but it gets converted to Uint8 when you assign into the Uint8 array. This behavior was the end-result of many experiments and discussions. The basic idea is that going through "large" types like Int and Uint and then converting at the end to whatever storage type you want almost always gives you the right answer in the end. This works really nicely for signed arithmetic but can be a little weirder for unsigned.

[timholy]

OK, thanks. Just thought I'd bring it to your attention in case it was a
surprise.

--Tim