Always false float comparisons

[Ola Fosheim Grøstad via Digitalmars-d]

On Monday, 16 May 2016 at 15:11:21 UTC, Daniel Murphy wrote:
> On 16/05/2016 10:37 PM, Walter Bright wrote:
>> Some counter points:
>>
>> 1. Go uses 256 bit soft float for constant folding.
>>
>
> Then we should use 257 bit soft float!

Go uses at least 288 bits!!!!! (256 bits mantissa and 32 bits 
exponent).

But Go has a completely different take on constant expressions, 
and much better than the C family that D belongs to (but still 
far from ideal). From https://golang.org/ref/spec:

«
Numeric constants represent exact values of arbitrary precision 
and do not overflow. Consequently, there are no constants 
denoting the IEEE-754 negative zero, infinity, and not-a-number 
values.

Constants may be typed or untyped. Literal constants, true, 
false, iota, and certain constant expressions containing only 
untyped constant operands are untyped.

A constant may be given a type explicitly by a constant 
declaration or conversion, or implicitly when used in a variable 
declaration or an assignment or as an operand in an expression. 
It is an error if the constant value cannot be represented as a 
value of the respective type. For instance, 3.0 can be given any 
integer or any floating-point type, while 2147483648.0 (equal to 
1<<31) can be given the types float32, float64, or uint32 but not 
int32 or string.

An untyped constant has a default type which is the type to which 
the constant is implicitly converted in contexts where a typed 
value is required, for instance, in a short variable declaration 
such as i := 0 where there is no explicit type. The default type 
of an untyped constant is bool, rune, int, float64, complex128 or 
string respectively, depending on whether it is a boolean, rune, 
integer, floating-point, complex, or string constant.

Implementation restriction: Although numeric constants have 
arbitrary precision in the language, a compiler may implement 
them using an internal representation with limited precision. 
That said, every implementation must:

Represent integer constants with at least 256 bits.
Represent floating-point constants, including the parts of a 
complex constant, with a mantissa of at least 256 bits and a 
signed exponent of at least 32 bits.
Give an error if unable to represent an integer constant 
precisely.
Give an error if unable to represent a floating-point or complex 
constant due to overflow.
Round to the nearest representable constant if unable to 
represent a floating-point or complex constant due to limits on 
precision.
These requirements apply both to literal constants and to the 
result of evaluating constant expressions.
»

See also https://golang.org/ref/spec#Constant_expressions