Data.Graph

A version of the graph algorithms described in:

Structuring Depth-First Search Algorithms in Haskell, by David King and John Launchbury.

External interface

stronglyConnComp

Arguments

:: Ord key

=> [(node, key, [key])]

The graph: a list of nodes uniquely identified by keys, with a list of keys of nodes this node has edges to. The out-list may contain keys that don't correspond to nodes of the graph; such edges are ignored.

-> [SCC node]

The strongly connected components of a directed graph, topologically sorted.

stronglyConnCompR

Arguments

:: Ord key

=> [(node, key, [key])]

The graph: a list of nodes uniquely identified by keys, with a list of keys of nodes this node has edges to. The out-list may contain keys that don't correspond to nodes of the graph; such edges are ignored.

-> [SCC (node, key, [key])]

Topologically sorted

The strongly connected components of a directed graph, topologically sorted. The function is the same as stronglyConnComp, except that all the information about each node retained. This interface is used when you expect to apply SCC to (some of) the result of SCC, so you don't want to lose the dependency information.

data SCC vertex

Strongly connected component.

Constructors

AcyclicSCC vertex

A single vertex that is not in any cycle.

CyclicSCC [vertex]

A maximal set of mutually reachable vertices.

Instances

Functor SCC

Methods

fmap :: (a -> b) -> SCC a -> SCC b

(<$) :: a -> SCC b -> SCC a

Foldable SCC

Methods

fold :: Monoid m => SCC m -> m

foldMap :: Monoid m => (a -> m) -> SCC a -> m

foldr :: (a -> b -> b) -> b -> SCC a -> b

foldr' :: (a -> b -> b) -> b -> SCC a -> b

foldl :: (b -> a -> b) -> b -> SCC a -> b

foldl' :: (b -> a -> b) -> b -> SCC a -> b

foldr1 :: (a -> a -> a) -> SCC a -> a

foldl1 :: (a -> a -> a) -> SCC a -> a

toList :: SCC a -> [a]

null :: SCC a -> Bool

length :: SCC a -> Int

elem :: Eq a => a -> SCC a -> Bool

maximum :: Ord a => SCC a -> a

minimum :: Ord a => SCC a -> a

sum :: Num a => SCC a -> a

product :: Num a => SCC a -> a

Traversable SCC

Methods

traverse :: Applicative f => (a -> f b) -> SCC a -> f (SCC b)

sequenceA :: Applicative f => SCC (f a) -> f (SCC a)

mapM :: Monad m => (a -> m b) -> SCC a -> m (SCC b)

sequence :: Monad m => SCC (m a) -> m (SCC a)

Eq1 SCC

Methods

liftEq :: (a -> b -> Bool) -> SCC a -> SCC b -> Bool

Read1 SCC

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (SCC a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [SCC a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (SCC a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [SCC a]

Show1 SCC

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> SCC a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [SCC a] -> ShowS

Eq vertex => Eq (SCC vertex)

Methods

(==) :: SCC vertex -> SCC vertex -> Bool

(/=) :: SCC vertex -> SCC vertex -> Bool

Data vertex => Data (SCC vertex)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SCC vertex -> c (SCC vertex)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (SCC vertex)

toConstr :: SCC vertex -> Constr

dataTypeOf :: SCC vertex -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (SCC vertex))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (SCC vertex))

gmapT :: (forall b. Data b => b -> b) -> SCC vertex -> SCC vertex

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SCC vertex -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SCC vertex -> r

gmapQ :: (forall d. Data d => d -> u) -> SCC vertex -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> SCC vertex -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SCC vertex -> m (SCC vertex)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SCC vertex -> m (SCC vertex)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SCC vertex -> m (SCC vertex)

Read vertex => Read (SCC vertex)

Methods

readsPrec :: Int -> ReadS (SCC vertex)

readList :: ReadS [SCC vertex]

readPrec :: ReadPrec (SCC vertex)

readListPrec :: ReadPrec [SCC vertex]

Show vertex => Show (SCC vertex)

Methods

showsPrec :: Int -> SCC vertex -> ShowS

show :: SCC vertex -> String

showList :: [SCC vertex] -> ShowS

Generic (SCC vertex)

Associated Types

type Rep (SCC vertex) :: * -> *

Methods

from :: SCC vertex -> Rep (SCC vertex) x

to :: Rep (SCC vertex) x -> SCC vertex

NFData a => NFData (SCC a)

Methods

rnf :: SCC a -> ()

Generic1 * SCC

Associated Types

type Rep1 SCC (f :: SCC -> *) :: k -> *

Methods

from1 :: f a -> Rep1 SCC f a

to1 :: Rep1 SCC f a -> f a

type Rep (SCC vertex)

type Rep (SCC vertex) = D1 * (MetaData "SCC" "Data.Graph" "containers-0.5.10.2-JOjc9xI4RgWIuwuFLwhvNw" False) ((:+:) * (C1 * (MetaCons "AcyclicSCC" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * vertex))) (C1 * (MetaCons "CyclicSCC" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [vertex]))))

type Rep1 * SCC

type Rep1 * SCC = D1 * (MetaData "SCC" "Data.Graph" "containers-0.5.10.2-JOjc9xI4RgWIuwuFLwhvNw" False) ((:+:) * (C1 * (MetaCons "AcyclicSCC" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1)) (C1 * (MetaCons "CyclicSCC" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 * []))))

flattenSCC :: SCC vertex -> [vertex]

The vertices of a strongly connected component.

flattenSCCs :: [SCC a] -> [a]

The vertices of a list of strongly connected components.

Graphs

type Graph = Table [Vertex]

Adjacency list representation of a graph, mapping each vertex to its list of successors.

type Table a = Array Vertex a

Table indexed by a contiguous set of vertices.

type Bounds = (Vertex, Vertex)

The bounds of a Table.

type Edge = (Vertex, Vertex)

An edge from the first vertex to the second.

type Vertex = Int

Abstract representation of vertices.

Building graphs

graphFromEdges :: Ord key => [(node, key, [key])] -> (Graph, Vertex -> (node, key, [key]), key -> Maybe Vertex)

Build a graph from a list of nodes uniquely identified by keys, with a list of keys of nodes this node should have edges to. The out-list may contain keys that don't correspond to nodes of the graph; they are ignored.

graphFromEdges' :: Ord key => [(node, key, [key])] -> (Graph, Vertex -> (node, key, [key]))

Identical to graphFromEdges, except that the return value does not include the function which maps keys to vertices. This version of graphFromEdges is for backwards compatibility.

buildG :: Bounds -> [Edge] -> Graph

Build a graph from a list of edges.

transposeG :: Graph -> Graph

The graph obtained by reversing all edges.

Graph properties

vertices :: Graph -> [Vertex]

All vertices of a graph.

edges :: Graph -> [Edge]

All edges of a graph.

outdegree :: Graph -> Table Int

A table of the count of edges from each node.

indegree :: Graph -> Table Int

A table of the count of edges into each node.

Algorithms

dfs :: Graph -> [Vertex] -> Forest Vertex

A spanning forest of the part of the graph reachable from the listed vertices, obtained from a depth-first search of the graph starting at each of the listed vertices in order.

dff :: Graph -> Forest Vertex

A spanning forest of the graph, obtained from a depth-first search of the graph starting from each vertex in an unspecified order.

topSort :: Graph -> [Vertex]

A topological sort of the graph. The order is partially specified by the condition that a vertex i precedes j whenever j is reachable from i but not vice versa.

components :: Graph -> Forest Vertex

The connected components of a graph. Two vertices are connected if there is a path between them, traversing edges in either direction.

scc :: Graph -> Forest Vertex

The strongly connected components of a graph.

bcc :: Graph -> Forest [Vertex]

The biconnected components of a graph. An undirected graph is biconnected if the deletion of any vertex leaves it connected.

reachable :: Graph -> Vertex -> [Vertex]

A list of vertices reachable from a given vertex.

path :: Graph -> Vertex -> Vertex -> Bool

Is the second vertex reachable from the first?

module Data.Tree