Update cabal file

floating-bits.cabal

@@ -5,7 +5,7 @@ description:         A small library to cast floating point values to integral v
 license:             BSD3
 license-file:        LICENSE
 author:              Anselm Jonas Scholl
-maintainer:          julia.longtin@gmail.com
+maintainer:          Julia Longtin <julia.longtin@gmail.com>
 copyright:           (c) 2015 Anselm Jonas Scholl, (c) 2023 Julia Longtin
 category:            Data
 build-type:          Simple

src/Data/Bits/Floating.hs

@@ -1,14 +1,15 @@
 {-# LANGUAGE FunctionalDependencies #-}
 -----------------------------------------------------------------------------
 -- |
--- Copyright   :  (C) 2015 Anselm Jonas Scholl
+-- Copyright   :  (C) 2015 Anselm Jonas Scholl, (C) 2023 Julia Longtin
 -- License     :  BSD3
--- Maintainer  :  Anselm Jonas Scholl <anselm.scholl@tu-harburg.de>
+-- Maintainer  :  Julia Longtin <Julia.Longtin@gmail.com>
 -- Stability   :  experimental
 -- Portability :  GHC-specific
 --
--- Conversions between floating point values and integral values preserving
--- the bit-patterns.
+-- Functions for performing conversions between floating point values and
+-- Integral values, for retrieving the Unit of Least Precision of a floating
+-- point value, and for incrementing / decrementing a value by one ULP..
 ----------------------------------------------------------------------------
 module Data.Bits.Floating (
 
@@ -57,20 +58,23 @@ class (Floating f, Integral w) => FloatingBits f w | f -> w where
     --   @'coerceToWord' ('coerceToFloat' w) /= w@.
     coerceToFloat :: w -> f
     -- | Return the next floating point value in the direction of +INF.
-    --   If the argument is NaN, NaN is returned. If the argument is +INF,
-    --   +INF is returned. If the argument is 0.0, the minimum value greater than
-    --   0.0 is returned.
+    --   If the argument is NaN, NaN is returned.
+    --   If the argument is +INF, +INF is returned.
+    --   If the argument is 0.0, the minimum value greater than 0.0 is returned.
+    --   If the argument is -INF, -INF is returned.
     nextUp :: f -> f
     -- | Return the next floating point value in the direction of -INF.
-    --   If the argument is NaN, NaN is returned. If the argument is -INF,
-    --   +INF is returned. If the argument is 0.0, the maximum value smaller than
-    --   0.0 is returned.
+    --   If the argument is NaN, NaN is returned.
+    --   If the argument is +INF, +INF is returned.
+    --   If the argument is 0.0, the maximum value smaller than 0.0 is returned.
+    --   If the argument is -INF, -INF is returned.
     nextDown :: f -> f
-    -- | Return the size of an ulp of the argument. If the argument is NaN, NaN
-    --   is returned. If the argument is +INF or -INF, +INF is returned. If
-    --   the argument is 0.0, the minimum value greater than 0.0 is returned.
+    -- | Return the size of the Unit of Least Precision of the argument.
+    --   If the argument is NaN, NaN is returned.
+    --   If the argument is +INF or -INF, +INF is returned.
+    --   If the argument is 0.0, the minimum value greater than 0.0 is returned.
     --
-    --   If @x@ is not NaN, @'ulp' x == 'ulp' (-x)@ holds.
+    --   If @x@ is not NaN or one of the infinities, @'ulp' x == 'ulp' (-x)@ holds.
     ulp :: f -> f
 
 class ShowFloat f where

src/Data/Bits/Floating/Prim.hs

@@ -1,8 +1,8 @@
 -----------------------------------------------------------------------------
 -- |
--- Copyright   :  (C) 2015 Anselm Jonas Scholl
+-- Copyright   :  (C) 2015 Anselm Jonas Scholl, (C) 2023 Julia Longtin
 -- License     :  BSD3
--- Maintainer  :  Anselm Jonas Scholl <anselm.scholl@tu-harburg.de>
+-- Maintainer  :  Julia Longtin
 -- Stability   :  experimental
 -- Portability :  GHC-specific
 --
@@ -17,6 +17,7 @@
 {-# LANGUAGE UnliftedFFITypes         #-}
 {-# LANGUAGE CPP                      #-}
 
+-- Note: HLint fails to find this, and will always warn.
 #include "MachDeps.h"
 
 module Data.Bits.Floating.Prim (
@@ -31,6 +32,7 @@ import Prelude ()
 import GHC.Exts (Double#, Double(D#), Float#, Float(F#))
 import GHC.Word (Word32(W32#), Word64(W64#))
 
+#if defined(WORD_SIZE_IN_BITS)
 #if WORD_SIZE_IN_BITS == 64 && MIN_VERSION_base(4,17,0)
 -- The name of Word# changed to Word64# in base 4.17.0 (GHC 9.4.1)
 import GHC.Exts (Word64#, Word32#)
@@ -52,6 +54,7 @@ import GHC.Exts (Word32#)
 #else
 #error non-X86_64 architectures not supported
 #endif
+#endif
 
 foreign import prim "double2WordBwzh"
     double2WordBitwise# :: Double# -> WORD64#

test/Bench.hs

@@ -1,11 +1,23 @@
+-----------------------------------------------------------------------------
+-- |
+-- Copyright   :  (C) 2015 Anselm Jonas Scholl, (C) 2023 Julia Longtin
+-- License     :  BSD3
+-- Maintainer  :  Julia Longtin <Julia.Longtin@gmail.com>
+-- Stability   :  experimental
+-- Portability :  GHC-specific
+--
+
 module Main where
 
-import TestUtils
+import Prelude (Double, Float, IO, ($), (++), concatMap, map, shows, unzip)
+
+import TestUtils (refDoubleDown, refDoubleToWord, refDoubleUp, refDoubleUlp, refFloatDown, refFloatToWord, refFloatUp, refFloatUlp, refWordToDouble, refWordToFloat, showW, testD, testF)
+
+import Data.Word (Word32, Word64)
 
-import Data.Word
-import Data.Bits.Floating
+import Data.Bits.Floating (coerceToFloat, coerceToWord, nextDown, nextUp, ulp)
 
-import Criterion.Main
+import Criterion.Main (Benchmark, bench, bgroup, defaultMain, nf)
 
 mkSingleBenchmarks :: ((Float, Word32) -> [Benchmark]) -> ((Double, Word64) -> [Benchmark]) -> [Benchmark]
 mkSingleBenchmarks mkFTest mkDTest = concatMap mkFTest testF ++ concatMap mkDTest testD

test/Test.hs

@@ -1,16 +1,30 @@
+-----------------------------------------------------------------------------
+-- |
+-- Copyright   :  (C) 2015 Anselm Jonas Scholl, (C) 2023 Julia Longtin
+-- License     :  BSD3
+-- Maintainer  :  Julia Longtin <Julia.Longtin@gmail.com>
+-- Stability   :  experimental
+-- Portability :  GHC-specific
+--
+
 {-# LANGUAGE BangPatterns #-}
+
 {-# LANGUAGE ScopedTypeVariables #-}
+
 module Main where
 
-import TestUtils
+import Prelude(Bool(False), Double, Float, Integral, IO, MonadFail, RealFloat, Show, String, (.), (<), ($), (+), (-), (&&), (++), (<=), (>=), (/=), (==), (||), (<$>), either, fail, fromIntegral, fst, isInfinite, isNaN, isNegativeZero, mapM_, maxBound, minBound, not, otherwise, putStrLn, realToFrac, rem, return, quot, show, shows, snd)
+
+import TestUtils (refDoubleDown, refDoubleToWord, refDoubleUp, refDoubleUlp, refFloatDown, refFloatToWord, refFloatUlp, refFloatUp, refWordToDouble, refWordToFloat, showW, testD, testF)
+
+import Data.Word (Word32, Word64)
 
-import Data.Word
-import Data.Bits
-import Data.Bits.Floating
+import Data.Bits ((.&.), complement)
+import Data.Bits.Floating (FloatingBits, ShowFloat, coerceToFloat, coerceToWord, nextDown, nextUp, showFloat, ulp)
 
-import Control.Concurrent
-import Control.Exception
-import Control.Monad
+import Control.Concurrent (MVar, forkIO, getNumCapabilities, newEmptyMVar, putMVar, takeMVar)
+import Control.Exception (SomeException, throwIO, try)
+import Control.Monad (forM_, join, replicateM_, unless, void, when)
 
 main :: IO ()
 main = do

test/TestUtils.hs

@@ -1,9 +1,21 @@
+-----------------------------------------------------------------------------
+-- |
+-- Copyright   :  (C) 2015 Anselm Jonas Scholl, (C) 2023 Julia Longtin
+-- License     :  BSD3
+-- Maintainer  :  Julia Longtin <Julia.Longtin@gmail.com>
+-- Stability   :  experimental
+-- Portability :  GHC-specific
+--
+
 {-# LANGUAGE ForeignFunctionInterface #-}
+
 module TestUtils where
 
-import Data.Word
+import Prelude (Double, Float, Integral, Show, String, (/), pi, sqrt)
+
+import Data.Word (Word32, Word64)
 
-import Numeric
+import Numeric (showHex)
 
 -- we do not test NaNs here because their binary representation can be changed
 -- without changing their value and some processors have been observed to do that.