WIP: use bit twiddling instead of ldexp for IEEE floats

base/float.jl

@@ -148,6 +148,67 @@ signed integer, so that `abs(typemin(x)) == typemin(x) < 0`, in which case the r
 uabs(x::Integer) = abs(x)
 uabs(x::BitSigned) = unsigned(abs(x))
 
+function float_representation(
+    ::Type{F},
+    signbit::Bool, exponent_field::Integer, mantissa_field::Integer,
+) where {F<:IEEEFloat}
+    T = uinttype(F)
+    sign_and_exp = (T(signbit) << exponent_bits(F)) | T(exponent_field)
+    ret = (sign_and_exp << significand_bits(F)) | T(mantissa_field)
+    ret::T
+end
+
+float_representation_of_infinity(::Type{F}, signbit::Bool) where {F<:IEEEFloat} =
+    float_representation(F, signbit, exponent_raw_max(F), false)
+
+float_representation_of_zero(::Type{F}, signbit::Bool) where {F<:IEEEFloat} =
+    float_representation(F, signbit, false, false)
+
+function float_representation_from_components(
+    ::Type{F},
+    sign::Real, exp::Integer, mantissa::Integer,
+) where {F<:IEEEFloat}
+    T = uinttype(F)
+    sb = signbit(sign)
+
+    iszero(sign) && return float_representation_of_zero(F, sb)
+
+    normalized_exp = exp + significand_bits(F)
+
+    if exponent_max(F) < normalized_exp
+        # overflow (infinity)
+        float_representation_of_infinity(F, sb)
+    elseif normalized_exp < true - exponent_bias(F)
+        # underflow (subnormal or zero)
+        ed = true - exponent_bias(F) - normalized_exp
+        float_representation(F, sb, false, mantissa >> ed)
+    else
+        # normal: `true - exponent_bias(F) ≤ normalized_exp ≤ exponent_max(F)`
+        mantissa_field = T(mantissa) & significand_mask(F)  # clear the leading set bit
+        e = normalized_exp + exponent_bias(F)
+        float_representation(F, sb, e, mantissa_field)
+    end
+end
+
+float_from_components(
+    ::Type{F},
+    sign::Real, exp::Integer, mantissa::Integer,
+) where {F<:IEEEFloat} =
+    reinterpret(F, float_representation_from_components(F, sign, exp, mantissa))
+
+# The input parameters represent the number `sign * 2^exp * mantissa`,
+# let's call it `n`. The sign is expected to be an integer between `-1`
+# and `1`, and the mantissa is expected to be as wide as the mantissa
+# of the floating-point type `F`, not counting the leading bit. Let's
+# call the number `x`.
+#
+# Returns the same value as `ldexp(sign * F(mantissa), exp)`
+float_from_components(
+    ::Type{F},
+    sign::Real, exp::Integer, mantissa::Integer,
+) where {F<:AbstractFloat} =
+    ldexp(sign * F(mantissa), exp)
+
 ## conversions to floating-point ##
 
 # TODO: deprecate in 2.0

base/rational.jl

@@ -360,11 +360,10 @@ function rational_to_float_impl(
       T,
       RoundNearest,
     )
-    mantissa = to_float(components.mantissa)
-
-    # TODO: `ldexp` could be replaced with a mere bit of bit twiddling
-    # in the case of `Float16`, `Float32`, `Float64`
-    ret = ldexp(s * mantissa, components.exponent)
+    ret = float_from_components(
+        typeof(to_float(false)),
+        s, components.exponent, components.mantissa,
+    )
 
     # TODO: faster?
     if iszero(ret) | issubnormal(ret)
@@ -377,11 +376,10 @@ function rational_to_float_impl(
           T,
           RoundToZero,
         )
-        mantissa = to_float(components.mantissa | !components.is_exact)
-
-        # TODO: `ldexp` could be replaced with a mere bit of bit
-        # twiddling in the case of `Float16`, `Float32`, `Float64`
-        ret = ldexp(s * mantissa, components.exponent)
+        ret = float_from_components(
+            typeof(to_float(false)),
+            s, components.exponent, components.mantissa | !components.is_exact,
+        )
     end
 
     ret