Exhaustive tests, update documentation

Author: sharkdp

docs/Data/BigInt.md

@@ -1,5 +1,7 @@
 ## Module Data.BigInt
 
+This module defines a `BigInt` data type for arbitrary length integers.
+
 #### `BigInt`
 
 ``` purescript
@@ -41,7 +43,7 @@ large.
 pow :: BigInt -> BigInt -> BigInt
 ```
 
-Exponentiation for BigInt. If the exponent is less than 0, `pow`
+Exponentiation for `BigInt`. If the exponent is less than 0, `pow`
 returns 0. Also, `pow zero zero == one`.
 
 #### `abs`
@@ -50,7 +52,7 @@ returns 0. Also, `pow zero zero == one`.
 abs :: BigInt -> BigInt
 ```
 
-The absolute value of a BigInt
+The absolute value.
 
 #### `even`
 
@@ -82,7 +84,7 @@ Returns `true` if the number is prime, `false` otherwise.
 fromString :: String -> Maybe BigInt
 ```
 
-Parse a string into a BigInt, assuming a decimal representation. Returns
+Parse a string into a `BigInt`, assuming a decimal representation. Returns
 `Nothing` if the parse fails.
 
 Examples:
@@ -98,8 +100,8 @@ fromString "1e100"
 fromBase :: Int -> String -> Maybe BigInt
 ```
 
-Parse a string into a BigInt, assuming a representation in the given base.
-The letters "a-z" and "A-Z" will be interpreted as the numbers `10` to
+Parse a string into a `BigInt`, assuming a representation in the given base.
+The letters "a-z" and "A-Z" will be interpreted as the digits `10` to
 `36`. Returns `Nothing` if the parse fails.
 
 ```purescript
@@ -113,6 +115,6 @@ fromBase 16 "ff" == fromString "255"
 toString :: BigInt -> String
 ```
 
-A textual representation of the BigInt.
+A decimal representation of the `BigInt` as a `String`.
 
 

src/Data/BigInt.purs

@@ -1,3 +1,4 @@
+-- | This module defines a `BigInt` data type for arbitrary length integers.
 module Data.BigInt
   ( BigInt(..)
   , fromString
@@ -33,11 +34,11 @@ foreign import fromInt :: Int -> BigInt
 -- | large.
 foreign import toNumber :: BigInt -> Number
 
--- | Exponentiation for BigInt. If the exponent is less than 0, `pow`
+-- | Exponentiation for `BigInt`. If the exponent is less than 0, `pow`
 -- | returns 0. Also, `pow zero zero == one`.
 foreign import pow :: BigInt -> BigInt -> BigInt
 
--- | The absolute value of a BigInt
+-- | The absolute value.
 foreign import abs :: BigInt -> BigInt
 
 -- | Returns `true` if the number is even, `false` otherwise.
@@ -49,7 +50,7 @@ foreign import odd :: BigInt -> Boolean
 -- | Returns `true` if the number is prime, `false` otherwise.
 foreign import prime :: BigInt -> Boolean
 
--- | Parse a string into a BigInt, assuming a decimal representation. Returns
+-- | Parse a string into a `BigInt`, assuming a decimal representation. Returns
 -- | `Nothing` if the parse fails.
 -- |
 -- | Examples:
@@ -61,8 +62,8 @@ foreign import prime :: BigInt -> Boolean
 fromString :: String -> Maybe BigInt
 fromString = fromBase 10
 
--- | Parse a string into a BigInt, assuming a representation in the given base.
--- | The letters "a-z" and "A-Z" will be interpreted as the numbers `10` to
+-- | Parse a string into a `BigInt`, assuming a representation in the given base.
+-- | The letters "a-z" and "A-Z" will be interpreted as the digits `10` to
 -- | `36`. Returns `Nothing` if the parse fails.
 -- |
 -- | ```purescript
@@ -77,7 +78,6 @@ foreign import biEquals :: BigInt -> BigInt -> Boolean
 instance eqBigInt :: Eq BigInt where
   eq = biEquals
 
-
 foreign import biCompare :: BigInt -> BigInt -> Int
 
 instance ordBigInt :: Ord BigInt where
@@ -86,7 +86,7 @@ instance ordBigInt :: Ord BigInt where
                   0  -> EQ
                   -1 -> LT
 
--- | A textual representation of the BigInt.
+-- | A decimal representation of the `BigInt` as a `String`.
 foreign import toString :: BigInt -> String
 
 instance showBigInt :: Show BigInt where

test/Main.purs

@@ -1,14 +1,16 @@
 module Test.Main where
 
+import Prelude
 import Control.Monad.Eff.Console (log)
+import Data.Array (filter, range)
 import Data.BigInt
-import Data.Maybe
+import Data.Foldable (mconcat)
+import Data.Maybe (Maybe(..))
 import Data.Maybe.Unsafe (fromJust)
-import Prelude
-import Test.Assert
-import Test.QuickCheck
-import Test.QuickCheck.Arbitrary
-import Test.QuickCheck.Gen (chooseInt)
+import Test.Assert (assert)
+import Test.QuickCheck (quickCheck)
+import Test.QuickCheck.Arbitrary (Arbitrary)
+import Test.QuickCheck.Gen (Gen(..), chooseInt, arrayOf, elements)
 import qualified Data.Int as Int
 
 -- | Newtype with an Arbitrary instance that generates only small integers
@@ -20,6 +22,17 @@ instance arbitrarySmallInt :: Arbitrary SmallInt where
 runSmallInt :: SmallInt -> Int
 runSmallInt (SmallInt n) = n
 
+-- | Arbitrary instance for BigInt
+instance arbitraryBigInt :: Arbitrary BigInt where
+  arbitrary = do
+    n <- (fromJust <<< fromString) <$> digitString
+    op <- elements id [negate]
+    return (op n)
+    where digits :: Gen Int
+          digits = chooseInt 0 9
+          digitString :: Gen String
+          digitString = (mconcat <<< map show) <$> arrayOf digits
+
 -- | Convert SmallInt to BigInt
 fromSmallInt :: SmallInt -> BigInt
 fromSmallInt = fromInt <<< runSmallInt
@@ -46,6 +59,7 @@ main = do
   assert $ fromString "2.1" == Nothing
   assert $ fromString "123456789" == Just (fromInt 123456789)
   assert $ fromString "1e7" == Just (fromInt 10000000)
+  quickCheck $ \a -> (fromString <<< toString) a == Just a
 
   log "Parsing strings with a different base"
   assert $ fromBase 2 "100" == Just four
@@ -62,18 +76,26 @@ main = do
   testBinary mod mod
   testBinary div div
 
+  -- To test the multiplication, we need to make sure that Int does not overflow
+  quickCheck (\x y -> fromSmallInt x * fromSmallInt y == fromInt (runSmallInt x * runSmallInt y))
+
   log "It should perform multiplications which would lead to imprecise results using Number"
   assert $ Just (fromInt 333190782 * fromInt 1103515245) == fromString "367681107430471590"
 
-  -- To check the multiplication, we need to make sure that the Int does not overflow
-  quickCheck (\x y -> fromSmallInt x * fromSmallInt y == fromInt (runSmallInt x * runSmallInt y))
-
-  log "compare and (==) should be the same before and after converting to BigInt"
+  log "compare, (==), even, odd should be the same before and after converting to BigInt"
   quickCheck (\x y -> compare x y == compare (fromInt x) (fromInt y))
   quickCheck (\x y -> (fromSmallInt x == fromSmallInt y) == (runSmallInt x == runSmallInt y))
+  quickCheck (\x -> Int.even x == even (fromInt x))
+  quickCheck (\x -> Int.odd x == odd (fromInt x))
 
   log "pow should perform integer exponentiation and yield 0 for negative exponents"
   assert $ three `pow` four == fromInt 81
   assert $ three `pow` -two == zero
   assert $ three `pow` zero == one
   assert $ zero `pow` zero == one
+
+  log "Prime numbers"
+  assert $ filter (prime <<< fromInt) (range 2 20) == [2, 3, 5, 7, 11, 13, 17, 19]
+
+  log "Absolute value"
+  quickCheck $ \x -> abs x == if x > zero then x else (-x)