1 files changed, 67 insertions, 0 deletions
diff --git a/src/Verismith/Circuit/Random.hs b/src/Verismith/Circuit/Random.hs
new file mode 100644
index 0000000..0eabf56
--- /dev/null
+++ b/src/Verismith/Circuit/Random.hs
@@ -0,0 +1,67 @@
+{-|
+Module      : Verismith.Circuit.Random
+Description : Random generation for DAG
+Copyright   : (c) 2018-2019, Yann Herklotz
+License     : BSD-3
+Maintainer  : yann [at] yannherklotz [dot] com
+Stability   : experimental
+Portability : POSIX
+
+Define the random generation for the directed acyclic graph.
+-}
+
+module Verismith.Circuit.Random
+    ( rDups
+    , rDupsCirc
+    , randomDAG
+    , genRandomDAG
+    )
+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           Verismith.Circuit.Base
+
+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