Missing edge case when converting Float to UInt

[mchristianl]

Hi,

I found some strange behavior hat might be a missing edge case when converting typemax(UInt64) from-and-to Float64.

In the following code, the neighbouring numbers of Float64(typemax(UInt64)) are converted to UInt64 again. The bigger such neighbours throw an InexactError, where the smaller ones perform the conversion.

But UInt64(Float64(typemax(UInt64))) (case b2 below) does something strange

a2 = typemax(UInt64) # 0xffffffffffffffff

f1 =                     nextfloat(Float64(a2))   # 1.8446744073709556e19
f2 =                               Float64(a2)    # 1.8446744073709552e19
f3 =                     prevfloat(Float64(a2))   # 1.8446744073709550e19
f4 =           prevfloat(prevfloat(Float64(a2)))  # 1.8446744073709548e19
f5 = prevfloat(prevfloat(prevfloat(Float64(a2)))) # 1.8446744073709545e19
                                                  # ...

b1 = UInt64(f1) #       InexactError ✓
b2 = UInt64(f2) # 0x8000000000000000 ↯↯↯
b3 = UInt64(f3) # 0xfffffffffffff800 ✓
b4 = UInt64(f4) # 0xfffffffffffff000 ✓
b5 = UInt64(f5) # 0xffffffffffffe800 ✓
                # ...

there is a similar issue with Float32

a2 = typemax(UInt32) # 0xffffffff

f1 =                     nextfloat(Float32(a2))   # 4.2949680f9
f2 =                               Float32(a2)    # 4.2949673f9
f3 =                     prevfloat(Float32(a2))   # 4.2949670f9
f4 =           prevfloat(prevfloat(Float32(a2)))  # 4.2949668f9
f5 = prevfloat(prevfloat(prevfloat(Float32(a2)))) # 4.2949665f9
                                                  # ...

b1 = UInt32(f1) # InexactError ✓
b2 = UInt32(f2) #  0x00000000 ↯↯↯
b3 = UInt32(f3) #  0xffffff00 ✓
b4 = UInt32(f4) #  0xfffffe00 ✓
b5 = UInt32(f5) #  0xfffffd00 ✓
                # ...

and a bit worse situation with Float16

a2 = typemax(UInt16) # 0xffff

f1 =                     nextfloat(Float16(a2))   #           Inf16 ☝️🧐
f2 =                               Float16(a2)    #           Inf16 ☝️🧐
f3 =                     prevfloat(Float16(a2))   # Float16(6.550e4)
f4 =           prevfloat(prevfloat(Float16(a2)))  # Float16(6.547e4)
f5 = prevfloat(prevfloat(prevfloat(Float16(a2)))) # Float16(6.544e4)
                                                  # ...

b1 = UInt16(f1) # 0x0000 ↯↯↯
b2 = UInt16(f2) # 0x0000 ↯↯↯
b3 = UInt16(f3) # 0xffe0 ✓
b4 = UInt16(f4) # 0xffc0 ✓
b5 = UInt16(f5) # 0xffa0 ✓
                # ...

Is this intended, or just on my system? I would expect the ↯↯↯-cases to throw an inexact error.

Julia Version 1.7.1
Commit ac5cc99908* (2021-12-22 19:35 UTC)
Platform Info:
  OS: Linux (x86_64-pc-linux-gnu)
  CPU: Intel(R) Core(TM) i7-8550U CPU @ 1.80GHz
  WORD_SIZE: 64
  LIBM: libopenlibm
  LLVM: libLLVM-13.0.0 (ORCJIT, skylake)
Environment:
  JULIA_LOAD_PATH = /usr/share/gmsh/api/julia/:
  JULIA_EDITOR = code
  JULIA_NUM_THREADS = 4

[N5N3]

Seems the check before trunc is incorrect in this case:

julia/base/float.jl

Lines 757 to 763 in 4e83cce

	function (::Type{$Ti})(x::$Tf)
	if ($(Tf(typemin(Ti))) <= x <= $(Tf(typemax(Ti)))) && (round(x, RoundToZero) == x)
	return unsafe_trunc($Ti,x)
	else
	throw(InexactError($(Expr(:quote,Ti.name.name)), $Ti, x))
	end
	end

julia> typemax(UInt) |> Float64 |> BigInt
18446744073709551616

julia> typemax(UInt) |> BigInt
18446744073709551615

The easiest fix is removing the conversion in L758, as the direct comparasion is correct.

[JeffBezanson]

b2 = UInt64(f2) # 0x8000000000000000 ↯↯↯

That's interesting; I get typemax(UInt64) as the answer here, which is also wrong since it should be an error, but I wonder why it's different.

[mchristianl]

There are two issues from FixedPointNumbers.jl that might be about a related finding:

• Overflow in N63f1(Float64(typemax(N63f1))) and so on JuliaMath/FixedPointNumbers.jl#200 (comment)
• MSB may be cleared in conversion from BigFloat on ARM JuliaMath/FixedPointNumbers.jl#202

Julia it is calling

Base.fptoui(UInt64,typemax(UInt64)) # 0x8000000000000000

where for example in C

#include <stdio.h>
#include <stdint.h>
// gcc -o floatTest floatTest.c && ./floatTest

int main(){
  uint64_t a      = UINT64_MAX;
  double   f      = (double)a;
  uint64_t b      = (uint64_t)f;

  printf("64bit\n");
  printf("  a      = %lx\n", a);
  printf("  f      = %e\n", f);
  printf("  b      = %lx\n", b);

  return 0;
}

I get 0x0... instead of 0x8...

64bit
  a      = ffffffffffffffff
  f      = 1.844674e+19
  b      = 0

[vtjnash]

The value is b is undefined behavior in C, since it overflowed. Nearly true also in Julia for fptoui, but we limit the UB to not also cause program UB, and then try to convert it to an error for convert.

[mikmoore]

Related:

julia> versioninfo()
Julia Version 1.10.0
Commit 3120989f39b (2023-12-25 18:01 UTC)
Build Info:
  Official https://julialang.org/ release
Platform Info:
  OS: Linux (x86_64-linux-gnu)
  CPU: 12 × Intel(R) Core(TM) i7-9850H CPU @ 2.60GHz
  WORD_SIZE: 64
  LIBM: libopenlibm
  LLVM: libLLVM-15.0.7 (ORCJIT, skylake)
  Threads: 1 on 12 virtual cores

julia> UInt16(2f0^16) # okay
ERROR: InexactError: UInt16(65536.0)

julia> UInt16(2e0^16) # okay
ERROR: InexactError: UInt16(65536.0)

julia> UInt32(2f0^32) # WRONG
0x00000000 # == 0

julia> UInt32(2e0^32) # okay
ERROR: InexactError: UInt32(4.294967296e9)

julia> UInt64(2f0^64) # WRONG
0x8000000000000000 # == 2^63

julia> UInt64(2e0^64) # WRONG
0x8000000000000000 # == 2^63

So UInt32(2f0^32), UInt64(2f0^64), UInt64(2e0^64) are silently wrong. It appears that N5N3's proposed fix above would resolve this.

[inkydragon]

Related issue #51063

Test on master (1.11.0-DEV.1340, Commit fb2d946* (2024-01-19 15:22 UTC))
Everything work fine.
Maybe #51095 need a backport? cc: @LilithHafner

using Test

a2 = typemax(UInt64); # 0xffffffffffffffff
f1 =    nextfloat(Float64(a2));  # 1.8446744073709556e19
f2 =              Float64(a2);   # 1.8446744073709552e19
f3 =    prevfloat(Float64(a2));  # 1.8446744073709550e19

@test_throws InexactError UInt64(f1)    #   InexactError ✓
@test_throws InexactError UInt64(f2)    # 0x8000000000000000 ↯↯↯
@test 0xfffffffffffff800 == UInt64(f3)  # 0xfffffffffffff800 ✓

a2 = typemax(UInt32); # 0xffffffff
f1 =    nextfloat(Float32(a2));  # 4.2949680f9
f2 =              Float32(a2);   # 4.2949673f9
f3 =    prevfloat(Float32(a2));  # 4.2949670f9

@test_throws InexactError UInt32(f1) # InexactError ✓
@test_throws InexactError UInt32(f2) #  0x00000000 ↯↯↯
@test 0xffffff00 == UInt32(f3)       #  0xffffff00 ✓

a2 = typemax(UInt16); # 0xffff
f1 =    nextfloat(Float16(a2));  # Inf16
f2 =              Float16(a2);   # Inf16
f3 =    prevfloat(Float16(a2));  # Float16(6.550e4)

@test_throws InexactError UInt16(f1)    # 0x0000 ↯↯↯
@test_throws InexactError UInt16(f2)    # 0x0000 ↯↯↯
@test 0xffe0 == UInt16(f3)              # 0xffe0 ✓

@test_throws InexactError UInt16(2f0^16) # okay
@test_throws InexactError UInt16(2e0^16) # okay
@test_throws InexactError UInt16(65536.0)
@test_throws InexactError UInt32(2f0^32) # WRONG

@test_throws InexactError UInt32(2e0^32) # okay
@test_throws InexactError UInt64(2f0^64) # WRONG
@test_throws InexactError UInt64(2e0^64) # WRONG

full julia repl log

$ ./julia.bat
               _
   _       _ _(_)_     |  Documentation: https://docs.julialang.org
  (_)     | (_) (_)    |
   _ _   _| |_  __ _   |  Type "?" for help, "]?" for Pkg help.
  | | | | | | |/ _` |  |
  | | |_| | | | (_| |  |  Version 1.11.0-DEV.1340 (2024-01-19)
 _/ |\__'_|_|_|\__'_|  |  Commit fb2d946b88* (0 days old master)
|__/                   |

julia> versioninfo()
Julia Version 1.11.0-DEV.1340
Commit fb2d946b88* (2024-01-19 15:22 UTC)
Platform Info:
  OS: Windows (x86_64-w64-mingw32)
  CPU: 32 × 13th Gen Intel(R) Core(TM) i9-13900HX
  WORD_SIZE: 64
  LLVM: libLLVM-16.0.6 (ORCJIT, alderlake)
Threads: 1 default, 0 interactive, 1 GC (on 32 virtual cores)

julia> using Test

julia> a2 = typemax(UInt64); # 0xffffffffffffffff
julia> f1 =    nextfloat(Float64(a2));  # 1.8446744073709556e19
julia> f2 =              Float64(a2);   # 1.8446744073709552e19
julia> f3 =    prevfloat(Float64(a2));  # 1.8446744073709550e19

julia> @test_throws InexactError UInt64(f1)    #   InexactError ✓
Test Passed
      Thrown: InexactError

julia> @test_throws InexactError UInt64(f2)    # 0x8000000000000000 ↯↯↯
Test Passed
      Thrown: InexactError

julia> @test 0xfffffffffffff800 == UInt64(f3)  # 0xfffffffffffff800 ✓
Test Passed

julia>

julia> a2 = typemax(UInt32); # 0xffffffff
julia> f1 =    nextfloat(Float32(a2));  # 4.2949680f9
julia> f2 =              Float32(a2);   # 4.2949673f9
julia> f3 =    prevfloat(Float32(a2));  # 4.2949670f9

julia> @test_throws InexactError UInt32(f1) # InexactError ✓
Test Passed
      Thrown: InexactError

julia> @test_throws InexactError UInt32(f2) #  0x00000000 ↯↯↯
Test Passed
      Thrown: InexactError

julia> @test 0xffffff00 == UInt32(f3)       #  0xffffff00 ✓
Test Passed

julia>

julia> a2 = typemax(UInt16); # 0xffff
julia> f1 =    nextfloat(Float16(a2));  # Inf16
julia> f2 =              Float16(a2);   # Inf16
julia> f3 =    prevfloat(Float16(a2));  # Float16(6.550e4)

julia> @test_throws InexactError UInt16(f1)    # 0x0000 ↯↯↯
Test Passed
      Thrown: InexactError

julia> @test_throws InexactError UInt16(f2)    # 0x0000 ↯↯↯
Test Passed
      Thrown: InexactError

julia> @test 0xffe0 == UInt16(f3)              # 0xffe0 ✓
Test Passed

julia>

julia>

julia> @test_throws InexactError UInt16(2f0^16) # okay
Test Passed
      Thrown: InexactError

julia> @test_throws InexactError UInt16(2e0^16) # okay
Test Passed
      Thrown: InexactError

julia> @test_throws InexactError UInt16(65536.0)
Test Passed
      Thrown: InexactError

julia> @test_throws InexactError UInt32(2f0^32) # WRONG
Test Passed
      Thrown: InexactError

julia>

julia> @test_throws InexactError UInt32(2e0^32) # okay
Test Passed
      Thrown: InexactError

julia> @test_throws InexactError UInt64(2f0^64) # WRONG
Test Passed
      Thrown: InexactError

julia> @test_throws InexactError UInt64(2e0^64) # WRONG
Test Passed
      Thrown: InexactError

[LilithHafner]

Lovely! #51095 is an easily backported 1loc source change. I've tagged it for backport to 1.10