Fixed conversion to text builder.

Also fixed comments.

Author: HaskellMouse

Data/Double/Conversion/ByteString.hs

@@ -11,6 +11,9 @@
 -- in new projects. 
 -- Please, use Convertable type class from Data.Double.Conversion.Convertable
 -- 
+-- It is espesially recommended to convert a large amount of numbers via bytestring builder
+-- using methods of Convertable type class. It is about 10-15x faster. 
+-- 
 -- Fast, efficient support for converting between double precision
 -- floating point values and text.
 --

Data/Double/Conversion/Convertable.hs

@@ -51,11 +51,15 @@ import qualified Data.Text.Internal.Builder as T (Builder)
 -- Compute the shortest string of digits that correctly represent
 -- the input number.
 --
--- Conversion to text is twice faster than conversion to bytestring
 -- Conversion to text via Builder (both in the in case of bytestring and text) in case of single number
--- is much slower, than to text or bytestring directly. (2-3x)
--- But conversion large amount of numbers to text via Builder is much faster than directly (up to 50x).
--- Conversion to text via text builder is a little slower, then via bytestring builder
+-- 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

Data/Double/Conversion/Internal/ByteStringBuilder.hs

@@ -12,9 +12,6 @@
 -- Fast, efficient support for converting between double precision
 -- floating point values and bytestring builder.
 
--- This functions are much slower on the single value, but also it is much faster in converting big set of
--- numbers, than bytestring functions. See benchmark.
-
 module Data.Double.Conversion.Internal.ByteStringBuilder
     (convert
     ) where

Data/Double/Conversion/Internal/TextBuilder.hs

@@ -28,21 +28,27 @@ import qualified Data.Text.Array as A
 import Data.Text.Internal.Builder (Builder, writeN)
 import Foreign.C.Types (CDouble, CFloat, CInt)
 import GHC.Prim (MutableByteArray#)
+import Control.Monad.ST (runST)
 
--- | Not implemented yet 
 convert :: (RealFloat a, RealFloat b, b ~ ForeignFloating a) => String -> CInt
         -> (forall s. b -> MutableByteArray# s -> IO CInt)
         -> a -> Builder
 {-# SPECIALIZE convert :: String -> CInt -> (forall s. CDouble -> MutableByteArray# s -> IO CInt) -> Double -> Builder #-}
 {-# SPECIALIZE convert :: String -> CInt -> (forall s. CFloat -> MutableByteArray# s -> IO CInt) -> Float -> Builder #-}
 {-# INLINABLE convert #-}
+convert func len act val = runST $ do 
 #if MIN_VERSION_text(2,0,0)
-convert func len act val = writeN (fromIntegral len) $ \(A.MutableByteArray maBa) _ -> do
+  mTempArr@(A.MutableByteArray tempMArr) <- A.new (fromIntegral len)
 #else
-convert func len act val = writeN (fromIntegral len) $ \(A.MArray maBa) _ -> do
+  mTempArr@(A.MArray tempMArr) <- A.new (fromIntegral len)
+#endif
+  size <- unsafeIOToST $ act (realToFrac val) tempMArr
+  tempArr <- A.unsafeFreeze mTempArr
+  when (size == -1) .
+      fail $ "Data.Double.Conversion.Text." ++ func ++
+              ": conversion failed."
+#if MIN_VERSION_text(2,0,0)
+  return $ writeN (fromIntegral size) $ \mArr _ -> A.copyI (fromIntegral size) mArr 0 tempArr 0
+#else
+  return $ writeN (fromIntegral size) $ \mArr _ -> A.copyI mArr 0 tempArr 0 (fromIntegral size)
 #endif
-    size <- unsafeIOToST $ act (realToFrac val) maBa
-    when (size == -1) .
-        error $ "Data.Double.Conversion.Text." ++ func ++
-               ": conversion failed (invalid precision requested)"
-    return ()

Data/Double/Conversion/Text.hs

@@ -13,6 +13,9 @@
 -- in new projects. 
 -- Please, use Convertable type class from Data.Double.Conversion.Convertable
 --
+-- It is espesially recommended to convert a large amount of numbers via text builder
+-- using methods of Convertable type class. It is about 10-15x faster.
+-- 
 -- Fast, efficient support for converting between double precision
 -- floating point values and text.
 --

benchmarks/Benchmarks.hs

@@ -18,34 +18,34 @@ testList = [2.08345919 .. 20002.08345919] :: [Double]
 testFloatList = [2.08345919 .. 20002.08345919] :: [Float]
 
 testListBSBuilder :: (Double -> BB.Builder) -> [Double] -> BSS.ByteString
-testListBSBuilder func list = BSL.toStrict $ BBE.toLazyByteStringWith (BBE.safeStrategy 128 128) BSL.empty $ foldr (\x y -> (func x) <> y) mempty list
+testListBSBuilder func list = BSL.toStrict $ BBE.toLazyByteStringWith (BBE.safeStrategy 128 128) BSL.empty $ foldr (\x y -> (func x <> ", ") <> y) mempty list
 
 testListBSBuilderFloat :: (Float -> BB.Builder) -> [Float] -> BSS.ByteString
-testListBSBuilderFloat func list = BSL.toStrict $ BBE.toLazyByteStringWith (BBE.safeStrategy 128 128) BSL.empty $ foldr (\x y -> (func x) <> y) mempty list
+testListBSBuilderFloat func list = BSL.toStrict $ BBE.toLazyByteStringWith (BBE.safeStrategy 128 128) BSL.empty $ foldr (\x y -> (func x <> ", ") <> y) mempty list
 
 testListByteString :: (Double -> BSS.ByteString) -> [Double] -> BSS.ByteString
-testListByteString func = foldr (\x y -> (func x) <> y) mempty
+testListByteString func = foldr (\x y -> (func x <> ", ") <> y) mempty
 
 testListByteStringFloat :: (Float -> BSS.ByteString) -> [Float] -> BSS.ByteString
-testListByteStringFloat func = foldr (\x y -> (func x) <> y) mempty
+testListByteStringFloat func = foldr (\x y -> (func x <> ", ") <> y) mempty
 
 testListText :: (Double -> T.Text) -> [Double] -> T.Text
-testListText func = foldr (\x y -> (func x) <> y) mempty
+testListText func = foldr (\x y -> (func x <> ", ") <> y) mempty
 
 testListTextFloat :: (Float -> T.Text) -> [Float] -> T.Text
-testListTextFloat func = foldr (\x y -> (func x) <> y) mempty
+testListTextFloat func = foldr (\x y -> (func x <> ", ") <> y) mempty
 
 testListTextBuilder :: (Double -> BT.Builder) -> [Double] -> T.Text
-testListTextBuilder func list = TL.toStrict $ BT.toLazyText $ foldr (\x y -> (func x) <> y) mempty list
+testListTextBuilder func list = TL.toStrict $ BT.toLazyText $ foldr (\x y -> (func x <> ", ") <> y) mempty list
 
 testListTextBuilderFloat :: (Float -> BT.Builder) -> [Float] -> T.Text
-testListTextBuilderFloat func list = TL.toStrict $ BT.toLazyText $ foldr (\x y -> (func x) <> y) mempty list
+testListTextBuilderFloat func list = TL.toStrict $ BT.toLazyText $ foldr (\x y -> (func x <> ", ") <> y) mempty list
 
 testFuncBuilderDefault :: [Double] -> BSS.ByteString
-testFuncBuilderDefault = \list -> BSL.toStrict $ BB.toLazyByteString $ foldr (\x y -> (BB.doubleDec x) <> y) mempty list
+testFuncBuilderDefault = \list -> BSL.toStrict $ BB.toLazyByteString $ foldr (\x y -> (BB.doubleDec x <> ", ") <> y) mempty list
 
 testFuncBuilderDefaultFloat :: [Float] -> BSS.ByteString
-testFuncBuilderDefaultFloat = \list -> BSL.toStrict $ BB.toLazyByteString $ foldr (\x y -> (BB.floatDec x) <> y) mempty list
+testFuncBuilderDefaultFloat = \list -> BSL.toStrict $ BB.toLazyByteString $ foldr (\x y -> (BB.floatDec x <> ", ") <> y) mempty list
 
 
 main = defaultMain [

benchmarks/cabal.project

@@ -0,0 +1 @@
+packages: . ../double-conversion.cabal

double-conversion.cabal

@@ -2,8 +2,8 @@ name:           double-conversion
 version:        2.0.4.1
 license:        BSD3
 license-file:   LICENSE
-homepage:       https://github.com/Haskell-mouse/double-conversion
-bug-reports:    https://github.com/Haskell-mouse/double-conversion/issues
+homepage:       https://github.com/haskell/double-conversion
+bug-reports:    https://github.com/haskell/double-conversion/issues
 category:       Text
 author:         Bryan O'Sullivan <bos@serpentine.com>
 maintainer:     Bryan O'Sullivan <bos@serpentine.com>
@@ -25,12 +25,11 @@ description:
     The 'Text' versions of these functions are about 30 times faster
     than the default 'show' implementation for the 'Double' type.
     .
-    The 'ByteString' versions are /slower/ than the 'Text' versions;
-    roughly half the speed.  (This seems to be due to the cost of
-    allocating 'ByteString' values via @malloc@.)
+    The 'ByteString' versions are have very close speed to the 'Text' versions;
     .
-    Builder versions are slower on single value, but they are much faster on large number of values 
-    (up to 50x faster on list with 20000 doubles).  
+    Builder versions (both for Text and Bytestring) are slower on single value,
+    but they are much faster on large number of values 
+    (up to 20x faster on list with 20000 doubles).
     .
     As a final note, be aware that the @bytestring-show@ package is
     about 50% slower than simply using 'show'.