{-# LANGUAGE DefaultSignatures, InstanceSigs, MagicHash, MultiParamTypeClasses,
             TypeFamilies, TypeOperators #-}

-- |
-- Module      : Data.Double.Conversion.Convertable
-- Copyright   : (c) 2011 MailRank, Inc.
--
-- License     : BSD-style
-- Maintainer  : bos@serpentine.com
-- Stability   : experimental
-- Portability : GHC

module Data.Double.Conversion.Convertable
    ( Convertable(..)
    ) where
import Data.ByteString.Builder.Prim (primBounded)
import Data.Text (Text)

import Data.Double.Conversion.Internal.FFI
import Data.String (IsString)

import qualified Data.ByteString.Builder as BB (Builder)
import qualified Data.ByteString.Internal as B (ByteString(..))
import qualified Data.Double.Conversion.Internal.ByteString as CB (convert)
import qualified Data.Double.Conversion.Internal.ByteStringBuilder as CBB (convert)
import qualified Data.Double.Conversion.Internal.Text as CT (convert)
import qualified Data.Double.Conversion.Internal.TextBuilder as CTB (convert)
import qualified Data.Text.Internal.Builder as T (Builder)

-- | Type class for floating data types, that can be converted, using double-conversion library
--
-- Default instanced convert input to Double and then make Bytestring Builder from it.
--
-- list of functions :
--
-- toExponential:
-- Compute a representation in exponential format with the requested
-- number of digits after the decimal point. The last emitted digit is
-- rounded.  If -1 digits are requested, then the shortest exponential
-- representation is computed.
--
-- toPrecision:
-- Compute @precision@ leading digits of the given value either in
-- exponential or decimal format. The last computed digit is rounded.
--
-- toFixed:
-- Compute a decimal representation with a fixed number of digits
-- after the decimal point. The last emitted digit is rounded.
--
-- toShortest:
-- Compute the shortest string of digits that correctly represent
-- the input number.
--
-- Conversion to text via Builder (both in the in case of bytestring and text) in case of single number
-- is a bit slower, than to text or bytestring directly.
-- But conversion a large amount of numbers to text via Builder (for example using foldr) is much faster than direct conversion to Text (up to 10-15x).
--
-- The same works for bytestrings: conversion, for example, a list of 20000 doubles to bytestring builder 
-- and then to bytestring is about 13 times faster than direct conversion of this list to bytestring. 
--
-- Conversion to text via text builder is a little bit slower, than conversion to bytestring via bytestring builder. 


class (RealFloat a, IsString b) => Convertable a b where
  toExponential :: Int -> a -> b
  default toExponential :: (b ~ BB.Builder) => Int -> a -> b
  toExponential Int
ndigits a
num = forall a. BoundedPrim a -> a -> Builder
primBounded (forall a b.
(RealFloat a, RealFloat b, b ~ ForeignFloating a) =>
String -> CInt -> (b -> Ptr Word8 -> IO CInt) -> BoundedPrim a
CBB.convert String
"toExponential" CInt
len forall a b. (a -> b) -> a -> b
$ \CDouble
val Ptr Word8
mba ->
                        CDouble -> Ptr Word8 -> CInt -> IO CInt
c_ToExponential CDouble
val Ptr Word8
mba (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
ndigits)) (forall a b. (Real a, Fractional b) => a -> b
realToFrac a
num :: Double)
      where len :: CInt
len = CInt
c_ToExponentialLength
            {-# NOINLINE len #-}

  toPrecision :: Int -> a -> b
  default toPrecision :: (b ~ BB.Builder) => Int -> a -> b
  toPrecision Int
ndigits a
num = forall a. BoundedPrim a -> a -> Builder
primBounded (forall a b.
(RealFloat a, RealFloat b, b ~ ForeignFloating a) =>
String -> CInt -> (b -> Ptr Word8 -> IO CInt) -> BoundedPrim a
CBB.convert String
"toPrecision" CInt
len forall a b. (a -> b) -> a -> b
$ \CDouble
val Ptr Word8
mba ->
                      CDouble -> Ptr Word8 -> CInt -> IO CInt
c_ToPrecision CDouble
val Ptr Word8
mba (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
ndigits)) (forall a b. (Real a, Fractional b) => a -> b
realToFrac a
num :: Double)
      where len :: CInt
len = CInt
c_ToPrecisionLength
            {-# NOINLINE len #-}

  toFixed :: Int -> a -> b
  default toFixed :: (b ~ BB.Builder) => Int -> a -> b
  toFixed Int
ndigits a
num = forall a. BoundedPrim a -> a -> Builder
primBounded (forall a b.
(RealFloat a, RealFloat b, b ~ ForeignFloating a) =>
String -> CInt -> (b -> Ptr Word8 -> IO CInt) -> BoundedPrim a
CBB.convert String
"toFixed" CInt
len forall a b. (a -> b) -> a -> b
$ \CDouble
val Ptr Word8
mba ->
                  CDouble -> Ptr Word8 -> CInt -> IO CInt
c_ToFixed CDouble
val Ptr Word8
mba (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
ndigits)) (forall a b. (Real a, Fractional b) => a -> b
realToFrac a
num :: Double)
      where len :: CInt
len = CInt
c_ToFixedLength
            {-# NOINLINE len #-}

  toShortest :: a -> b
  default toShortest :: (b ~ BB.Builder) => a -> b
  toShortest a
num = forall a. BoundedPrim a -> a -> Builder
primBounded (forall a b.
(RealFloat a, RealFloat b, b ~ ForeignFloating a) =>
String -> CInt -> (b -> Ptr Word8 -> IO CInt) -> BoundedPrim a
CBB.convert String
"toShortest" CInt
len CDouble -> Ptr Word8 -> IO CInt
c_ToShortest) (forall a b. (Real a, Fractional b) => a -> b
realToFrac a
num :: Double)
      where len :: CInt
len = CInt
c_ToShortestLength
            {-# NOINLINE len #-}

-- Instances

instance Convertable Double BB.Builder where
    toExponential :: Int -> Double -> BB.Builder
    toExponential :: Int -> Double -> Builder
toExponential Int
ndigits = forall a. BoundedPrim a -> a -> Builder
primBounded forall a b. (a -> b) -> a -> b
$ forall a b.
(RealFloat a, RealFloat b, b ~ ForeignFloating a) =>
String -> CInt -> (b -> Ptr Word8 -> IO CInt) -> BoundedPrim a
CBB.convert String
"toExponential" CInt
len forall a b. (a -> b) -> a -> b
$ \CDouble
val Ptr Word8
mba ->
                        CDouble -> Ptr Word8 -> CInt -> IO CInt
c_ToExponential CDouble
val Ptr Word8
mba (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
ndigits)
        where len :: CInt
len = CInt
c_ToExponentialLength
              {-# NOINLINE len #-}

    toPrecision :: Int -> Double -> BB.Builder
    toPrecision :: Int -> Double -> Builder
toPrecision Int
ndigits = forall a. BoundedPrim a -> a -> Builder
primBounded (forall a b.
(RealFloat a, RealFloat b, b ~ ForeignFloating a) =>
String -> CInt -> (b -> Ptr Word8 -> IO CInt) -> BoundedPrim a
CBB.convert String
"toPrecision" CInt
len forall a b. (a -> b) -> a -> b
$ \CDouble
val Ptr Word8
mba ->
                      CDouble -> Ptr Word8 -> CInt -> IO CInt
c_ToPrecision CDouble
val Ptr Word8
mba (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
ndigits))
        where len :: CInt
len = CInt
c_ToPrecisionLength
              {-# NOINLINE len #-}

    toShortest :: Double -> BB.Builder
    toShortest :: Double -> Builder
toShortest = forall a. BoundedPrim a -> a -> Builder
primBounded forall a b. (a -> b) -> a -> b
$ forall a b.
(RealFloat a, RealFloat b, b ~ ForeignFloating a) =>
String -> CInt -> (b -> Ptr Word8 -> IO CInt) -> BoundedPrim a
CBB.convert String
"toShortest" CInt
len CDouble -> Ptr Word8 -> IO CInt
c_ToShortest
        where len :: CInt
len = CInt
c_ToShortestLength
              {-# NOINLINE len #-}

    toFixed :: Int -> Double -> BB.Builder
    toFixed :: Int -> Double -> Builder
toFixed Int
ndigits = forall a. BoundedPrim a -> a -> Builder
primBounded forall a b. (a -> b) -> a -> b
$ forall a b.
(RealFloat a, RealFloat b, b ~ ForeignFloating a) =>
String -> CInt -> (b -> Ptr Word8 -> IO CInt) -> BoundedPrim a
CBB.convert String
"toFixed" CInt
len forall a b. (a -> b) -> a -> b
$ \CDouble
val Ptr Word8
mba ->
                  CDouble -> Ptr Word8 -> CInt -> IO CInt
c_ToFixed CDouble
val Ptr Word8
mba (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
ndigits)
        where len :: CInt
len = CInt
c_ToFixedLength
              {-# NOINLINE len #-}


instance Convertable Float BB.Builder where
    toExponential :: Int -> Float -> BB.Builder
    toExponential :: Int -> Float -> Builder
toExponential Int
ndigits = forall a. BoundedPrim a -> a -> Builder
primBounded forall a b. (a -> b) -> a -> b
$ forall a b.
(RealFloat a, RealFloat b, b ~ ForeignFloating a) =>
String -> CInt -> (b -> Ptr Word8 -> IO CInt) -> BoundedPrim a
CBB.convert String
"toExponential" CInt
len forall a b. (a -> b) -> a -> b
$ \CFloat
val Ptr Word8
mba ->
                        CFloat -> Ptr Word8 -> CInt -> IO CInt
c_ToExponentialFloat CFloat
val Ptr Word8
mba (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
ndigits)
        where len :: CInt
len = CInt
c_ToExponentialLength
              {-# NOINLINE len #-}

    toPrecision :: Int -> Float -> BB.Builder
    toPrecision :: Int -> Float -> Builder
toPrecision Int
ndigits = forall a. BoundedPrim a -> a -> Builder
primBounded (forall a b.
(RealFloat a, RealFloat b, b ~ ForeignFloating a) =>
String -> CInt -> (b -> Ptr Word8 -> IO CInt) -> BoundedPrim a
CBB.convert String
"toPrecision" CInt
len forall a b. (a -> b) -> a -> b
$ \CFloat
val Ptr Word8
mba ->
                      CFloat -> Ptr Word8 -> CInt -> IO CInt
c_ToPrecisionFloat CFloat
val Ptr Word8
mba (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
ndigits))
        where len :: CInt
len = CInt
c_ToPrecisionLength
              {-# NOINLINE len #-}

    toShortest :: Float -> BB.Builder
    toShortest :: Float -> Builder
toShortest = forall a. BoundedPrim a -> a -> Builder
primBounded forall a b. (a -> b) -> a -> b
$ forall a b.
(RealFloat a, RealFloat b, b ~ ForeignFloating a) =>
String -> CInt -> (b -> Ptr Word8 -> IO CInt) -> BoundedPrim a
CBB.convert String
"toShortest" CInt
len CFloat -> Ptr Word8 -> IO CInt
c_ToShortestFloat
        where len :: CInt
len = CInt
c_ToShortestLength
              {-# NOINLINE len #-}

    toFixed :: Int -> Float -> BB.Builder
    toFixed :: Int -> Float -> Builder
toFixed Int
ndigits = forall a. BoundedPrim a -> a -> Builder
primBounded forall a b. (a -> b) -> a -> b
$ forall a b.
(RealFloat a, RealFloat b, b ~ ForeignFloating a) =>
String -> CInt -> (b -> Ptr Word8 -> IO CInt) -> BoundedPrim a
CBB.convert String
"toFixed" CInt
len forall a b. (a -> b) -> a -> b
$ \CFloat
val Ptr Word8
mba ->
                  CFloat -> Ptr Word8 -> CInt -> IO CInt
c_ToFixedFloat CFloat
val Ptr Word8
mba (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
ndigits)
        where len :: CInt
len = CInt
c_ToFixedLength
              {-# NOINLINE len #-}

-- Fast conversion to bytestring.
-- Although about 15 times faster than plain 'show', these functions
-- are /slower/ than their 'Text' counterparts, at roughly half the
-- speed.  (This seems to be due to the cost of allocating
-- 'ByteString' values via @malloc@.)

instance Convertable Double B.ByteString where
    toExponential :: Int -> Double -> B.ByteString
    toExponential :: Int -> Double -> ByteString
toExponential Int
ndigits = forall a b.
(RealFloat a, RealFloat b, b ~ ForeignFloating a) =>
String -> CInt -> (b -> Ptr Word8 -> IO CInt) -> a -> ByteString
CB.convert String
"toExponential" CInt
len forall a b. (a -> b) -> a -> b
$ \CDouble
val Ptr Word8
mba ->
                        CDouble -> Ptr Word8 -> CInt -> IO CInt
c_ToExponential CDouble
val Ptr Word8
mba (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
ndigits)
        where len :: CInt
len = CInt
c_ToExponentialLength
              {-# NOINLINE len #-}

    toFixed :: Int -> Double -> B.ByteString
    toFixed :: Int -> Double -> ByteString
toFixed Int
ndigits = forall a b.
(RealFloat a, RealFloat b, b ~ ForeignFloating a) =>
String -> CInt -> (b -> Ptr Word8 -> IO CInt) -> a -> ByteString
CB.convert String
"toFixed" CInt
len forall a b. (a -> b) -> a -> b
$ \CDouble
val Ptr Word8
mba ->
                  CDouble -> Ptr Word8 -> CInt -> IO CInt
c_ToFixed CDouble
val Ptr Word8
mba (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
ndigits)
        where len :: CInt
len = CInt
c_ToFixedLength
              {-# NOINLINE len #-}

    toShortest :: Double -> B.ByteString
    toShortest :: Double -> ByteString
toShortest = forall a b.
(RealFloat a, RealFloat b, b ~ ForeignFloating a) =>
String -> CInt -> (b -> Ptr Word8 -> IO CInt) -> a -> ByteString
CB.convert String
"toShortest" CInt
len CDouble -> Ptr Word8 -> IO CInt
c_ToShortest
        where len :: CInt
len = CInt
c_ToShortestLength
              {-# NOINLINE len #-}

    toPrecision :: Int -> Double -> B.ByteString
    toPrecision :: Int -> Double -> ByteString
toPrecision Int
ndigits = forall a b.
(RealFloat a, RealFloat b, b ~ ForeignFloating a) =>
String -> CInt -> (b -> Ptr Word8 -> IO CInt) -> a -> ByteString
CB.convert String
"toPrecision" CInt
len forall a b. (a -> b) -> a -> b
$ \CDouble
val Ptr Word8
mba ->
                      CDouble -> Ptr Word8 -> CInt -> IO CInt
c_ToPrecision CDouble
val Ptr Word8
mba (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
ndigits)
        where len :: CInt
len = CInt
c_ToPrecisionLength
              {-# NOINLINE len #-}


instance Convertable Float B.ByteString where
    toExponential :: Int -> Float -> B.ByteString
    toExponential :: Int -> Float -> ByteString
toExponential Int
ndigits = forall a b.
(RealFloat a, RealFloat b, b ~ ForeignFloating a) =>
String -> CInt -> (b -> Ptr Word8 -> IO CInt) -> a -> ByteString
CB.convert String
"toExponential" CInt
len forall a b. (a -> b) -> a -> b
$ \CFloat
val Ptr Word8
mba ->
                        CFloat -> Ptr Word8 -> CInt -> IO CInt
c_ToExponentialFloat CFloat
val Ptr Word8
mba (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
ndigits)
        where len :: CInt
len = CInt
c_ToExponentialLength
              {-# NOINLINE len #-}

    toFixed :: Int -> Float -> B.ByteString
    toFixed :: Int -> Float -> ByteString
toFixed Int
ndigits = forall a b.
(RealFloat a, RealFloat b, b ~ ForeignFloating a) =>
String -> CInt -> (b -> Ptr Word8 -> IO CInt) -> a -> ByteString
CB.convert String
"toFixed" CInt
len forall a b. (a -> b) -> a -> b
$ \CFloat
val Ptr Word8
mba ->
                  CFloat -> Ptr Word8 -> CInt -> IO CInt
c_ToFixedFloat CFloat
val Ptr Word8
mba (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
ndigits)
        where len :: CInt
len = CInt
c_ToFixedLength
              {-# NOINLINE len #-}

    toShortest :: Float -> B.ByteString
    toShortest :: Float -> ByteString
toShortest = forall a b.
(RealFloat a, RealFloat b, b ~ ForeignFloating a) =>
String -> CInt -> (b -> Ptr Word8 -> IO CInt) -> a -> ByteString
CB.convert String
"toShortest" CInt
len CFloat -> Ptr Word8 -> IO CInt
c_ToShortestFloat
        where len :: CInt
len = CInt
c_ToShortestLength
              {-# NOINLINE len #-}

    toPrecision :: Int -> Float -> B.ByteString
    toPrecision :: Int -> Float -> ByteString
toPrecision Int
ndigits = forall a b.
(RealFloat a, RealFloat b, b ~ ForeignFloating a) =>
String -> CInt -> (b -> Ptr Word8 -> IO CInt) -> a -> ByteString
CB.convert String
"toPrecision" CInt
len forall a b. (a -> b) -> a -> b
$ \CFloat
val Ptr Word8
mba ->
                      CFloat -> Ptr Word8 -> CInt -> IO CInt
c_ToPrecisionFloat CFloat
val Ptr Word8
mba (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
ndigits)
        where len :: CInt
len = CInt
c_ToPrecisionLength
              {-# NOINLINE len #-}


instance Convertable Double Text where
    toExponential :: Int -> Double -> Text
    toExponential :: Int -> Double -> Text
toExponential Int
ndigits = forall a b.
(RealFloat a, RealFloat b, b ~ ForeignFloating a) =>
String
-> CInt
-> (forall s. b -> MutableByteArray# s -> IO CInt)
-> a
-> Text
CT.convert String
"toExponential" CInt
len forall a b. (a -> b) -> a -> b
$ \CDouble
val MutableByteArray# s
mba ->
                            forall s. CDouble -> MutableByteArray# s -> CInt -> IO CInt
c_Text_ToExponential CDouble
val MutableByteArray# s
mba (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
ndigits)
        where len :: CInt
len = CInt
c_ToExponentialLength
              {-# NOINLINE len #-}

    toFixed :: Int -> Double -> Text
    toFixed :: Int -> Double -> Text
toFixed Int
ndigits = forall a b.
(RealFloat a, RealFloat b, b ~ ForeignFloating a) =>
String
-> CInt
-> (forall s. b -> MutableByteArray# s -> IO CInt)
-> a
-> Text
CT.convert String
"toFixed" CInt
len forall a b. (a -> b) -> a -> b
$ \CDouble
val MutableByteArray# s
mba ->
                    forall s. CDouble -> MutableByteArray# s -> CInt -> IO CInt
c_Text_ToFixed CDouble
val MutableByteArray# s
mba (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
ndigits)
        where len :: CInt
len = CInt
c_ToFixedLength
              {-# NOINLINE len #-}

    toShortest :: Double -> Text
    toShortest :: Double -> Text
toShortest = forall a b.
(RealFloat a, RealFloat b, b ~ ForeignFloating a) =>
String
-> CInt
-> (forall s. b -> MutableByteArray# s -> IO CInt)
-> a
-> Text
CT.convert String
"toShortest" CInt
len forall s. CDouble -> MutableByteArray# s -> IO CInt
c_Text_ToShortest
        where len :: CInt
len = CInt
c_ToShortestLength
              {-# NOINLINE len #-}

    toPrecision :: Int -> Double -> Text
    toPrecision :: Int -> Double -> Text
toPrecision Int
ndigits = forall a b.
(RealFloat a, RealFloat b, b ~ ForeignFloating a) =>
String
-> CInt
-> (forall s. b -> MutableByteArray# s -> IO CInt)
-> a
-> Text
CT.convert String
"toPrecision" CInt
len forall a b. (a -> b) -> a -> b
$ \CDouble
val MutableByteArray# s
mba ->
                          forall s. CDouble -> MutableByteArray# s -> CInt -> IO CInt
c_Text_ToPrecision CDouble
val MutableByteArray# s
mba (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
ndigits)
        where len :: CInt
len = CInt
c_ToPrecisionLength
              {-# NOINLINE len #-}


instance Convertable Float Text where
    toExponential :: Int -> Float -> Text
    toExponential :: Int -> Float -> Text
toExponential Int
ndigits = forall a b.
(RealFloat a, RealFloat b, b ~ ForeignFloating a) =>
String
-> CInt
-> (forall s. b -> MutableByteArray# s -> IO CInt)
-> a
-> Text
CT.convert String
"toExponential" CInt
len forall a b. (a -> b) -> a -> b
$ \CFloat
val MutableByteArray# s
mba ->
                            forall s. CFloat -> MutableByteArray# s -> CInt -> IO CInt
c_Text_ToExponentialFloat CFloat
val MutableByteArray# s
mba (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
ndigits)
        where len :: CInt
len = CInt
c_ToExponentialLength
              {-# NOINLINE len #-}

    toFixed :: Int -> Float -> Text
    toFixed :: Int -> Float -> Text
toFixed Int
ndigits = forall a b.
(RealFloat a, RealFloat b, b ~ ForeignFloating a) =>
String
-> CInt
-> (forall s. b -> MutableByteArray# s -> IO CInt)
-> a
-> Text
CT.convert String
"toFixed" CInt
len forall a b. (a -> b) -> a -> b
$ \CFloat
val MutableByteArray# s
mba ->
                    forall s. CFloat -> MutableByteArray# s -> CInt -> IO CInt
c_Text_ToFixedFloat CFloat
val MutableByteArray# s
mba (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
ndigits)
        where len :: CInt
len = CInt
c_ToFixedLength
              {-# NOINLINE len #-}

    toShortest :: Float -> Text
    toShortest :: Float -> Text
toShortest = forall a b.
(RealFloat a, RealFloat b, b ~ ForeignFloating a) =>
String
-> CInt
-> (forall s. b -> MutableByteArray# s -> IO CInt)
-> a
-> Text
CT.convert String
"toShortest" CInt
len forall s. CFloat -> MutableByteArray# s -> IO CInt
c_Text_ToShortestFloat
        where len :: CInt
len = CInt
c_ToShortestLength
              {-# NOINLINE len #-}

    toPrecision :: Int -> Float -> Text
    toPrecision :: Int -> Float -> Text
toPrecision Int
ndigits = forall a b.
(RealFloat a, RealFloat b, b ~ ForeignFloating a) =>
String
-> CInt
-> (forall s. b -> MutableByteArray# s -> IO CInt)
-> a
-> Text
CT.convert String
"toPrecision" CInt
len forall a b. (a -> b) -> a -> b
$ \CFloat
val MutableByteArray# s
mba ->
                          forall s. CFloat -> MutableByteArray# s -> CInt -> IO CInt
c_Text_ToPrecisionFloat CFloat
val MutableByteArray# s
mba (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
ndigits)
        where len :: CInt
len = CInt
c_ToPrecisionLength
              {-# NOINLINE len #-}


instance Convertable Double T.Builder where
    toExponential :: Int -> Double -> T.Builder
    toExponential :: Int -> Double -> Builder
toExponential Int
ndigits = forall a b.
(RealFloat a, RealFloat b, b ~ ForeignFloating a) =>
String
-> CInt
-> (forall s. b -> MutableByteArray# s -> IO CInt)
-> a
-> Builder
CTB.convert String
"toExponential" CInt
len forall a b. (a -> b) -> a -> b
$ \CDouble
val MutableByteArray# s
mba ->
                            forall s. CDouble -> MutableByteArray# s -> CInt -> IO CInt
c_Text_ToExponential CDouble
val MutableByteArray# s
mba (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
ndigits)
        where len :: CInt
len = CInt
c_ToExponentialLength
              {-# NOINLINE len #-}

    toFixed :: Int -> Double -> T.Builder
    toFixed :: Int -> Double -> Builder
toFixed Int
ndigits = forall a b.
(RealFloat a, RealFloat b, b ~ ForeignFloating a) =>
String
-> CInt
-> (forall s. b -> MutableByteArray# s -> IO CInt)
-> a
-> Builder
CTB.convert String
"toFixed" CInt
len forall a b. (a -> b) -> a -> b
$ \CDouble
val MutableByteArray# s
mba ->
                      forall s. CDouble -> MutableByteArray# s -> CInt -> IO CInt
c_Text_ToFixed CDouble
val MutableByteArray# s
mba (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
ndigits)
        where len :: CInt
len = CInt
c_ToFixedLength
              {-# NOINLINE len #-}

    toShortest :: Double -> T.Builder
    toShortest :: Double -> Builder
toShortest = forall a b.
(RealFloat a, RealFloat b, b ~ ForeignFloating a) =>
String
-> CInt
-> (forall s. b -> MutableByteArray# s -> IO CInt)
-> a
-> Builder
CTB.convert String
"toShortest" CInt
len forall s. CDouble -> MutableByteArray# s -> IO CInt
c_Text_ToShortest
        where len :: CInt
len = CInt
c_ToShortestLength
              {-# NOINLINE len #-}

    toPrecision :: Int -> Double -> T.Builder
    toPrecision :: Int -> Double -> Builder
toPrecision Int
ndigits = forall a b.
(RealFloat a, RealFloat b, b ~ ForeignFloating a) =>
String
-> CInt
-> (forall s. b -> MutableByteArray# s -> IO CInt)
-> a
-> Builder
CTB.convert String
"toPrecision" CInt
len forall a b. (a -> b) -> a -> b
$ \CDouble
val MutableByteArray# s
mba ->
                          forall s. CDouble -> MutableByteArray# s -> CInt -> IO CInt
c_Text_ToPrecision CDouble
val MutableByteArray# s
mba (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
ndigits)
        where len :: CInt
len = CInt
c_ToPrecisionLength
              {-# NOINLINE len #-}


instance Convertable Float T.Builder where
    toExponential :: Int -> Float -> T.Builder
    toExponential :: Int -> Float -> Builder
toExponential Int
ndigits = forall a b.
(RealFloat a, RealFloat b, b ~ ForeignFloating a) =>
String
-> CInt
-> (forall s. b -> MutableByteArray# s -> IO CInt)
-> a
-> Builder
CTB.convert String
"toExponential" CInt
len forall a b. (a -> b) -> a -> b
$ \CFloat
val MutableByteArray# s
mba ->
                            forall s. CFloat -> MutableByteArray# s -> CInt -> IO CInt
c_Text_ToExponentialFloat CFloat
val MutableByteArray# s
mba (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
ndigits)
        where len :: CInt
len = CInt
c_ToExponentialLength
              {-# NOINLINE len #-}

    toFixed :: Int -> Float -> T.Builder
    toFixed :: Int -> Float -> Builder
toFixed Int
ndigits = forall a b.
(RealFloat a, RealFloat b, b ~ ForeignFloating a) =>
String
-> CInt
-> (forall s. b -> MutableByteArray# s -> IO CInt)
-> a
-> Builder
CTB.convert String
"toFixed" CInt
len forall a b. (a -> b) -> a -> b
$ \CFloat
val MutableByteArray# s
mba ->
                      forall s. CFloat -> MutableByteArray# s -> CInt -> IO CInt
c_Text_ToFixedFloat CFloat
val MutableByteArray# s
mba (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
ndigits)
        where len :: CInt
len = CInt
c_ToFixedLength
              {-# NOINLINE len #-}

    toShortest :: Float -> T.Builder
    toShortest :: Float -> Builder
toShortest = forall a b.
(RealFloat a, RealFloat b, b ~ ForeignFloating a) =>
String
-> CInt
-> (forall s. b -> MutableByteArray# s -> IO CInt)
-> a
-> Builder
CTB.convert String
"toShortest" CInt
len forall s. CFloat -> MutableByteArray# s -> IO CInt
c_Text_ToShortestFloat
        where len :: CInt
len = CInt
c_ToShortestLength
              {-# NOINLINE len #-}

    toPrecision :: Int -> Float -> T.Builder
    toPrecision :: Int -> Float -> Builder
toPrecision Int
ndigits = forall a b.
(RealFloat a, RealFloat b, b ~ ForeignFloating a) =>
String
-> CInt
-> (forall s. b -> MutableByteArray# s -> IO CInt)
-> a
-> Builder
CTB.convert String
"toPrecision" CInt
len forall a b. (a -> b) -> a -> b
$ \CFloat
val MutableByteArray# s
mba ->
                          forall s. CFloat -> MutableByteArray# s -> CInt -> IO CInt
c_Text_ToPrecisionFloat CFloat
val MutableByteArray# s
mba (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
ndigits)
        where len :: CInt
len = CInt
c_ToPrecisionLength
              {-# NOINLINE len #-}