StackedDag.Base

Documentation

type NodeId = Int

type Edges = Map NodeId (Set NodeId)

type Labels = Map NodeId String

data Symbol

Constructors

SNode String

SLeft

SRight

SHold

SLMove

SRMove

SCross

SSpace

Instances

Eq Symbol

Defined in StackedDag.Base

Methods

(==) :: Symbol -> Symbol -> Bool

(/=) :: Symbol -> Symbol -> Bool

Read Symbol

Defined in StackedDag.Base

Methods

readsPrec :: Int -> ReadS Symbol

readList :: ReadS [Symbol]

readPrec :: ReadPrec Symbol

readListPrec :: ReadPrec [Symbol]

Show Symbol

Defined in StackedDag.Base

Methods

showsPrec :: Int -> Symbol -> ShowS

show :: Symbol -> String

showList :: [Symbol] -> ShowS

Semigroup Symbol

Defined in StackedDag.Base

Methods

(<>) :: Symbol -> Symbol -> Symbol

sconcat :: NonEmpty Symbol -> Symbol

stimes :: Integral b => b -> Symbol -> Symbol

Monoid Symbol

Defined in StackedDag.Base

Methods

mempty :: Symbol

mappend :: Symbol -> Symbol -> Symbol

mconcat :: [Symbol] -> Symbol

type Nodes = Set NodeId

type Depth = Int

type Dest = Int

type Cur = Int

type Pos = Int

type DepthNode = Map NodeId Depth

type DepthGroup = Map Depth [NodeId]

type NodeDepth = Map NodeId Depth

type DepthGroup' = Map Depth ([NodeId], [NodeId])

type DepthGroup'' = Map Depth ([(NodeId, Cur, Dest)], [(NodeId, Cur, Dest)])

mkEdges :: [(NodeId, [NodeId])] -> Edges

mkLabels :: [(NodeId, String)] -> Labels

sampledat :: Edges

samplelabels :: Labels

getDepthGroup :: Edges -> DepthGroup

Grouping the nodes by the depth

>>> getDepthGroup sampledat
fromList [(0,[5]),(1,[3]),(2,[2,4,6]),(3,[0,1])]

getNodeDepth :: DepthGroup -> NodeDepth

pairs :: Map b (Set a) -> [(a, b)]

reverseEdges :: Edges -> Edges

Reverse the directions of edges

>>> sampledat
fromList [(0,fromList [2]),(1,fromList [2]),(2,fromList [3]),(3,fromList [5]),(4,fromList [3]),(6,fromList [3])]
>>> reverseEdges sampledat
fromList [(2,fromList [0,1]),(3,fromList [2,4,6]),(5,fromList [3])]

getNodes :: Edges -> Nodes

Get nodes by edges

>>> getNodes sampledat
fromList [0,1,2,3,4,5,6]

getDepth2 :: Edges -> DepthNode

getDepth2' :: STRef s DepthNode -> Int -> Edges -> ST s Int

moveOne :: [(NodeId, Cur, Dest)] -> [((NodeId, Cur, Dest), [(Symbol, Pos)])]

Move nodes to next step

>>> moveOne [(0,0,4)]
[((0,2,4),[(SRight,1)])]
>>> moveOne [(0,0,4),(0,4,0)]
[((0,2,4),[(SRight,1)]),((0,2,0),[(SLeft,3)])]

takeNode :: Cur -> [((NodeId, Cur, Dest), [(Symbol, Pos)])] -> Maybe ((NodeId, Cur, Dest), [(Symbol, Pos)])

moveLeft' :: [((NodeId, Cur, Dest), [(Symbol, Pos)])] -> [((NodeId, Cur, Dest), [(Symbol, Pos)])]

Move more nodes

>>> moveLeft' [((0,0,0),[(SHold,0)]),((1,0,0),[(SLeft,1)]),((2,2,0),[(SLeft,3)])]
[((0,0,0),[(SHold,0)]),((1,0,0),[(SLeft,1)]),((2,0,0),[(SLMove,2),(SLeft,3)])]
>>> moveLeft' [((0,0,0),[(SHold,0)]),((1,0,0),[(SLeft,1)]),((2,0,0),[(SLMove,2),(SLeft,3)]),((3,2,0),[(SLMove,4),(SLeft,5)])]
[((0,0,0),[(SHold,0)]),((1,0,0),[(SLeft,1)]),((2,0,0),[(SLMove,2),(SLeft,3)]),((3,0,0),[(SLMove,4),(SLeft,5)])]
>>> moveLeft' [((0,2,0),[(SLeft,3)])]
[((0,0,0),[(SLMove,1),(SLMove,2),(SLeft,3)])]

moveLeft :: [((NodeId, Cur, Dest), [(Symbol, Pos)])] -> [((NodeId, Cur, Dest), [(Symbol, Pos)])]

Move more nodes

>>> moveLeft [((0,0,0),[(SHold,0)]),((1,0,0),[(SLeft,1)]),((2,2,0),[(SLeft,3)]),((3,4,0),[(SLeft,5)])]
[((0,0,0),[(SHold,0)]),((1,0,0),[(SLeft,1)]),((2,0,0),[(SLMove,2),(SLeft,3)]),((3,0,0),[(SLMove,4),(SLeft,5)])]

moveAll' :: [(NodeId, Cur, Dest)] -> [[(Symbol, Pos)]] -> [[(Symbol, Pos)]]

Move nodes to the next depth

>>> moveAll' [(0,0,4)] []
[[(SRight,1)],[(SRight,3)]]
>>> moveAll' [(0,4,0)] []
[[(SLMove,1),(SLMove,2),(SLeft,3)]]
>>> moveAll' [(0,2,0)] []
[[(SLeft,1)]]
>>> moveAll' [(0,0,4),(0,4,0)] []
[[(SRight,1),(SLeft,3)],[(SRight,3),(SLeft,1)]]
>>> moveAll' [(0,0,4),(0,2,0)] []
[[(SRight,1),(SLeft,1)],[(SRight,3),(SHold,0)]]

mergeSymbol :: [(Symbol, Pos)] -> [(Symbol, Pos)]

withSpace :: [(Symbol, Pos)] -> [(Symbol, Pos)]

Fill spaces

>>> withSpace [(SRight,1),(SLeft,3)]
[(SSpace,0),(SRight,1),(SSpace,2),(SLeft,3)]
>>> withSpace [(SRight,3),(SLeft,1)]
[(SSpace,0),(SLeft,1),(SSpace,2),(SRight,3)]

moveAllWithSpace :: [(NodeId, Cur, Dest)] -> [[(Symbol, Pos)]]

Move nodes and fill spaces

>>> moveAllWithSpace [(0,0,4)]
[[(SSpace,0),(SRight,1)],[(SSpace,0),(SSpace,1),(SSpace,2),(SRight,3)]]
>>> moveAllWithSpace [(0,4,0)]
[[(SSpace,0),(SLMove,1),(SLMove,2),(SLeft,3)]]
>>> moveAllWithSpace [(0,0,4),(0,4,0)]
[[(SSpace,0),(SRight,1),(SSpace,2),(SLeft,3)],[(SSpace,0),(SLeft,1),(SSpace,2),(SRight,3)]]
>>> moveAllWithSpace [(0,4,0),(1,0,4)]
[[(SSpace,0),(SRight,1),(SSpace,2),(SLeft,3)],[(SSpace,0),(SLeft,1),(SSpace,2),(SRight,3)]]

lstr :: Labels -> NodeId -> String

nodeWithSpace :: Labels -> ([(NodeId, Cur, Dest)], [(NodeId, Cur, Dest)]) -> [(Symbol, Pos)]

addBypassNode'' :: Depth -> Edges -> DepthGroup' -> DepthGroup'

Add bypass nodes

>>> edges = mkEdges [(0,[1,2]),(1,[2])]
>>> addBypassNode'' 2 edges (M.fromList [(0,([2],[])),(1,([1],[])),(2,([0],[]))])
fromList [(0,([2],[])),(1,([1],[0])),(2,([0],[]))]
>>> edges = mkEdges [(0,[1,3]),(1,[2]),(2,[3])]
>>> addBypassNode'' 3 edges (M.fromList [(0,([3],[])),(1,([2],[])),(2,([1],[])),(3,([0],[]))])
fromList [(0,([3],[])),(1,([2],[])),(2,([1],[0])),(3,([0],[]))]
>>> addBypassNode'' 2 edges (M.fromList [(0,([3],[])),(1,([2],[])),(2,([1],[0])),(3,([0],[]))])
fromList [(0,([3],[])),(1,([2],[0])),(2,([1],[0])),(3,([0],[]))]

>>> edges = mkEdges [(0,[1,2]),(1,[4]),(2,[3]),(3,[4])]
>>> addBypassNode'' 2 edges (M.fromList [(0,([4],[])),(1,([3,1],[])),(2,([2],[0])),(3,([0],[]))])
fromList [(0,([4],[])),(1,([3,1],[])),(2,([2],[0])),(3,([0],[]))]

maxDepth :: DepthGroup' -> Int

Get a maximum of depth

>>> maxDepth (M.fromList [(0,([2],[])),(1,([1],[])),(2,([0],[]))])
2

addBypassNode' :: Edges -> DepthGroup' -> DepthGroup'

Add bypass nodes

>>> edges = mkEdges [(0,[1,2]),(1,[2])]
>>> addBypassNode' edges (M.fromList [(0,([2],[])),(1,([1],[])),(2,([0],[]))])
fromList [(0,([2],[])),(1,([1],[0])),(2,([0],[]))]
>>> edges = mkEdges [(0,[1,3]),(1,[2]),(2,[3])]
>>> addBypassNode' edges (M.fromList [(0,([3],[])),(1,([2],[])),(2,([1],[])),(3,([0],[]))])
fromList [(0,([3],[])),(1,([2],[0])),(2,([1],[0])),(3,([0],[]))]

addBypassNode :: Edges -> DepthGroup -> DepthGroup'

Add bypass nodes

>>> edges = mkEdges [(0,[1,2]),(1,[2])]
>>> dg = getDepthGroup edges
>>> addBypassNode edges dg
fromList [(0,([2],[])),(1,([1],[0])),(2,([0],[]))]
>>> edges = mkEdges [(0,[1,3]),(1,[2]),(2,[3])]
>>> dg = getDepthGroup edges
>>> addBypassNode edges dg
fromList [(0,([3],[])),(1,([2],[0])),(2,([1],[0])),(3,([0],[]))]
>>> edges = mkEdges [(0,[1,2]),(1,[4]),(2,[3]),(3,[4])]
>>> dg = getDepthGroup edges
>>> addBypassNode edges dg
fromList [(0,([4],[])),(1,([3,1],[])),(2,([2],[0])),(3,([0],[]))]

addPosNode :: Edges -> DepthGroup' -> DepthGroup''

Add destinations of nodes

>>> edges = mkEdges [(0,[1,2]),(1,[2])]
>>> dg = getDepthGroup edges
>>> addPosNode edges $ M.fromList [(0,([2],[])),(1,([1],[0])),(2,([0],[]))]
fromList [(0,([(2,0,0)],[])),(1,([(1,0,0)],[(0,2,0)])),(2,([(0,0,0),(0,0,2)],[]))]

addNode :: Edges -> DepthGroup -> DepthGroup''

Grouping the nodes by the depth

>>> edges = mkEdges [(0,[1,2])]
>>> dg = getDepthGroup edges
>>> dg
fromList [(0,[1,2]),(1,[0])]
>>> addNode edges dg
fromList [(0,([(1,0,0),(2,2,2)],[])),(1,([(0,0,0),(0,0,2)],[]))]

toSymbol :: Labels -> DepthGroup'' -> [[(Symbol, Pos)]]

edgesToText :: Labels -> Edges -> String

symbolToChar :: Symbol -> Char

renderToText :: [[(Symbol, Pos)]] -> [String] -> String

Rendering symbols to text

>>> renderToText [[(SNode "",0)],[(SHold,0)],[(SNode "",0)]] []
"o\n|\no\n"
>>> renderToText [[(SNode "",0),(SSpace,1),(SNode "",2)],[(SHold,0),(SLeft,1)],[(SNode "",0)]] []
"o o\n|/\no\n"

addPos :: Edges -> ([NodeId], [NodeId]) -> ([NodeId], [NodeId]) -> ([(NodeId, Cur, Dest)], [(NodeId, Cur, Dest)])

Allocate destinations of nodes.

>>> addPos sampledat ([0,1],[]) ([2],[])
([(0,0,0),(1,2,0)],[])
>>> addPos (mkEdges [(0,[1,2]),(1,[2])]) ([0],[]) ([1],[0])
([(0,0,0),(0,0,2)],[])
>>> addPos (mkEdges [(0,[1,2]),(1,[2])]) ([1],[0]) ([2],[])
([(1,0,0)],[(0,2,0)])
>>> addPos (mkEdges [(0,[1,3]),(1,[2]),(2,[3])]) ([1],[0]) ([2],[0])
([(1,0,0)],[(0,2,2)])