Large refactor with passing tests

1 files changed, 0 insertions, 61 deletions

diff --git a/src/VeriFuzz/Random.hs b/src/VeriFuzz/Random.hs
deleted file mode 100644
index 947f74e..0000000
--- a/src/VeriFuzz/Random.hs
+++ /dev/null
@@ -1,61 +0,0 @@
-{-|
-Module      : VeriFuzz.Random
-Description : Random generation for DAG
-Copyright   : (c) 2018-2019, Yann Herklotz
-License     : BSD-3
-Maintainer  : ymherklotz [at] gmail [dot] com
-Stability   : experimental
-Portability : POSIX
-
-Define the random generation for the directed acyclic graph.
--}
-
-module VeriFuzz.Random where
-
-import           Data.Graph.Inductive              (Context)
-import qualified Data.Graph.Inductive              as G
-import           Data.Graph.Inductive.PatriciaTree (Gr)
-import           Data.List                         (nub)
-import           Hedgehog                          (Gen)
-import qualified Hedgehog.Gen                      as Hog
-import qualified Hedgehog.Range                    as Hog
-import           VeriFuzz.Circuit
-
-dupFolder :: (Eq a, Eq b) => Context a b -> [Context a b] -> [Context a b]
-dupFolder cont ns = unique cont : ns
-    where unique (a, b, c, d) = (nub a, b, c, nub d)
-
--- | Remove duplicates.
-rDups :: (Eq a, Eq b) => Gr a b -> Gr a b
-rDups g = G.buildGr $ G.ufold dupFolder [] g
-
--- | Remove duplicates.
-rDupsCirc :: Circuit -> Circuit
-rDupsCirc = Circuit . rDups . getCircuit
-
--- | Gen instance to create an arbitrary edge, where the edges are limited by
--- `n` that is passed to it.
-arbitraryEdge :: Hog.Size -> Gen CEdge
-arbitraryEdge n = do
-    x <- with $ \a -> a < n && a > 0 && a /= n - 1
-    y <- with $ \a -> x < a && a < n && a > 0
-    return $ CEdge (fromIntegral x, fromIntegral y, ())
-  where
-    with = flip Hog.filter $ fromIntegral <$> Hog.resize
-        n
-        (Hog.int (Hog.linear 0 100))
-
--- | Gen instance for a random acyclic DAG.
-randomDAG :: Gen Circuit -- ^ The generated graph. It uses Arbitrary to generate
-                         -- random instances of each node
-randomDAG = do
-    list <- Hog.list (Hog.linear 1 100) $ Hog.enum minBound maxBound
-    l    <- Hog.list (Hog.linear 10 1000) aE
-    return . Circuit $ G.mkGraph (nodes list) l
-  where
-    nodes l = zip [0 .. length l - 1] l
-    aE = getCEdge <$> Hog.sized arbitraryEdge
-
--- | Generate a random acyclic DAG with an IO instance.
-genRandomDAG :: IO Circuit
-genRandomDAG = Hog.sample randomDAG