{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE BangPatterns, MagicHash #-}
-- |
-- Module      : Data.ByteString.Builder.RealFloat.F2S
-- Copyright   : (c) Lawrence Wu 2021
-- License     : BSD-style
-- Maintainer  : lawrencejwu@gmail.com
--
-- Implementation of float-to-string conversion

module Data.ByteString.Builder.RealFloat.F2S
    ( FloatingDecimal(..)
    , f2s
    , f2Intermediate
    ) where

import Control.Arrow (first)
import Data.Bits ((.|.), (.&.), unsafeShiftL, unsafeShiftR)
import Data.ByteString.Builder.Internal (Builder)
import Data.ByteString.Builder.Prim (primBounded)
import Data.ByteString.Builder.RealFloat.Internal
import GHC.Int (Int32(..))
import GHC.Word (Word32(..), Word64(..))

-- See Data.ByteString.Builder.RealFloat.TableGenerator for a high-level
-- explanation of the ryu algorithm

-- | Table of 2^k / 5^q + 1
-- Byte-swapped version of
-- > fmap (finv float_pow5_inv_bitcount) [0..float_max_inv_split]
--
-- Displayed here as 2 Word64 table values per line
float_pow5_inv_split :: Addr
float_pow5_inv_split :: Addr
float_pow5_inv_split = Addr# -> Addr
Addr
  Addr#
"\x01\x00\x00\x00\x00\x00\x00\x08\x67\x66\x66\x66\x66\x66\x66\x06\
  \\xb9\x1e\x85\xeb\x51\xb8\x1e\x05\xfa\x7e\x6a\xbc\x74\x93\x18\x04\
  \\x2a\xcb\x10\xc7\xba\xb8\x8d\x06\x22\x3c\xda\x38\x62\x2d\x3e\x05\
  \\x4e\x63\x7b\x2d\xe8\xbd\x31\x04\x16\xd2\x2b\xaf\xa6\xfc\xb5\x06\
  \\x78\x0e\x23\x8c\xb8\x63\x5e\x05\x2d\xa5\xb5\x09\xfa\x82\x4b\x04\
  \\xae\x6e\xef\x75\xf6\x37\xdf\x06\x58\x25\x59\x5e\xf8\x5f\x7f\x05\
  \\x47\x84\x7a\x4b\x60\xe6\x65\x04\x71\xa0\x5d\x12\x9a\x70\x09\x07\
  \\xc1\xe6\x4a\xa8\xe1\x26\xa1\x05\x67\x85\xd5\xb9\xe7\xeb\x80\x04\
  \\x0b\x6f\x22\xf6\xa5\xac\x34\x07\xa3\x25\xb5\x91\x51\xbd\xc3\x05\
  \\xe9\xea\x90\x74\x74\x97\x9c\x04\x0e\xab\xb4\xed\x53\xf2\x60\x07\
  \\xd8\x88\x90\x24\x43\x28\xe7\x05\xe0\xd3\xa6\x83\x02\xed\xb8\x04\
  \\x66\xb9\xd7\x05\x04\x48\x8e\x07\x52\x94\xac\x04\xd0\x6c\x0b\x06\
  \\xdb\xa9\x23\x6a\xa6\xf0\xd5\x04\x2b\x76\x9f\x76\x3d\xb4\xbc\x07\
  \\xef\xc4\xb2\x2b\x31\x90\x30\x06\xf3\x03\x8f\xbc\x8d\xa6\xf3\x04\
  \\x51\x06\x18\x94\xaf\x3d\xec\x07\xda\xd1\xac\xa9\xbf\x97\x56\x06\
  \\xe2\xa7\xf0\xba\xff\x12\x12\x05"#

-- | Table of 5^(-e2-q) / 2^k + 1
-- Byte-swapped version of
-- > fmap (fnorm float_pow5_bitcount) [0..float_max_split]
--
-- Displayed here as 2 Word64 table values per line
float_pow5_split :: Addr
float_pow5_split :: Addr
float_pow5_split = Addr# -> Addr
Addr
  Addr#
"\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x14\
  \\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x40\x1f\
  \\x00\x00\x00\x00\x00\x00\x88\x13\x00\x00\x00\x00\x00\x00\x6a\x18\
  \\x00\x00\x00\x00\x00\x80\x84\x1e\x00\x00\x00\x00\x00\xd0\x12\x13\
  \\x00\x00\x00\x00\x00\x84\xd7\x17\x00\x00\x00\x00\x00\x65\xcd\x1d\
  \\x00\x00\x00\x00\x20\x5f\xa0\x12\x00\x00\x00\x00\xe8\x76\x48\x17\
  \\x00\x00\x00\x00\xa2\x94\x1a\x1d\x00\x00\x00\x40\xe5\x9c\x30\x12\
  \\x00\x00\x00\x90\x1e\xc4\xbc\x16\x00\x00\x00\x34\x26\xf5\x6b\x1c\
  \\x00\x00\x80\xe0\x37\x79\xc3\x11\x00\x00\xa0\xd8\x85\x57\x34\x16\
  \\x00\x00\xc8\x4e\x67\x6d\xc1\x1b\x00\x00\x3d\x91\x60\xe4\x58\x11\
  \\x00\x40\x8c\xb5\x78\x1d\xaf\x15\x00\x50\xef\xe2\xd6\xe4\x1a\x1b\
  \\x00\x92\xd5\x4d\x06\xcf\xf0\x10\x80\xf6\x4a\xe1\xc7\x02\x2d\x15\
  \\x20\xb4\x9d\xd9\x79\x43\x78\x1a\x94\x90\x02\x28\x2c\x2a\x8b\x10\
  \\xb9\x34\x03\x32\xb7\xf4\xad\x14\xe7\x01\x84\xfe\xe4\x71\xd9\x19\
  \\x30\x81\x12\x1f\x2f\xe7\x27\x10\x7c\x21\xd7\xe6\xfa\xe0\x31\x14\
  \\xdb\xe9\x8c\xa0\x39\x59\x3e\x19\x52\x24\xb0\x08\x88\xef\x8d\x1f\
  \\xb3\x16\x6e\x05\xb5\xb5\xb8\x13\x60\x9c\xc9\x46\x22\xe3\xa6\x18\
  \\x78\x03\x7c\xd8\xea\x9b\xd0\x1e\x2b\x82\x4d\xc7\x72\x61\x42\x13\
  \\xb6\xe2\x20\x79\xcf\xf9\x12\x18\x64\x1b\x69\x57\x43\xb8\x17\x1e\
  \\x1e\xb1\xa1\x16\x2a\xd3\xce\x12\x66\x1d\x4a\x9c\xf4\x87\x82\x17\
  \\xbf\xa4\x5c\xc3\xf1\x29\x63\x1d\xf7\xe6\x19\x1a\x37\xfa\x5d\x12\
  \\xb5\x60\xa0\xe0\xc4\x78\xf5\x16\xe3\x78\xc8\x18\xf6\xd6\xb2\x1c\
  \\x8d\x4b\x7d\xcf\x59\xc6\xef\x11\x71\x9e\x5c\x43\xf0\xb7\x6b\x16\
  \\x0d\xc6\x33\x54\xec\xa5\x06\x1c"#

-- | Number of mantissa bits of a 32-bit float. The number of significant bits
-- (floatDigits (undefined :: Float)) is 24 since we have a leading 1 for
-- normal floats and 0 for subnormal floats
float_mantissa_bits :: Int
float_mantissa_bits :: Int
float_mantissa_bits = Int
23

-- | Number of exponent bits of a 32-bit float
float_exponent_bits :: Int
float_exponent_bits :: Int
float_exponent_bits = Int
8

-- | Bias in encoded 32-bit float representation (2^7 - 1)
float_bias :: Int
float_bias :: Int
float_bias = Int
127

data FloatingDecimal = FloatingDecimal
  { FloatingDecimal -> Word32
fmantissa :: !Word32
  , FloatingDecimal -> Int32
fexponent :: !Int32
  } deriving (Int -> FloatingDecimal -> ShowS
[FloatingDecimal] -> ShowS
FloatingDecimal -> String
(Int -> FloatingDecimal -> ShowS)
-> (FloatingDecimal -> String)
-> ([FloatingDecimal] -> ShowS)
-> Show FloatingDecimal
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FloatingDecimal] -> ShowS
$cshowList :: [FloatingDecimal] -> ShowS
show :: FloatingDecimal -> String
$cshow :: FloatingDecimal -> String
showsPrec :: Int -> FloatingDecimal -> ShowS
$cshowsPrec :: Int -> FloatingDecimal -> ShowS
Show, FloatingDecimal -> FloatingDecimal -> Bool
(FloatingDecimal -> FloatingDecimal -> Bool)
-> (FloatingDecimal -> FloatingDecimal -> Bool)
-> Eq FloatingDecimal
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FloatingDecimal -> FloatingDecimal -> Bool
$c/= :: FloatingDecimal -> FloatingDecimal -> Bool
== :: FloatingDecimal -> FloatingDecimal -> Bool
$c== :: FloatingDecimal -> FloatingDecimal -> Bool
Eq)

-- | Multiply a 32-bit number with a 64-bit number while keeping the upper 64
-- bits. Then shift by specified amount minus 32
mulShift32 :: Word32 -> Word64 -> Int -> Word32
mulShift32 :: Word32 -> Word64 -> Int -> Word32
mulShift32 Word32
m Word64
factor Int
shift =
  let factorLo :: Word64
factorLo = Word64
factor Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.&. Int -> Word64
forall a. (Bits a, Integral a) => Int -> a
mask Int
32
      factorHi :: Word64
factorHi = Word64
factor Word64 -> Int -> Word64
forall a. Bits a => a -> Int -> a
`unsafeShiftR` Int
32
      bits0 :: Word64
bits0 = Word32 -> Word64
word32ToWord64 Word32
m Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
* Word64
factorLo
      bits1 :: Word64
bits1 = Word32 -> Word64
word32ToWord64 Word32
m Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
* Word64
factorHi
      total :: Word64
total  = (Word64
bits0 Word64 -> Int -> Word64
forall a. Bits a => a -> Int -> a
`unsafeShiftR` Int
32) Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
+ Word64
bits1
   in Word64 -> Word32
word64ToWord32 (Word64 -> Word32) -> Word64 -> Word32
forall a b. (a -> b) -> a -> b
$ Word64
total Word64 -> Int -> Word64
forall a. Bits a => a -> Int -> a
`unsafeShiftR` (Int
shift Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
32)

-- | Index into the 64-bit word lookup table float_pow5_inv_split
get_float_pow5_inv_split :: Int -> Word64
get_float_pow5_inv_split :: Int -> Word64
get_float_pow5_inv_split =
  let !(Addr Addr#
arr) = Addr
float_pow5_inv_split
   in Addr# -> Int -> Word64
getWord64At Addr#
arr

-- | Index into the 64-bit word lookup table float_pow5_split
get_float_pow5_split :: Int -> Word64
get_float_pow5_split :: Int -> Word64
get_float_pow5_split =
  let !(Addr Addr#
arr) = Addr
float_pow5_split
   in Addr# -> Int -> Word64
getWord64At Addr#
arr

-- | Take the high bits of m * 2^k / 5^q / 2^-e2+q+k
mulPow5InvDivPow2 :: Word32 -> Int -> Int -> Word32
mulPow5InvDivPow2 :: Word32 -> Int -> Int -> Word32
mulPow5InvDivPow2 Word32
m Int
q Int
j = Word32 -> Word64 -> Int -> Word32
mulShift32 Word32
m (Int -> Word64
get_float_pow5_inv_split Int
q) Int
j

-- | Take the high bits of m * 5^-e2-q / 2^k / 2^q-k
mulPow5DivPow2 :: Word32 -> Int -> Int -> Word32
mulPow5DivPow2 :: Word32 -> Int -> Int -> Word32
mulPow5DivPow2 Word32
m Int
i Int
j = Word32 -> Word64 -> Int -> Word32
mulShift32 Word32
m (Int -> Word64
get_float_pow5_split Int
i) Int
j

-- | Handle case e2 >= 0
f2dGT :: Int32 -> Word32 -> Word32 -> Word32 -> (BoundsState Word32, Int32)
f2dGT :: Int32 -> Word32 -> Word32 -> Word32 -> (BoundsState Word32, Int32)
f2dGT Int32
e2' Word32
u Word32
v Word32
w =
  let e2 :: Int
e2 = Int32 -> Int
int32ToInt Int32
e2'
      -- q = e10 = log_10(2^e2)
      q :: Int
q = Int -> Int
log10pow2 Int
e2
      -- k = B0 + log_2(5^q)
      k :: Int
k = Int
float_pow5_inv_bitcount Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int -> Int
pow5bits Int
q Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1
      i :: Int
i = -Int
e2 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
q Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
k
      -- (u, v, w) * 2^k / 5^q / 2^-e2+q+k
      u' :: Word32
u' = Word32 -> Int -> Int -> Word32
mulPow5InvDivPow2 Word32
u Int
q Int
i
      v' :: Word32
v' = Word32 -> Int -> Int -> Word32
mulPow5InvDivPow2 Word32
v Int
q Int
i
      w' :: Word32
w' = Word32 -> Int -> Int -> Word32
mulPow5InvDivPow2 Word32
w Int
q Int
i
      !lastRemoved :: Word32
lastRemoved =
        if Int
q Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= Int
0 Bool -> Bool -> Bool
&& Word32 -> Word32
fquot10 (Word32
w' Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
- Word32
1) Word32 -> Word32 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word32 -> Word32
fquot10 Word32
u'
          -- We need to know one removed digit even if we are not going to loop
          -- below. We could use q = X - 1 above, except that would require 33
          -- bits for the result, and we've found that 32-bit arithmetic is
          -- faster even on 64-bit machines.
          then let l :: Int
l = Int
float_pow5_inv_bitcount Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int -> Int
pow5bits (Int
q Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1
                in Word32 -> Word32
frem10 (Word32 -> Int -> Int -> Word32
mulPow5InvDivPow2 Word32
v (Int
q Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) (-Int
e2 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
q Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
l))
          else Word32
0
      !(Bool
vvTrailing, Bool
vuTrailing, Word32
vw') =
        case () of
          ()
_ | Int
q Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
9 Bool -> Bool -> Bool
&& Word32 -> Word32
frem5 Word32
v Word32 -> Word32 -> Bool
forall a. Eq a => a -> a -> Bool
== Word32
0
                -> (Word32 -> Int -> Bool
forall a. Mantissa a => a -> Int -> Bool
multipleOfPowerOf5 Word32
v Int
q, Bool
False, Word32
w')
            | Int
q Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
9 Bool -> Bool -> Bool
&& Word32 -> Bool
forall a. Mantissa a => a -> Bool
acceptBounds Word32
v
                -> (Bool
False, Word32 -> Int -> Bool
forall a. Mantissa a => a -> Int -> Bool
multipleOfPowerOf5 Word32
u Int
q, Word32
w')
            | Int
q Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
9
                -> (Bool
False, Bool
False, Word32
w' Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
- Bool -> Word32
boolToWord32 (Word32 -> Int -> Bool
forall a. Mantissa a => a -> Int -> Bool
multipleOfPowerOf5 Word32
w Int
q))
            | Bool
otherwise
                -> (Bool
False, Bool
False, Word32
w')
   in (Word32
-> Word32 -> Word32 -> Word32 -> Bool -> Bool -> BoundsState Word32
forall a. a -> a -> a -> a -> Bool -> Bool -> BoundsState a
BoundsState Word32
u' Word32
v' Word32
vw' Word32
lastRemoved Bool
vuTrailing Bool
vvTrailing, Int -> Int32
intToInt32 Int
q)

-- | Handle case e2 < 0
f2dLT :: Int32 -> Word32 -> Word32 -> Word32 -> (BoundsState Word32, Int32)
f2dLT :: Int32 -> Word32 -> Word32 -> Word32 -> (BoundsState Word32, Int32)
f2dLT Int32
e2' Word32
u Word32
v Word32
w =
  let e2 :: Int
e2 = Int32 -> Int
int32ToInt Int32
e2'
      q :: Int
q = Int -> Int
log10pow5 (-Int
e2)
      e10 :: Int
e10 = Int
q Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
e2
      i :: Int
i = (-Int
e2) Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
q
      -- k = log_2(5^-e2-q) - B1
      k :: Int
k = Int -> Int
pow5bits Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
float_pow5_bitcount
      j :: Int
j = Int
q Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
k
      -- (u, v, w) * 5^-e2-q / 2^k / 2^q-k
      u' :: Word32
u' = Word32 -> Int -> Int -> Word32
mulPow5DivPow2 Word32
u Int
i Int
j
      v' :: Word32
v' = Word32 -> Int -> Int -> Word32
mulPow5DivPow2 Word32
v Int
i Int
j
      w' :: Word32
w' = Word32 -> Int -> Int -> Word32
mulPow5DivPow2 Word32
w Int
i Int
j
      !lastRemoved :: Word32
lastRemoved =
        if Int
q Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= Int
0 Bool -> Bool -> Bool
&& Word32 -> Word32
fquot10 (Word32
w' Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
- Word32
1) Word32 -> Word32 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word32 -> Word32
fquot10 Word32
u'
          then let j' :: Int
j' = Int
q Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1 Int -> Int -> Int
forall a. Num a => a -> a -> a
- (Int -> Int
pow5bits (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
float_pow5_bitcount)
                in Word32 -> Word32
frem10 (Word32 -> Int -> Int -> Word32
mulPow5DivPow2 Word32
v (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) Int
j')
          else Word32
0
      !(Bool
vvTrailing , Bool
vuTrailing, Word32
vw') =
        case () of
          ()
_ | Int
q Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
1 Bool -> Bool -> Bool
&& Word32 -> Bool
forall a. Mantissa a => a -> Bool
acceptBounds Word32
v
                -> (Bool
True, Word32
v Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
- Word32
u Word32 -> Word32 -> Bool
forall a. Eq a => a -> a -> Bool
== Word32
2, Word32
w') -- mmShift == 1
            | Int
q Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
1
                -> (Bool
True, Bool
False, Word32
w' Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
- Word32
1)
            | Int
q Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
31
                -> (Word32 -> Int -> Bool
forall a. Mantissa a => a -> Int -> Bool
multipleOfPowerOf2 Word32
v (Int
q Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1), Bool
False, Word32
w')
            | Bool
otherwise
                -> (Bool
False, Bool
False, Word32
w')
   in (Word32
-> Word32 -> Word32 -> Word32 -> Bool -> Bool -> BoundsState Word32
forall a. a -> a -> a -> a -> Bool -> Bool -> BoundsState a
BoundsState Word32
u' Word32
v' Word32
vw' Word32
lastRemoved Bool
vuTrailing Bool
vvTrailing, Int -> Int32
intToInt32 Int
e10)

-- | Returns the decimal representation of the given mantissa and exponent of a
-- 32-bit Float using the ryu algorithm.
f2d :: Word32 -> Word32 -> FloatingDecimal
f2d :: Word32 -> Word32 -> FloatingDecimal
f2d Word32
m Word32
e =
  let !mf :: Word32
mf = if Word32
e Word32 -> Word32 -> Bool
forall a. Eq a => a -> a -> Bool
== Word32
0
              then Word32
m
              else (Word32
1 Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`unsafeShiftL` Int
float_mantissa_bits) Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
m
      !ef :: Int32
ef = Int -> Int32
intToInt32 (Int -> Int32) -> Int -> Int32
forall a b. (a -> b) -> a -> b
$ if Word32
e Word32 -> Word32 -> Bool
forall a. Eq a => a -> a -> Bool
== Word32
0
              then Int
1 Int -> Int -> Int
forall a. Num a => a -> a -> a
- (Int
float_bias Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
float_mantissa_bits)
              else Word32 -> Int
word32ToInt Word32
e Int -> Int -> Int
forall a. Num a => a -> a -> a
- (Int
float_bias Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
float_mantissa_bits)
      !e2 :: Int32
e2 = Int32
ef Int32 -> Int32 -> Int32
forall a. Num a => a -> a -> a
- Int32
2
      -- Step 2. 3-tuple (u, v, w) * 2**e2
      !u :: Word32
u = Word32
4 Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
* Word32
mf Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
- Word32
1 Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
- Bool -> Word32
boolToWord32 (Word32
m Word32 -> Word32 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word32
0 Bool -> Bool -> Bool
|| Word32
e Word32 -> Word32 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word32
1)
      !v :: Word32
v = Word32
4 Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
* Word32
mf
      !w :: Word32
w = Word32
4 Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
* Word32
mf Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
+ Word32
2
      -- Step 3. convert to decimal power base
      !(BoundsState Word32
state, Int32
e10) =
        if Int32
e2 Int32 -> Int32 -> Bool
forall a. Ord a => a -> a -> Bool
>= Int32
0
           then Int32 -> Word32 -> Word32 -> Word32 -> (BoundsState Word32, Int32)
f2dGT Int32
e2 Word32
u Word32
v Word32
w
           else Int32 -> Word32 -> Word32 -> Word32 -> (BoundsState Word32, Int32)
f2dLT Int32
e2 Word32
u Word32
v Word32
w
      -- Step 4: Find the shortest decimal representation in the interval of
      -- valid representations.
      !(Word32
output, Int32
removed) =
        let rounded :: BoundsState Word32 -> Word32
rounded = Bool -> BoundsState Word32 -> Word32
forall a. Mantissa a => Bool -> BoundsState a -> a
closestCorrectlyRounded (Word32 -> Bool
forall a. Mantissa a => a -> Bool
acceptBounds Word32
v)
         in (BoundsState Word32 -> Word32)
-> (BoundsState Word32, Int32) -> (Word32, Int32)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (b, d) (c, d)
first BoundsState Word32 -> Word32
rounded ((BoundsState Word32, Int32) -> (Word32, Int32))
-> (BoundsState Word32, Int32) -> (Word32, Int32)
forall a b. (a -> b) -> a -> b
$ if BoundsState Word32 -> Bool
forall a. BoundsState a -> Bool
vvIsTrailingZeros BoundsState Word32
state Bool -> Bool -> Bool
|| BoundsState Word32 -> Bool
forall a. BoundsState a -> Bool
vuIsTrailingZeros BoundsState Word32
state
           then BoundsState Word32 -> (BoundsState Word32, Int32)
forall a.
(Show a, Mantissa a) =>
BoundsState a -> (BoundsState a, Int32)
trimTrailing BoundsState Word32
state
           else BoundsState Word32 -> (BoundsState Word32, Int32)
forall a. Mantissa a => BoundsState a -> (BoundsState a, Int32)
trimNoTrailing BoundsState Word32
state
      !e' :: Int32
e' = Int32
e10 Int32 -> Int32 -> Int32
forall a. Num a => a -> a -> a
+ Int32
removed
   in Word32 -> Int32 -> FloatingDecimal
FloatingDecimal Word32
output Int32
e'

-- | Split a Float into (sign, mantissa, exponent)
breakdown :: Float -> (Bool, Word32, Word32)
breakdown :: Float -> (Bool, Word32, Word32)
breakdown Float
f =
  let bits :: Word32
bits = Float -> Word32
castFloatToWord32 Float
f
      sign :: Bool
sign = ((Word32
bits Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`unsafeShiftR` (Int
float_mantissa_bits Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
float_exponent_bits)) Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.&. Word32
1) Word32 -> Word32 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word32
0
      mantissa :: Word32
mantissa = Word32
bits Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.&. Int -> Word32
forall a. (Bits a, Integral a) => Int -> a
mask Int
float_mantissa_bits
      expo :: Word32
expo = (Word32
bits Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`unsafeShiftR` Int
float_mantissa_bits) Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.&. Int -> Word32
forall a. (Bits a, Integral a) => Int -> a
mask Int
float_exponent_bits
   in (Bool
sign, Word32
mantissa, Word32
expo)

-- | Dispatches to `f2d` and applies the given formatters
{-# INLINE f2s' #-}
f2s' :: (Bool -> Word32 -> Int32 -> a) -> (NonNumbersAndZero -> a) -> Float -> a
f2s' :: forall a.
(Bool -> Word32 -> Int32 -> a)
-> (NonNumbersAndZero -> a) -> Float -> a
f2s' Bool -> Word32 -> Int32 -> a
formatter NonNumbersAndZero -> a
specialFormatter Float
f =
  let (Bool
sign, Word32
mantissa, Word32
expo) = Float -> (Bool, Word32, Word32)
breakdown Float
f
   in if (Word32
expo Word32 -> Word32 -> Bool
forall a. Eq a => a -> a -> Bool
== Int -> Word32
forall a. (Bits a, Integral a) => Int -> a
mask Int
float_exponent_bits) Bool -> Bool -> Bool
|| (Word32
expo Word32 -> Word32 -> Bool
forall a. Eq a => a -> a -> Bool
== Word32
0 Bool -> Bool -> Bool
&& Word32
mantissa Word32 -> Word32 -> Bool
forall a. Eq a => a -> a -> Bool
== Word32
0)
         then NonNumbersAndZero -> a
specialFormatter NonNumbersAndZero
                  { negative :: Bool
negative=Bool
sign
                  , exponent_all_one :: Bool
exponent_all_one=Word32
expo Word32 -> Word32 -> Bool
forall a. Ord a => a -> a -> Bool
> Word32
0
                  , mantissa_non_zero :: Bool
mantissa_non_zero=Word32
mantissa Word32 -> Word32 -> Bool
forall a. Ord a => a -> a -> Bool
> Word32
0 }
         else let FloatingDecimal Word32
m Int32
e = Word32 -> Word32 -> FloatingDecimal
f2d Word32
mantissa Word32
expo
               in Bool -> Word32 -> Int32 -> a
formatter Bool
sign Word32
m Int32
e

-- | Render a Float in scientific notation
f2s :: Float -> Builder
f2s :: Float -> Builder
f2s Float
f = BoundedPrim () -> () -> Builder
forall a. BoundedPrim a -> a -> Builder
primBounded ((Bool -> Word32 -> Int32 -> BoundedPrim ())
-> (NonNumbersAndZero -> BoundedPrim ()) -> Float -> BoundedPrim ()
forall a.
(Bool -> Word32 -> Int32 -> a)
-> (NonNumbersAndZero -> a) -> Float -> a
f2s' Bool -> Word32 -> Int32 -> BoundedPrim ()
forall a. Mantissa a => Bool -> a -> Int32 -> BoundedPrim ()
toCharsScientific NonNumbersAndZero -> BoundedPrim ()
toCharsNonNumbersAndZero Float
f) ()

-- | Returns the decimal representation of a Float. NaN and Infinity will
-- return `FloatingDecimal 0 0`
f2Intermediate :: Float -> FloatingDecimal
f2Intermediate :: Float -> FloatingDecimal
f2Intermediate = (Bool -> Word32 -> Int32 -> FloatingDecimal)
-> (NonNumbersAndZero -> FloatingDecimal)
-> Float
-> FloatingDecimal
forall a.
(Bool -> Word32 -> Int32 -> a)
-> (NonNumbersAndZero -> a) -> Float -> a
f2s' ((Word32 -> Int32 -> FloatingDecimal)
-> Bool -> Word32 -> Int32 -> FloatingDecimal
forall a b. a -> b -> a
const Word32 -> Int32 -> FloatingDecimal
FloatingDecimal) (FloatingDecimal -> NonNumbersAndZero -> FloatingDecimal
forall a b. a -> b -> a
const (FloatingDecimal -> NonNumbersAndZero -> FloatingDecimal)
-> FloatingDecimal -> NonNumbersAndZero -> FloatingDecimal
forall a b. (a -> b) -> a -> b
$ Word32 -> Int32 -> FloatingDecimal
FloatingDecimal Word32
0 Int32
0)