Loss of precision in Integer -> Float autocast

[beta-ziliani]

When adding number autocast for 1.3.0, one key aspect of the design was to preserve the precision of numbers. That's why it's possible to cast an Int32 to a Float64, but not to Float32. However, literal autocasting might lose precision:

a : Float32 = 0
a = 33554435_i32
p a # prints 33554436.0

Probably the easiest fix it to see if for FloatN the literal integer fits in an (U)Int(N/2) or, better still, check the mantissa of the type, and raise an appropriate compilation error message.

[yxhuvud]

That could detect the error but what should the action taken be? Compilation error?

[beta-ziliani]

Thanks @yxhuvud , I updated the issue.

[straight-shoota]

Yes, I think this should be a compilation error. If you don't care about integer precision, you wouldn't use an integer literal.

We should also consider Float32 to Float64 autocasting.

Float64's range is much bigger as well. Literals outside of Float32's range silently turn up as Infinity. That should certainly be a compiler error instead.

x : Float32
x = 1.7976931348623157e+308 # => Infinity

Additionally, Float64 has higher precision than Float32. The problem with floating point literals is that they are almost always losing precision.

0.99999999_f32 # => 1.0
0.99999999_f64 # => 0.99999999
0.99999999999999999_f64 # => 1.0

So it's clear that a float literal is never really precise. Even that precise looking 0.99999999 is not that exact decimal value, it's just very close to it.
Still, when using a literal explicitly typed as Float64, the expectation is to represent a floating point value with 64-bit precision. Not 32-bits. So I think an explicit Float64 literal should never autocast to Float32.

[straight-shoota]

I realized the range problem isn't specific to autocasting, it also shows with regular literals:

1.7976931348623157e+308_f32 # => Infinity

[HertzDevil]

Integer-to-float autocasting can also produce infinities for UInt128 to Float32:

def foo(x : Float32)
  x
end

foo 1_u128                                     # => 1.0
foo 0xFFFFFF00_00000000_00000000_00000000_u128 # => 3.4028235e+38
foo 0xFFFFFF7F_FFFFFFFF_FFFFFFFF_FFFFFFFF_u128 # => 3.4028235e+38
foo 0xFFFFFF80_00000000_00000000_00000000_u128 # => Infinity
foo 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_u128 # => Infinity