{-# OPTIONS_GHC -F -pgmF htfpp -Wno-overlapping-patterns #-}
{-# OPTIONS_HADDOCK prune #-}
{-# LANGUAGE TemplateHaskell #-}

module Striot.Partition ( allPartitions
                        , singleton

                        , htf_thisModulesTests
                        ) where

import Striot.StreamGraph

import Algebra.Graph
import Algebra.Graph.ToGraph (reachable)
import Test.Framework

-- | Return a list of all possible valid partitionings of the `StreamGraph`.
-- A partitioning is a list of groupings of `Int`s corresponding to `vertexID`s
-- for the `StreamGraph`.
--
-- A valid partitioning is any which does not violate the following constraints:
--  * only one `Source` or `Sink` node can exist in each partition
--  * `Merge` operators must be the first in their partition
--
-- The validity rules are encoded in the `extendPartitioning` function.
allPartitions :: StreamGraph -> [[[Int]]]
allPartitions :: StreamGraph -> [[[Int]]]
allPartitions = (([[StreamVertex]] -> [[Int]]) -> [[[StreamVertex]]] -> [[[Int]]]
forall a b. (a -> b) -> [a] -> [b]
map(([[StreamVertex]] -> [[Int]]) -> [[[StreamVertex]]] -> [[[Int]]])
-> ((StreamVertex -> Int) -> [[StreamVertex]] -> [[Int]])
-> (StreamVertex -> Int)
-> [[[StreamVertex]]]
-> [[[Int]]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.([StreamVertex] -> [Int]) -> [[StreamVertex]] -> [[Int]]
forall a b. (a -> b) -> [a] -> [b]
map(([StreamVertex] -> [Int]) -> [[StreamVertex]] -> [[Int]])
-> ((StreamVertex -> Int) -> [StreamVertex] -> [Int])
-> (StreamVertex -> Int)
-> [[StreamVertex]]
-> [[Int]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(StreamVertex -> Int) -> [StreamVertex] -> [Int]
forall a b. (a -> b) -> [a] -> [b]
map) StreamVertex -> Int
vertexId ([[[StreamVertex]]] -> [[[Int]]])
-> (StreamGraph -> [[[StreamVertex]]]) -> StreamGraph -> [[[Int]]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([[[StreamVertex]]] -> StreamVertex -> [[[StreamVertex]]])
-> [[[StreamVertex]]] -> StreamGraph -> [[[StreamVertex]]]
forall a b. (Eq a, Ord a) => (b -> a -> b) -> b -> Graph a -> b
foldgl [[[StreamVertex]]] -> StreamVertex -> [[[StreamVertex]]]
fun [] (StreamGraph -> [[[StreamVertex]]])
-> (StreamGraph -> StreamGraph)
-> StreamGraph
-> [[[StreamVertex]]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StreamGraph -> StreamGraph
forall a. Graph a -> Graph a
transpose
    where
        fun :: [[[StreamVertex]]] -> StreamVertex -> [[[StreamVertex]]]
fun []      StreamVertex
n = [[[StreamVertex
n]]]
        fun [[[StreamVertex]]]
choices StreamVertex
n = ([[StreamVertex]] -> [[[StreamVertex]]])
-> [[[StreamVertex]]] -> [[[StreamVertex]]]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (StreamVertex -> [[StreamVertex]] -> [[[StreamVertex]]]
extendPartitioning StreamVertex
n) [[[StreamVertex]]]
choices

-- The maximum length of a PartitionMap generated by allPartitions never
-- exceeds the number of operators in the StreamGraph. Note: this triggers
-- an "overlapping patterns" warning from GHC, since 'g' matches 'empty',
-- so the OPTIONS_GHC line above disables that check for this module.
prop_allPartitions_maxlength :: StreamGraph -> Bool
prop_allPartitions_maxlength StreamGraph
empty = Bool
True
prop_allPartitions_maxlength StreamGraph
g = let
    numOperators :: Int
numOperators = ([StreamVertex] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ([StreamVertex] -> Int)
-> (StreamGraph -> [StreamVertex]) -> StreamGraph -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StreamGraph -> [StreamVertex]
forall a. Ord a => Graph a -> [a]
vertexList) StreamGraph
g
    maxLength :: Int
maxLength    = ([Int] -> Int
forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
maximum ([Int] -> Int) -> (StreamGraph -> [Int]) -> StreamGraph -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([[Int]] -> Int) -> [[[Int]]] -> [Int]
forall a b. (a -> b) -> [a] -> [b]
map [[Int]] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ([[[Int]]] -> [Int])
-> (StreamGraph -> [[[Int]]]) -> StreamGraph -> [Int]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StreamGraph -> [[[Int]]]
allPartitions) StreamGraph
g
    in Int
maxLength Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
numOperators

-- | A left-fold over Graphs. Unlike 'foldg', the traversal order follows
-- edges from a root node.
--
-- XXX could we rework this in terms of subGraph, instead of subGraphs?
-- Caveat: when the incoming graph is e.g. overlay x y, getRoot returns
-- one of x or y, and subGraphs returns [], so we lose the other branch
foldgl :: Eq a => Ord a =>
               (b -> a -> b) -> b -> Graph a -> b
foldgl :: forall a b. (Eq a, Ord a) => (b -> a -> b) -> b -> Graph a -> b
foldgl b -> a -> b
f b
z Graph a
g =
    if Graph a -> Bool
forall a. Graph a -> Bool
isEmpty Graph a
g then b
z
    else let x :: a
x  = Graph a -> a
forall a. (Eq a, Ord a) => Graph a -> a
getRoot Graph a
g     -- :: a
             xs :: [Graph a]
xs = a -> Graph a -> [Graph a]
forall a. Ord a => a -> Graph a -> [Graph a]
subGraphs a
x Graph a
g -- [Graph a]
         in (b -> Graph a -> b) -> b -> [Graph a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (\b
b Graph a
g -> (b -> a -> b) -> b -> Graph a -> b
forall a b. (Eq a, Ord a) => (b -> a -> b) -> b -> Graph a -> b
foldgl b -> a -> b
f b
b Graph a
g) (b -> a -> b
f b
z a
x) [Graph a]
xs

test_foldgl1 :: IO ()
test_foldgl1 = TestID -> TestID -> IO ()
forall a. (Eq a, Show a, HasCallStack) => a -> a -> IO ()
assertEqual TestID
"ABC" (TestID -> IO ()) -> TestID -> IO ()
forall a b. (a -> b) -> a -> b
$
    (TestID -> Char -> TestID) -> TestID -> Graph Char -> TestID
forall a b. (Eq a, Ord a) => (b -> a -> b) -> b -> Graph a -> b
foldgl (\TestID
b Char
a -> TestID
bTestID -> TestID -> TestID
forall a. [a] -> [a] -> [a]
++[Char
a]) TestID
"" (TestID -> Graph Char
forall a. [a] -> Graph a
path TestID
"ABC")
test_foldgl2 :: IO ()
test_foldgl2 = TestID -> TestID -> IO ()
forall a. (Eq a, Show a, HasCallStack) => a -> a -> IO ()
assertEqual TestID
"ABCD" (TestID -> IO ()) -> TestID -> IO ()
forall a b. (a -> b) -> a -> b
$
    (TestID -> Char -> TestID) -> TestID -> Graph Char -> TestID
forall a b. (Eq a, Ord a) => (b -> a -> b) -> b -> Graph a -> b
foldgl (\TestID
b Char
a -> TestID
bTestID -> TestID -> TestID
forall a. [a] -> [a] -> [a]
++[Char
a]) TestID
"" (Graph Char -> Graph Char -> Graph Char
forall a. Graph a -> Graph a -> Graph a
overlay (TestID -> Graph Char
forall a. [a] -> Graph a
path TestID
"ABC") (TestID -> Graph Char
forall a. [a] -> Graph a
path TestID
"BD"))

getRoots :: Eq a => Ord a =>
            Graph a -> [a]
getRoots :: forall a. (Eq a, Ord a) => Graph a -> [a]
getRoots Graph a
g = let
    edges :: [(a, a)]
edges = Graph a -> [(a, a)]
forall a. Ord a => Graph a -> [(a, a)]
edgeList Graph a
g
    dests :: [a]
dests = ((a, a) -> a) -> [(a, a)] -> [a]
forall a b. (a -> b) -> [a] -> [b]
map (a, a) -> a
forall a b. (a, b) -> b
snd [(a, a)]
edges
    roots :: [a]
roots = (a -> Bool) -> [a] -> [a]
forall a. (a -> Bool) -> [a] -> [a]
filter (Bool -> Bool
not(Bool -> Bool) -> (a -> Bool) -> a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem`[a]
dests)) (Graph a -> [a]
forall a. Ord a => Graph a -> [a]
vertexList Graph a
g)
    in [a]
roots

getRoot :: Eq a => Ord a =>
           Graph a -> a
getRoot :: forall a. (Eq a, Ord a) => Graph a -> a
getRoot = [a] -> a
forall a. [a] -> a
head ([a] -> a) -> (Graph a -> [a]) -> Graph a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Graph a -> [a]
forall a. (Eq a, Ord a) => Graph a -> [a]
getRoots

subGraphs :: Ord a =>
             a -> Graph a -> [Graph a]
subGraphs :: forall a. Ord a => a -> Graph a -> [Graph a]
subGraphs a
n Graph a
g = (a -> Graph a) -> [a] -> [Graph a]
forall a b. (a -> b) -> [a] -> [b]
map (\a
k -> a -> Graph a -> Graph a
forall a. (Eq a, Ord a) => a -> Graph a -> Graph a
subGraph a
k Graph a
g) (a -> Graph a -> [a]
forall a. Ord a => a -> Graph a -> [a]
childrenOf a
n Graph a
g)

test_subGraphs1 :: IO ()
test_subGraphs1 = [Graph Integer] -> [Graph Integer] -> IO ()
forall a. (Eq a, Show a, HasCallStack) => a -> a -> IO ()
assertEqual (Integer -> Graph Integer -> [Graph Integer]
forall a. Ord a => a -> Graph a -> [Graph a]
subGraphs Integer
2 Graph Integer
t2) [Integer -> Graph Integer
forall a. a -> Graph a
Vertex Integer
v | Integer
v <- [Integer
3,Integer
4]]
test_subGraphs2 :: IO ()
test_subGraphs2 = [Graph Integer] -> [Graph Integer] -> IO ()
forall a. (Eq a, Show a, HasCallStack) => a -> a -> IO ()
assertEqual (Integer -> Graph Integer -> [Graph Integer]
forall a. Ord a => a -> Graph a -> [Graph a]
subGraphs Integer
3 Graph Integer
t2) []
test_subGraphs3 :: IO ()
test_subGraphs3 = [Graph Integer] -> [Graph Integer] -> IO ()
forall a. (Eq a, Show a, HasCallStack) => a -> a -> IO ()
assertEqual (Integer -> Graph Integer -> [Graph Integer]
forall a. Ord a => a -> Graph a -> [Graph a]
subGraphs Integer
1 Graph Integer
t1) [[Integer] -> Graph Integer
forall a. [a] -> Graph a
path [Integer
2,Integer
3]]
test_subGraphs4 :: IO ()
test_subGraphs4 = [Graph Integer] -> [Graph Integer] -> IO ()
forall a. (Eq a, Show a, HasCallStack) => a -> a -> IO ()
assertEqual (Integer -> Graph Integer -> [Graph Integer]
forall a. Ord a => a -> Graph a -> [Graph a]
subGraphs Integer
1 Graph Integer
t2) [Integer -> Graph Integer -> Graph Integer
forall a. Eq a => a -> Graph a -> Graph a
removeVertex Integer
1 Graph Integer
t2]

v0 :: StreamVertex
v0 = Int
-> StreamOperator
-> [ExpQ]
-> TestID
-> TestID
-> Double
-> StreamVertex
StreamVertex Int
0 (Double -> StreamOperator
Source Double
1) [] TestID
"" TestID
"" Double
0
v1 :: StreamVertex
v1 = Int
-> StreamOperator
-> [ExpQ]
-> TestID
-> TestID
-> Double
-> StreamVertex
StreamVertex Int
1 StreamOperator
Map [] TestID
"" TestID
"" Double
1
v2 :: StreamVertex
v2 = Int
-> StreamOperator
-> [ExpQ]
-> TestID
-> TestID
-> Double
-> StreamVertex
StreamVertex Int
2 StreamOperator
Sink [] TestID
"" TestID
"" Double
2 
v3 :: StreamVertex
v3 = Int
-> StreamOperator
-> [ExpQ]
-> TestID
-> TestID
-> Double
-> StreamVertex
StreamVertex Int
3 (Double -> StreamOperator
Source Double
1) [] TestID
"" TestID
"" Double
3
v4 :: StreamVertex
v4 = Int
-> StreamOperator
-> [ExpQ]
-> TestID
-> TestID
-> Double
-> StreamVertex
StreamVertex Int
4 StreamOperator
Merge [] TestID
"" TestID
"" Double
4
v5 :: StreamVertex
v5 = Int
-> StreamOperator
-> [ExpQ]
-> TestID
-> TestID
-> Double
-> StreamVertex
StreamVertex Int
5 StreamOperator
Map [] TestID
"" TestID
"" Double
5
g3 :: StreamGraph
g3 = StreamGraph -> StreamGraph -> StreamGraph
forall a. Graph a -> Graph a -> Graph a
overlay ([StreamVertex] -> StreamGraph
forall a. [a] -> Graph a
path [StreamVertex
v0, StreamVertex
v1, StreamVertex
v4, StreamVertex
v2]) ([StreamVertex] -> StreamGraph
forall a. [a] -> Graph a
path [StreamVertex
v3, StreamVertex
v5, StreamVertex
v4])
g4 :: StreamGraph
g4 = StreamGraph -> StreamGraph
forall a. Graph a -> Graph a
transpose StreamGraph
g3

test_subGraphs5 :: IO ()
test_subGraphs5 = let
    g :: StreamGraph
g = [StreamGraph] -> StreamGraph
forall a. [a] -> a
head ([StreamGraph] -> StreamGraph) -> [StreamGraph] -> StreamGraph
forall a b. (a -> b) -> a -> b
$ StreamVertex -> StreamGraph -> [StreamGraph]
forall a. Ord a => a -> Graph a -> [Graph a]
subGraphs (StreamGraph -> StreamVertex
forall a. (Eq a, Ord a) => Graph a -> a
getRoot StreamGraph
g4) StreamGraph
g4
    in HasCallStack => Bool -> IO ()
Bool -> IO ()
assertBool (Bool -> IO ()) -> Bool -> IO ()
forall a b. (a -> b) -> a -> b
$ StreamVertex
v0 StreamVertex -> [StreamVertex] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` (StreamGraph -> [StreamVertex]
forall a. Ord a => Graph a -> [a]
vertexList StreamGraph
g)

subGraph :: Eq a => Ord a =>
            a -> Graph a -> Graph a
subGraph :: forall a. (Eq a, Ord a) => a -> Graph a -> Graph a
subGraph a
n Graph a
g = (a -> Bool) -> Graph a -> Graph a
forall a. (a -> Bool) -> Graph a -> Graph a
induce (a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` ToVertex (Graph a) -> Graph a -> [ToVertex (Graph a)]
forall t.
(ToGraph t, Ord (ToVertex t)) =>
ToVertex t -> t -> [ToVertex t]
reachable a
ToVertex (Graph a)
n Graph a
g) Graph a
g

t1 :: Graph Integer
t1 = [Integer] -> Graph Integer
forall a. [a] -> Graph a
path [Integer
1,Integer
2,Integer
3]
test_subGraph1 :: IO ()
test_subGraph1 = Graph Integer -> Graph Integer -> IO ()
forall a. (Eq a, Show a, HasCallStack) => a -> a -> IO ()
assertEqual (Integer -> Graph Integer -> Graph Integer
forall a. (Eq a, Ord a) => a -> Graph a -> Graph a
subGraph Integer
1 Graph Integer
t1) (Graph Integer -> IO ()) -> Graph Integer -> IO ()
forall a b. (a -> b) -> a -> b
$ Graph Integer
t1
test_subGraph2 :: IO ()
test_subGraph2 = Graph Integer -> Graph Integer -> IO ()
forall a. (Eq a, Show a, HasCallStack) => a -> a -> IO ()
assertEqual (Integer -> Graph Integer -> Graph Integer
forall a. (Eq a, Ord a) => a -> Graph a -> Graph a
subGraph Integer
2 Graph Integer
t1) (Graph Integer -> IO ()) -> Graph Integer -> IO ()
forall a b. (a -> b) -> a -> b
$ [Integer] -> Graph Integer
forall a. [a] -> Graph a
path [Integer
2,Integer
3]
test_subGraph3 :: IO ()
test_subGraph3 = Graph Integer -> Graph Integer -> IO ()
forall a. (Eq a, Show a, HasCallStack) => a -> a -> IO ()
assertEqual (Integer -> Graph Integer -> Graph Integer
forall a. (Eq a, Ord a) => a -> Graph a -> Graph a
subGraph Integer
3 Graph Integer
t1) (Graph Integer -> IO ()) -> Graph Integer -> IO ()
forall a b. (a -> b) -> a -> b
$ Integer -> Graph Integer
forall a. a -> Graph a
Vertex Integer
3

t2 :: Graph Integer
t2 = Graph Integer
t1 Graph Integer -> Graph Integer -> Graph Integer
forall a. Num a => a -> a -> a
+ [Integer] -> Graph Integer
forall a. [a] -> Graph a
path [Integer
2,Integer
4]
test_subGraph4 :: IO ()
test_subGraph4 = Graph Integer -> Graph Integer -> IO ()
forall a. (Eq a, Show a, HasCallStack) => a -> a -> IO ()
assertEqual (Integer -> Graph Integer -> Graph Integer
forall a. (Eq a, Ord a) => a -> Graph a -> Graph a
subGraph Integer
4 Graph Integer
t2) (Graph Integer -> IO ()) -> Graph Integer -> IO ()
forall a b. (a -> b) -> a -> b
$ Integer -> Graph Integer
forall a. a -> Graph a
Vertex Integer
4
test_subGraph5 :: IO ()
test_subGraph5 = Graph Integer -> Graph Integer -> IO ()
forall a. (Eq a, Show a, HasCallStack) => a -> a -> IO ()
assertEqual (Integer -> Graph Integer -> Graph Integer
forall a. (Eq a, Ord a) => a -> Graph a -> Graph a
subGraph Integer
2 Graph Integer
t2) (Graph Integer -> IO ()) -> Graph Integer -> IO ()
forall a b. (a -> b) -> a -> b
$ [Integer] -> Graph Integer
forall a. [a] -> Graph a
path [Integer
2,Integer
4] Graph Integer -> Graph Integer -> Graph Integer
forall a. Num a => a -> a -> a
+ [Integer] -> Graph Integer
forall a. [a] -> Graph a
path [Integer
2,Integer
3]

childrenOf :: Ord a =>
              a -> Graph a -> [a]
childrenOf :: forall a. Ord a => a -> Graph a -> [a]
childrenOf a
n = ((a, a) -> a) -> [(a, a)] -> [a]
forall a b. (a -> b) -> [a] -> [b]
map (a, a) -> a
forall a b. (a, b) -> b
snd ([(a, a)] -> [a]) -> (Graph a -> [(a, a)]) -> Graph a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((a, a) -> Bool) -> [(a, a)] -> [(a, a)]
forall a. (a -> Bool) -> [a] -> [a]
filter ((a -> a -> Bool
forall a. Eq a => a -> a -> Bool
==a
n)(a -> Bool) -> ((a, a) -> a) -> (a, a) -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(a, a) -> a
forall a b. (a, b) -> a
fst) ([(a, a)] -> [(a, a)])
-> (Graph a -> [(a, a)]) -> Graph a -> [(a, a)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Graph a -> [(a, a)]
forall a. Ord a => Graph a -> [(a, a)]
edgeList

-- | Given an existing partitioning and a new operator to consider: We can
-- start a new partition; in some circumstances we can also append the operator
-- to the last partition.
extendPartitioning :: StreamVertex -> [[StreamVertex]] -> [[[StreamVertex]]]
extendPartitioning :: StreamVertex -> [[StreamVertex]] -> [[[StreamVertex]]]
extendPartitioning StreamVertex
n [[StreamVertex]]
choice = let
  lastNode :: StreamVertex
lastNode = [StreamVertex] -> StreamVertex
forall a. [a] -> a
last ([StreamVertex] -> StreamVertex)
-> ([[StreamVertex]] -> [StreamVertex])
-> [[StreamVertex]]
-> StreamVertex
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[StreamVertex]] -> [StreamVertex]
forall a. [a] -> a
last ([[StreamVertex]] -> StreamVertex)
-> [[StreamVertex]] -> StreamVertex
forall a b. (a -> b) -> a -> b
$ [[StreamVertex]]
choice
  in if Int
1 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< ([StreamVertex] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ((StreamVertex -> Bool) -> [StreamVertex] -> [StreamVertex]
forall a. (a -> Bool) -> [a] -> [a]
filter StreamVertex -> Bool
singleton (StreamVertex
nStreamVertex -> [StreamVertex] -> [StreamVertex]
forall a. a -> [a] -> [a]
:([[StreamVertex]] -> [StreamVertex]
forall a. [a] -> a
last [[StreamVertex]]
choice))))
     Bool -> Bool -> Bool
|| (StreamVertex -> StreamOperator
operator StreamVertex
lastNode StreamOperator -> StreamOperator -> Bool
forall a. Eq a => a -> a -> Bool
== StreamOperator
Merge Bool -> Bool -> Bool
|| StreamOperator -> Bool
isSource (StreamVertex -> StreamOperator
operator StreamVertex
lastNode))
     then [ [[StreamVertex]]
choice [[StreamVertex]] -> [[StreamVertex]] -> [[StreamVertex]]
forall a. [a] -> [a] -> [a]
++ [[StreamVertex
n]] ]
     else [ [[StreamVertex]]
choice [[StreamVertex]] -> [[StreamVertex]] -> [[StreamVertex]]
forall a. [a] -> [a] -> [a]
++ [[StreamVertex
n]]
          , [[StreamVertex]] -> [[StreamVertex]]
forall a. [a] -> [a]
init [[StreamVertex]]
choice [[StreamVertex]] -> [[StreamVertex]] -> [[StreamVertex]]
forall a. [a] -> [a] -> [a]
++ [[[StreamVertex]] -> [StreamVertex]
forall a. [a] -> a
last [[StreamVertex]]
choice [StreamVertex] -> [StreamVertex] -> [StreamVertex]
forall a. [a] -> [a] -> [a]
++ [StreamVertex
n]]
          ]

singleton :: StreamVertex -> Bool
singleton StreamVertex
v = StreamVertex -> StreamOperator
operator StreamVertex
v StreamOperator -> StreamOperator -> Bool
forall a. Eq a => a -> a -> Bool
== StreamOperator
Sink Bool -> Bool -> Bool
|| StreamOperator -> Bool
isSource (StreamVertex -> StreamOperator
operator StreamVertex
v)

g' :: StreamGraph
g' = [StreamVertex] -> StreamGraph
forall a. [a] -> Graph a
path [ StreamVertex
v0 , StreamVertex
v1 , StreamVertex
v2 ]
test_g' :: IO ()
test_g' = [[[Int]]] -> [[[Int]]] -> IO ()
forall a. (Eq a, Show a, HasCallStack) => a -> a -> IO ()
assertEqual [ [[Int
2],[Int
1],[Int
0]]
                      , [[Int
2],[Int
1,Int
0]]
                      , [[Int
2,Int
1],[Int
0]]]
    ([[[Int]]] -> IO ()) -> [[[Int]]] -> IO ()
forall a b. (a -> b) -> a -> b
$ StreamGraph -> [[[Int]]]
allPartitions StreamGraph
g'

g2 :: StreamGraph
g2 = StreamGraph -> StreamGraph -> StreamGraph
forall a. Graph a -> Graph a -> Graph a
overlay ([StreamVertex] -> StreamGraph
forall a. [a] -> Graph a
path [StreamVertex
v0, StreamVertex
v4, StreamVertex
v2]) ([StreamVertex] -> StreamGraph
forall a. [a] -> Graph a
path [StreamVertex
v3, StreamVertex
v4])

test_g2 :: IO ()
test_g2 = [[[Int]]] -> [[[Int]]] -> IO ()
forall a. (Eq a, Show a, HasCallStack) => a -> a -> IO ()
assertEqual [ [[Int
2],[Int
4],[Int
0],[Int
3]]
                      , [[Int
2,Int
4],[Int
0],[Int
3]]]
    ([[[Int]]] -> IO ()) -> [[[Int]]] -> IO ()
forall a b. (a -> b) -> a -> b
$ StreamGraph -> [[[Int]]]
allPartitions StreamGraph
g2

test_g3 :: IO ()
test_g3 = [[[Int]]] -> [[[Int]]] -> IO ()
forall a. (Eq a, Show a, HasCallStack) => a -> a -> IO ()
assertEqual
    [ [[Int
2],[Int
4],[Int
1],[Int
0],[Int
5],[Int
3]]
    , [[Int
2],[Int
4],[Int
1],[Int
0],[Int
5,Int
3]]
    , [[Int
2],[Int
4],[Int
1,Int
0],[Int
5],[Int
3]]
    , [[Int
2],[Int
4],[Int
1,Int
0],[Int
5,Int
3]]
    , [[Int
2,Int
4],[Int
1],[Int
0],[Int
5],[Int
3]]
    , [[Int
2,Int
4],[Int
1],[Int
0],[Int
5,Int
3]]
    , [[Int
2,Int
4],[Int
1,Int
0],[Int
5],[Int
3]]
    , [[Int
2,Int
4],[Int
1,Int
0],[Int
5,Int
3]]
    ] ([[[Int]]] -> IO ()) -> [[[Int]]] -> IO ()
forall a b. (a -> b) -> a -> b
$ StreamGraph -> [[[Int]]]
allPartitions StreamGraph
g3

main :: IO ()
main = TestSuite -> IO ()
forall t. TestableHTF t => t -> IO ()
htfMain htf_thisModulesTests