number-length 0.1.0.1 → 0.2.0.0

raw patch · 11 files changed

+551/−56 lines, 11 filesdep ~QuickCheckPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: QuickCheck

API changes (from Hackage documentation)

Files

• ChangeLog.md +6/−0
• LICENSE +1/−1
• number-length.cabal +73/−26
• src/Data/NumberLength.hs +23/−4
• src/Data/NumberLength/Integer.hs +84/−0
• src/Data/NumberLength/Natural.hs +75/−0
• test/TestCase.hs +14/−4
• test/TestCase/Data/NumberLength.hs +39/−20
• test/TestCase/Data/NumberLength/Integer.hs +102/−0
• test/TestCase/Data/NumberLength/Natural.hs +88/−0
• test/benchmark.hs +46/−1

@@ -1,6 +1,12 @@ # ChangeLog / ReleaseNotes  +## Version 0.2.0.0++* Instances for `Integer` and `Natural`.+* Build on GHC 8.2.2 and Stackage LTS 10.\*.++ ## Version 0.1.0.1  * Removed dead code. (**minor change**)

@@ -1,4 +1,4 @@-Copyright (c) 2015-2016, Peter Trško+Copyright (c) 2015-2016, 2018 Peter Trško  All rights reserved. 

@@ -1,5 +1,5 @@ name:                   number-length-version:                0.1.0.1+version:                0.2.0.0 synopsis:   Number of digits in a number in decimal and hexadecimal representation. description:@@ -22,7 +22,7 @@ license-file:           LICENSE author:                 Peter Trško maintainer:             peter.trsko@gmail.com-copyright:              (c) 2015-2016, Peter Trško+copyright:              (c) 2015-2016, 2018 Peter Trško category:               Data build-type:             Simple cabal-version:          >=1.10@@ -39,6 +39,7 @@   exposed-modules:       Data.NumberLength     , Data.NumberLength.Int+    , Data.NumberLength.Integer     , Data.NumberLength.Internal     , Data.NumberLength.Word   -- other-modules:@@ -47,16 +48,26 @@   other-extensions:     NoImplicitPrelude    build-depends:        base >=4.5 && <5-  if impl(ghc <7.8)-    -- Data.Proxy was introduced in base ==4.7, which was bundled with GHC 7.8.-    build-depends:      tagged >=0.6 && <0.9 -  ghc-options:          -Wall -fwarn-tabs+  if impl(ghc >=7.10)+    -- Module Numeric.Natural providing new Natural type representing+    -- non-negative arbitrary-precision integers was introduced in base+    -- 4.8.0.0, which was bundled with GHC 7.10.1.+    cpp-options:        -DHAVE_NATURAL+    exposed-modules:    Data.NumberLength.Natural++  ghc-options:          -Wall   if flag(pedantic)-    ghc-options:-      -fwarn-implicit-prelude-      -fwarn-missing-import-lists---    -Werror+    if impl(ghc >8)+      ghc-options:+        -Wimplicit-prelude+        -Wmissing-import-lists+        -Werror+    else+      ghc-options:+        -fwarn-implicit-prelude+        -fwarn-missing-import-lists+        -Werror  test-suite unit-tests   hs-source-dirs:       src, test@@ -66,8 +77,15 @@       TestCase     , TestCase.Data.NumberLength     , TestCase.Data.NumberLength.Int+    , TestCase.Data.NumberLength.Integer     , TestCase.Data.NumberLength.Word +    , Data.NumberLength+    , Data.NumberLength.Int+    , Data.NumberLength.Integer+    , Data.NumberLength.Internal+    , Data.NumberLength.Word+   default-language:     Haskell2010   other-extensions:     DefaultSignatures, NoImplicitPrelude @@ -76,6 +94,15 @@     -- Data.Proxy was introduced in base ==4.7, which was bundled with GHC 7.8.     build-depends:      tagged >=0.6 && <0.9 +  if impl(ghc >=7.10)+    -- Module Numeric.Natural providing new Natural type representing+    -- non-negative arbitrary-precision integers was introduced in base+    -- 4.8.0.0, which was bundled with GHC 7.10.1.+    cpp-options:        -DHAVE_NATURAL+    other-modules:+        TestCase.Data.NumberLength.Natural+      , Data.NumberLength.Natural+   build-depends:       base >=4.5 && <5   -- }}} Dependencies of the library ------------------------------------------@@ -83,7 +110,7 @@   -- {{{ Test-suite dependencies ----------------------------------------------     , HUnit >=1.2 && <2       -- ^ Same constraints as test-framework-hunit-    , QuickCheck >=2.6 && <2.9+    , QuickCheck >=2.6 && <3       -- ^ Same constraints as test-framework-quickcheck2==0.3.0.3.     , test-framework >=0.8 && <1       -- ^ Same constraint as test-framework-skip, other packages that@@ -95,26 +122,40 @@       -- on it had a compilation failure on Hackage.   -- }}} Test-suite dependencies ---------------------------------------------- -  ghc-options:          -Wall -fwarn-tabs+  ghc-options:          -Wall   if flag(pedantic)-    ghc-options:-      -fwarn-implicit-prelude-      -fwarn-missing-import-lists---    -Werror+    if impl(ghc >8)+      ghc-options:+        -Wimplicit-prelude+        -Wmissing-import-lists+        -Werror+    else+      ghc-options:+        -fwarn-implicit-prelude+        -fwarn-missing-import-lists+        -Werror  benchmark benchmark   hs-source-dirs:       src, test   type:                 exitcode-stdio-1.0   main-is:              benchmark.hs---other-modules:+  other-modules:+      Data.NumberLength.Int+    , Data.NumberLength.Internal+    , Data.NumberLength.Integer+    , Data.NumberLength.Natural+    , Data.NumberLength.Word    default-language:     Haskell2010   other-extensions:     NoImplicitPrelude    -- {{{ Dependencies of the library -------------------------------------------  if impl(ghc <7.8)-    -- Data.Proxy was introduced in base ==4.7, which was bundled with GHC 7.8.-    build-depends:      tagged >=0.6 && <0.9+  if impl(ghc >=7.10)+    -- Module Numeric.Natural providing new Natural type representing+    -- non-negative arbitrary-precision integers was introduced in base+    -- 4.8.0.0, which was bundled with GHC 7.10.1.+    cpp-options:        -DHAVE_NATURAL+    other-modules:      Data.NumberLength.Natural    build-depends:       base >=4.5 && <5@@ -123,12 +164,18 @@     , criterion >=1.0.0.0 && <2     , number-length -  ghc-options:          -Wall -fwarn-tabs+  ghc-options:          -Wall   if flag(pedantic)-    ghc-options:-      -fwarn-implicit-prelude-      -fwarn-missing-import-lists---    -Werror+    if impl(ghc >8)+      ghc-options:+        -Wimplicit-prelude+        -Wmissing-import-lists+        -Werror+    else+      ghc-options:+        -fwarn-implicit-prelude+        -fwarn-missing-import-lists+        -Werror  source-repository head   type:                 git@@ -137,4 +184,4 @@ source-repository this   type:                 git   location:             git://github.com/trskop/number-length.git-  tag:                  v0.1.0.1+  tag:                  v0.2.0.0

@@ -1,3 +1,4 @@+{-# LANGUAGE CPP #-} {-# LANGUAGE DefaultSignatures #-} {-# LANGUAGE NoImplicitPrelude #-} -- |@@ -20,12 +21,14 @@     )   where -import Prelude(Num((+)), fromIntegral)+import Prelude(Integer, Num((+)), fromIntegral)  import Data.Int (Int, Int16, Int32, Int64, Int8) import Data.Ord (Ord((<)))-import Data.Proxy (Proxy) import Data.Word (Word, Word16, Word32, Word64, Word8)+#ifdef HAVE_NATURAL+import Numeric.Natural (Natural)+#endif  import Data.NumberLength.Int     ( lengthInt@@ -39,7 +42,11 @@     , lengthInt8hex     , lengthIntHex     )+import Data.NumberLength.Integer (lengthInteger, lengthIntegerHex) import Data.NumberLength.Internal (either32or64)+#ifdef HAVE_NATURAL+import Data.NumberLength.Natural (lengthNatural, lengthNaturalHex)+#endif import Data.NumberLength.Word     ( lengthWord     , lengthWord16@@ -134,10 +141,10 @@ -- it. class NumberLength a => BoundedNumberLength a where     -- | Get maximum number of digits of a number in base 10.-    maxNumberLength :: Proxy a -> Int+    maxNumberLength :: proxy a -> Int      -- | Get maximum number of digits of a number in base 16.-    maxNumberLengthHex :: Proxy a -> Int+    maxNumberLengthHex :: proxy a -> Int  -- {{{ Int* ------------------------------------------------------------------- @@ -240,3 +247,15 @@     maxNumberLengthHex _ = 2  -- }}} Word* ------------------------------------------------------------------++-- | /Since 0.2.0.0/+instance NumberLength Integer where+    numberLength = lengthInteger+    numberLengthHex = lengthIntegerHex++#ifdef HAVE_NATURAL+-- | /Since 0.2.0.0/+instance NumberLength Natural where+    numberLength = lengthNatural+    numberLengthHex = lengthNaturalHex+#endif

@@ -0,0 +1,84 @@+{-# LANGUAGE NoImplicitPrelude #-}+-- |+-- Module:       $HEADER$+-- Description:  Get number of digits of an Integer.+-- Copyright:    (c) 2016, Peter Trško+-- License:      BSD3+--+-- Stability:    experimental+-- Portability:  NoImplicitPrelude+--+-- Get number of digits of an 'Integer'.+--+-- /Since 0.2.0.0/+module Data.NumberLength.Integer+    (+    -- * Decimal (base 10)+      lengthInteger++    -- * Hexadecimal (base 16)+    , lengthIntegerHex+    )+  where++import Prelude+    ( Bounded(maxBound)+    , Integer+    , Integral(quot)+    , Num((+), fromInteger, negate)+    , (^)+    , fromIntegral+    )++import Data.Bool (otherwise)+import Data.Eq (Eq((==)))+import Data.Int (Int)+import Data.Ord (Ord((<)))++import Data.NumberLength.Int (lengthInt, lengthIntHex)+import Data.NumberLength.Internal (either32or64)+++-- | Number of digits in a @number :: 'Integer'@ in base 10.+--+-- /Since 0.2.0.0/+lengthInteger :: Integer -> Int+lengthInteger n+  | n < 0     = go (negate (fromIntegral n))+  | otherwise = go (fromIntegral n)+  where+    go :: Integer -> Int+    go m+      | m < maxInt = lengthInt (fromInteger m)+      | otherwise  =+        let r = m `quot` (10 ^ maxIntDigits)+        in maxIntDigits + if r == 0 then 0 else lengthInteger r++    maxIntDigits :: Int+    maxIntDigits = 10 `either32or64` 19+{-# INLINE lengthInteger #-}++-- | Number of digits in a @number :: 'Integer'@ in base 16.+--+-- /Since 0.2.0.0/+lengthIntegerHex :: Integer -> Int+lengthIntegerHex n+  | n < 0     = go (negate n)+  | otherwise = go n+  where+    go :: Integer -> Int+    go m+      | m < maxInt = lengthIntHex (fromInteger m)+      | otherwise  =+        let r = m `quot` (16 ^ maxIntDigits)+        in maxIntDigits + if r == 0 then 0 else lengthIntegerHex r++    maxIntDigits :: Int+    maxIntDigits = 8 `either32or64` 16+{-# INLINE lengthIntegerHex #-}++-- | Maximum value of type 'Int' cast in to 'Integral'.+--+-- /Do not export this function!/+maxInt :: Integer+maxInt = fromIntegral (maxBound :: Int)

@@ -0,0 +1,75 @@+{-# LANGUAGE NoImplicitPrelude #-}+-- |+-- Module:       $HEADER$+-- Description:  Get number of digits of a Natural.+-- Copyright:    (c) 2016, Peter Trško+-- License:      BSD3+--+-- Stability:    experimental+-- Portability:  NoImplicitPrelude+--+-- Get number of digits of a 'Natural'.+--+-- /Since 0.2.0.0/+module Data.NumberLength.Natural+    (+    -- * Decimal (base 10)+      lengthNatural++    -- * Hexadecimal (base 16)+    , lengthNaturalHex+    )+  where++import Prelude+    ( Bounded(maxBound)+    , Integral(quot)+    , Num((+))+    , (^)+    , fromIntegral+    )++import Data.Bool (otherwise)+import Data.Eq (Eq((==)))+import Data.Int (Int)+import Data.Ord (Ord((<)))+import Data.Word (Word)+import Numeric.Natural (Natural)++import Data.NumberLength.Internal (either32or64)+import Data.NumberLength.Word (lengthWord, lengthWordHex)+++-- | Number of digits in a @number :: 'Natural'@ in base 10.+--+-- /Since 0.2.0.0/+lengthNatural :: Natural -> Int+lengthNatural n+  | n < maxWord = lengthWord (fromIntegral n)+  | otherwise   =+    let r = n `quot` (10 ^ maxWordDigits)+    in maxWordDigits + if r == 0 then 0 else lengthNatural r+  where+    maxWordDigits :: Int+    maxWordDigits = 10 `either32or64` 20+{-# INLINE lengthNatural #-}++-- | Number of digits in a @number :: 'Natural'@ in base 16.+--+-- /Since 0.2.0.0/+lengthNaturalHex :: Natural -> Int+lengthNaturalHex n+  | n < maxWord = lengthWordHex (fromIntegral n)+  | otherwise   =+    let r = n `quot` (16 ^ maxWordDigits)+    in maxWordDigits + if r == 0 then 0 else lengthNaturalHex r+  where+    maxWordDigits :: Int+    maxWordDigits = 8 `either32or64` 16+{-# INLINE lengthNaturalHex #-}++-- | Maximum value of type 'Word' cast in to 'Natural'.+--+-- /Do not export this function!/+maxWord :: Natural+maxWord = fromIntegral (maxBound :: Word)

@@ -1,3 +1,4 @@+{-# LANGUAGE CPP #-} {-# LANGUAGE NoImplicitPrelude #-} -- | -- Module:       $HEADER$@@ -14,14 +15,23 @@  import Test.Framework (Test, testGroup) -import qualified TestCase.Data.NumberLength.Int as NumberLength.Int (tests) import qualified TestCase.Data.NumberLength as NumberLength (tests)-import qualified TestCase.Data.NumberLength.Word as NumberLength.Word (tests)+import qualified TestCase.Data.NumberLength.Int as Int (tests)+import qualified TestCase.Data.NumberLength.Integer as Integer (tests)+import qualified TestCase.Data.NumberLength.Word as Word (tests) +#ifdef HAVE_NATURAL+import qualified TestCase.Data.NumberLength.Natural as Natural (tests)+#endif + tests :: [Test] tests =-    [ testGroup "Data.NumberLength.Int" NumberLength.Int.tests-    , testGroup "Data.NumberLength.Word" NumberLength.Word.tests+    [ testGroup "Data.NumberLength.Int" Int.tests+    , testGroup "Data.NumberLength.Word" Word.tests+    , testGroup "Data.NumberLength.Integer" Integer.tests+#ifdef HAVE_NATURAL+    , testGroup "Data.NumberLength.Natural" Natural.tests+#endif     , testGroup "Data.NumberLength" NumberLength.tests     ]

@@ -1,3 +1,4 @@+{-# LANGUAGE CPP #-} {-# LANGUAGE NoImplicitPrelude #-} -- | -- Module:       $HEADER$@@ -46,6 +47,16 @@     , lengthInt8hex     , lengthIntHex     )+import Data.NumberLength.Integer+    ( lengthInteger+    , lengthIntegerHex+    )+#ifdef HAVE_NATURAL+import Data.NumberLength.Natural+    ( lengthNatural+    , lengthNaturalHex+    )+#endif import Data.NumberLength.Word     ( lengthWord     , lengthWord16@@ -64,29 +75,37 @@ tests =     [ testGroup "class NumberLength"         [ testGroup "numberLengthHex"-            [ testProperty "Int"    $ numberLength <==> lengthInt-            , testProperty "Int8"   $ numberLength <==> lengthInt8-            , testProperty "Int16"  $ numberLength <==> lengthInt16-            , testProperty "Int32"  $ numberLength <==> lengthInt32-            , testProperty "Int64"  $ numberLength <==> lengthInt64-            , testProperty "Word"   $ numberLength <==> lengthWord-            , testProperty "Word8"  $ numberLength <==> lengthWord8-            , testProperty "Word16" $ numberLength <==> lengthWord16-            , testProperty "Word32" $ numberLength <==> lengthWord32-            , testProperty "Word64" $ numberLength <==> lengthWord64+            [ testProperty "Int"     $ numberLength <==> lengthInt+            , testProperty "Int8"    $ numberLength <==> lengthInt8+            , testProperty "Int16"   $ numberLength <==> lengthInt16+            , testProperty "Int32"   $ numberLength <==> lengthInt32+            , testProperty "Int64"   $ numberLength <==> lengthInt64+            , testProperty "Word"    $ numberLength <==> lengthWord+            , testProperty "Word8"   $ numberLength <==> lengthWord8+            , testProperty "Word16"  $ numberLength <==> lengthWord16+            , testProperty "Word32"  $ numberLength <==> lengthWord32+            , testProperty "Word64"  $ numberLength <==> lengthWord64+            , testProperty "Integer" $ numberLength <==> lengthInteger+#ifdef HAVE_NATURAL+            , testProperty "Natural" $ numberLength <==> lengthNatural+#endif             ]          , testGroup "numberLengthHex"-            [ testProperty "Int"    $ numberLengthHex <==> lengthIntHex-            , testProperty "Int8"   $ numberLengthHex <==> lengthInt8hex-            , testProperty "Int16"  $ numberLengthHex <==> lengthInt16hex-            , testProperty "Int32"  $ numberLengthHex <==> lengthInt32hex-            , testProperty "Int64"  $ numberLengthHex <==> lengthInt64hex-            , testProperty "Word"   $ numberLengthHex <==> lengthWordHex-            , testProperty "Word8"  $ numberLengthHex <==> lengthWord8hex-            , testProperty "Word16" $ numberLengthHex <==> lengthWord16hex-            , testProperty "Word32" $ numberLengthHex <==> lengthWord32hex-            , testProperty "Word64" $ numberLengthHex <==> lengthWord64hex+            [ testProperty "Int"     $ numberLengthHex <==> lengthIntHex+            , testProperty "Int8"    $ numberLengthHex <==> lengthInt8hex+            , testProperty "Int16"   $ numberLengthHex <==> lengthInt16hex+            , testProperty "Int32"   $ numberLengthHex <==> lengthInt32hex+            , testProperty "Int64"   $ numberLengthHex <==> lengthInt64hex+            , testProperty "Word"    $ numberLengthHex <==> lengthWordHex+            , testProperty "Word8"   $ numberLengthHex <==> lengthWord8hex+            , testProperty "Word16"  $ numberLengthHex <==> lengthWord16hex+            , testProperty "Word32"  $ numberLengthHex <==> lengthWord32hex+            , testProperty "Word64"  $ numberLengthHex <==> lengthWord64hex+            , testProperty "Integer" $ numberLengthHex <==> lengthIntegerHex+#ifdef HAVE_NATURAL+            , testProperty "Natural" $ numberLengthHex <==> lengthNaturalHex+#endif             ]         ] 

@@ -0,0 +1,102 @@+{-# LANGUAGE NoImplicitPrelude #-}+-- |+-- Module:       $HEADER$+-- Description:  TODO+-- Copyright:    (c) 2015-2016, Peter Trško+-- License:      BSD3+--+-- Stability:    experimental+-- Portability:  NoImplicitPrelude+module TestCase.Data.NumberLength.Integer (tests)+  where++import Prelude+    ( Bounded(maxBound, minBound)+    , Integer+    , Num((-), (*), negate)+    , fromIntegral+    , (^)+    )++import Control.Applicative (liftA2)+import Data.Bool (Bool, otherwise)+import Data.Eq (Eq((==)))+import Data.Function ((.), ($))+import Data.Int (Int, Int64)+import qualified Data.List as List (dropWhile, length)+import Data.Ord (Ord((<)))+import Data.String (String)+import Data.Word (Word64)+import Text.Printf (printf)+import Text.Show (Show(show))++import Test.Framework (Test)+import Test.Framework.Providers.HUnit (testCase)+import Test.Framework.Providers.QuickCheck2 (testProperty)+import Test.HUnit (Assertion, (@?=))++import Data.NumberLength.Integer+    ( lengthInteger+    , lengthIntegerHex+    )+++tests :: [Test]+tests =+    [ testCase "lengthInteger minInt64" $ test_lengthInteger minInt64+    , testCase "lengthInteger maxInt64" $ test_lengthInteger maxInt64+    , testCase "lengthInteger minWord64" $ test_lengthInteger minWord64+    , testCase "lengthInteger maxWord64" $ test_lengthInteger maxWord64+    , testCase "lengthInteger (maxWord64 * 2)"+        $ test_lengthInteger (maxWord64 * 2)+    , testCase "lengthInteger (10 ^ maxWordDigits32 - 1)"+        $ test_lengthInteger (10 ^ maxWordDigits32 - 1)+    , testCase "lengthInteger (10 ^ maxWordDigits64 - 1)"+        $ test_lengthInteger (10 ^ maxWordDigits64 - 1)+    , testProperty "lengthInteger = length . show" property_lengthInteger++    , testCase "lengthIntegerHex minInt64" $ test_lengthIntegerHex minInt64+    , testCase "lengthIntegerHex maxInt64" $ test_lengthIntegerHex maxInt64+    , testCase "lengthIntegerHex minWord64" $ test_lengthIntegerHex minWord64+    , testCase "lengthIntegerHex maxWord64" $ test_lengthIntegerHex maxWord64+    , testCase "lengthIntegerHex (maxWord64 * 2)"+        $ test_lengthIntegerHex (maxWord64 * 2)+    , testCase "lengthIntegerHex (10 ^ maxWordDigits32hex - 1)"+        $ test_lengthIntegerHex (16 ^ maxWordDigits32hex - 1)+    , testCase "lengthIntegerHex (10 ^ maxWordDigits64hex - 1)"+        $ test_lengthIntegerHex (16 ^ maxWordDigits64hex - 1)+    , testProperty "lengthIntegerHex = length . show" property_lengthIntegerHex+    ]+  where+    minInt64 = fromIntegral (minBound :: Int64)+    maxInt64 = fromIntegral (maxBound :: Int64)+    minWord64 = fromIntegral (minBound :: Word64)+    maxWord64 = fromIntegral (maxBound :: Word64)+    maxWordDigits32 = 10 :: Int+    maxWordDigits64 = 20 :: Int+    maxWordDigits32hex = 8 :: Int+    maxWordDigits64hex = 16 :: Int++numberLengthDec :: Integer -> Int+numberLengthDec = List.length . List.dropWhile (== '-') . show++numberLengthHex :: Integer -> Int+numberLengthHex n+  | n < 0     = numberLengthHex' $ negate n+  | otherwise = numberLengthHex' n+  where+    numberLengthHex' :: Integer -> Int+    numberLengthHex' m = List.length (printf "%x" m :: String)++(<==>) :: Eq b => (a -> b) -> (a -> b) -> a -> Bool+(<==>) = liftA2 (==)++test_lengthInteger, test_lengthIntegerHex :: Integer -> Assertion+test_lengthInteger n = lengthInteger n @?= numberLengthDec n+test_lengthIntegerHex n = lengthIntegerHex n @?= numberLengthHex n++property_lengthInteger :: Integer -> Bool+property_lengthInteger = lengthInteger <==> numberLengthDec++property_lengthIntegerHex :: Integer -> Bool+property_lengthIntegerHex = lengthIntegerHex <==> numberLengthHex

@@ -0,0 +1,88 @@+{-# LANGUAGE NoImplicitPrelude #-}+-- |+-- Module:       $HEADER$+-- Description:  TODO+-- Copyright:    (c) 2015-2016, Peter Trško+-- License:      BSD3+--+-- Stability:    experimental+-- Portability:  NoImplicitPrelude+module TestCase.Data.NumberLength.Natural (tests)+  where++import Prelude+    ( Bounded(maxBound)+    , Num((-), (*))+    , fromIntegral+    , (^)+    )++import Control.Applicative (liftA2)+import Data.Bool (Bool)+import Data.Eq (Eq((==)))+import Data.Function ((.), ($))+import Data.Int (Int, Int64)+import qualified Data.List as List (length)+import Data.String (String)+import Data.Word (Word64)+import Numeric.Natural (Natural)+import Text.Printf (printf)+import Text.Show (Show(show))++import Test.Framework (Test)+import Test.Framework.Providers.HUnit (testCase)+import Test.Framework.Providers.QuickCheck2 (testProperty)+import Test.HUnit (Assertion, (@?=))++import Data.NumberLength.Natural+    ( lengthNatural+    , lengthNaturalHex+    )+++tests :: [Test]+tests =+    [ testCase "lengthNatural maxInt64" $ test_lengthNatural maxInt64+    , testCase "lengthNatural maxWord64" $ test_lengthNatural maxWord64+    , testCase "lengthNatural (maxWord64 * 2)"+        $ test_lengthNatural (maxWord64 * 2)+    , testCase "lengthNatural (10 ^ maxWordDigits32 - 1)"+        $ test_lengthNatural (10 ^ maxWordDigits32 - 1)+    , testCase "lengthNatural (10 ^ maxWordDigits64 - 1)"+        $ test_lengthNatural (10 ^ maxWordDigits64 - 1)+    , testProperty "lengthNatural = length . show" property_lengthNatural++    , testCase "lengthNaturalHex maxInt64" $ test_lengthNaturalHex maxInt64+    , testCase "lengthNaturalHex maxWord64" $ test_lengthNaturalHex maxWord64+    , testCase "lengthNaturalHex (maxWord64 * 2)"+        $ test_lengthNaturalHex (maxWord64 * 2)+    , testCase "lengthNaturalHex (10 ^ maxWordDigits32hex - 1)"+        $ test_lengthNaturalHex (16 ^ maxWordDigits32hex - 1)+    , testCase "lengthNaturalHex (10 ^ maxWordDigits64hex - 1)"+        $ test_lengthNaturalHex (16 ^ maxWordDigits64hex - 1)+    , testProperty "lengthNaturalHex = length . show" property_lengthNaturalHex+    ]+  where+    maxInt64 = fromIntegral (maxBound :: Int64)+    maxWord64 = fromIntegral (maxBound :: Word64)+    maxWordDigits32 = 10 :: Int+    maxWordDigits64 = 20 :: Int+    maxWordDigits32hex = 8 :: Int+    maxWordDigits64hex = 16 :: Int++numberLengthDec :: Natural -> Int+numberLengthDec = List.length . show++numberLengthHex :: Natural -> Int+numberLengthHex n = List.length (printf "%x" n :: String)++(<==>) :: Eq b => (a -> b) -> (a -> b) -> a -> Bool+(<==>) = liftA2 (==)++test_lengthNatural, test_lengthNaturalHex :: Natural -> Assertion+test_lengthNatural n = lengthNatural n @?= numberLengthDec n+test_lengthNaturalHex n = lengthNaturalHex n @?= numberLengthHex n++property_lengthNatural, property_lengthNaturalHex :: Natural -> Bool+property_lengthNatural = lengthNatural <==> numberLengthDec+property_lengthNaturalHex = lengthNaturalHex <==> numberLengthHex

@@ -1,4 +1,6 @@+{-# LANGUAGE CPP #-} {-# LANGUAGE NoImplicitPrelude #-}+{-# LANGUAGE NoMonomorphismRestriction #-} -- | -- Module:       Main -- Description:  Benchmarks for low-level functions.@@ -12,9 +14,11 @@ module Main (main)   where -import Prelude (Bounded(minBound, maxBound))+import Prelude (Bounded(minBound, maxBound), Num((*)), fromIntegral)  import Data.Function (($))+import Data.Int (Int64)+import Data.Word (Word64) import System.IO (IO)  import Criterion.Main (bench, defaultMain, nf)@@ -31,6 +35,16 @@     , lengthInt8hex     , lengthIntHex     )+import Data.NumberLength.Integer+    ( lengthInteger+    , lengthIntegerHex+    )+#ifdef HAVE_NATURAL+import Data.NumberLength.Natural+    ( lengthNatural+    , lengthNaturalHex+    )+#endif import Data.NumberLength.Word     ( lengthWord     , lengthWord16@@ -88,6 +102,32 @@     , bench "lengthInt64hex maxBound" $ nf lengthInt64hex maxBound  +    , bench "lengthInteger minInt64"           $ nf lengthInteger minInt64+    , bench "lengthInteger 0"                  $ nf lengthInteger 0+    , bench "lengthInteger maxInt64"           $ nf lengthInteger maxInt64+    , bench "lengthInteger maxWord64"          $ nf lengthInteger maxWord64+    , bench "lengthInteger (maxWord64 * 2)"    $ nf lengthInteger maxWord64x2++    , bench "lengthIntegerHex minInt64"        $ nf lengthIntegerHex minInt64+    , bench "lengthIntegerHex 0"               $ nf lengthIntegerHex 0+    , bench "lengthIntegerHex minInt64"        $ nf lengthIntegerHex maxInt64+    , bench "lengthIntegerHex maxWord64"       $ nf lengthIntegerHex maxWord64+    , bench "lengthIntegerHex (maxWord64 * 2)" $ nf lengthIntegerHex maxWord64x2+++#ifdef HAVE_NATURAL+    , bench "lengthNatural 0"                  $ nf lengthNatural 0+    , bench "lengthNatural maxInt64"           $ nf lengthNatural maxInt64+    , bench "lengthNatural maxWord64"          $ nf lengthNatural maxInt64+    , bench "lengthNatural (maxWord64 * 2)"    $ nf lengthNatural maxWord64x2++    , bench "lengthNaturalHex 0"               $ nf lengthNaturalHex 0+    , bench "lengthNaturalHex minInt64"        $ nf lengthNaturalHex maxInt64+    , bench "lengthNaturalHex maxWord64"       $ nf lengthNaturalHex maxWord64+    , bench "lengthNaturalHex (maxWord64 * 2)" $ nf lengthNaturalHex maxWord64x2+#endif++     , bench "lengthWord 0"        $ nf lengthWord 0     , bench "lengthWord maxBound" $ nf lengthWord maxBound @@ -118,3 +158,8 @@     , bench "lengthWord64hex 0"        $ nf lengthWord64hex 0     , bench "lengthWord64hex maxBound" $ nf lengthWord64hex maxBound     ]+  where+    maxInt64 = fromIntegral (maxBound :: Int64)+    minInt64 = fromIntegral (minBound :: Int64)+    maxWord64 = fromIntegral (maxBound :: Word64)+    maxWord64x2 = maxWord64 * 2