containers-0.5.10.2: Assorted concrete container types

Copyright | (c) The University of Glasgow 2002
License | BSD-style (see the file libraries/base/LICENSE)
Maintainer | libraries@haskell.org
Portability | portable
Safe Haskell | Trustworthy
Language | Haskell98

Data.Graph

Contents

- External interface
- Graphs
  - Building graphs
  - Graph properties
- Algorithms

Description

A version of the graph algorithms described in:

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

Synopsis

- stronglyConnComp :: Ord key => [(node, key, [key])] -> [SCC node]
- stronglyConnCompR :: Ord key => [(node, key, [key])] -> [SCC (node, key, [key])]
- data SCC vertex
  - = AcyclicSCC vertex
  - | CyclicSCC [vertex]
- flattenSCC :: SCC vertex -> [vertex]
- flattenSCCs :: [SCC a] -> [a]
- type Graph = Table [Vertex]
- type Table a = Array Vertex a
- type Bounds = (Vertex, Vertex)
- type Edge = (Vertex, Vertex)
- type Vertex = Int
- graphFromEdges :: Ord key => [(node, key, [key])] -> (Graph, Vertex -> (node, key, [key]), key -> Maybe Vertex)
- graphFromEdges' :: Ord key => [(node, key, [key])] -> (Graph, Vertex -> (node, key, [key]))
- buildG :: Bounds -> [Edge] -> Graph
- transposeG :: Graph -> Graph
- vertices :: Graph -> [Vertex]
- edges :: Graph -> [Edge]
- outdegree :: Graph -> Table Int
- indegree :: Graph -> Table Int
- dfs :: Graph -> [Vertex] -> Forest Vertex
- dff :: Graph -> Forest Vertex
- topSort :: Graph -> [Vertex]
- components :: Graph -> Forest Vertex
- scc :: Graph -> Forest Vertex
- bcc :: Graph -> Forest [Vertex]
- reachable :: Graph -> Vertex -> [Vertex]
- path :: Graph -> Vertex -> Vertex -> Bool
- module Data.Tree

# 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 Source # (<$) :: a -> SCC b -> SCC a Source #
Foldable SCC # |

Methods

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

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

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

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

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

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

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

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

toList :: SCC a -> [a] Source #

null :: SCC a -> Bool Source #

length :: SCC a -> Int Source #

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

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

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

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

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

Traversable SCC # |
Methods traverse :: Applicative f => (a -> f b) -> SCC a -> f (SCC b) Source # sequenceA :: Applicative f => SCC (f a) -> f (SCC a) Source # mapM :: Monad m => (a -> m b) -> SCC a -> m (SCC b) Source # sequence :: Monad m => SCC (m a) -> m (SCC a) Source #
Eq1 SCC # |
Methods liftEq :: (a -> b -> Bool) -> SCC a -> SCC b -> Bool Source #
Read1 SCC # |
Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (SCC a) Source # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [SCC a] Source # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (SCC a) Source # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [SCC a] Source #
Show1 SCC # |
Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> SCC a -> ShowS Source # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [SCC a] -> ShowS Source #
Eq vertex => Eq (SCC vertex) # |
Methods (==) :: SCC vertex -> SCC vertex -> Bool Source # (/=) :: SCC vertex -> SCC vertex -> Bool Source #
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) Source #

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

toConstr :: SCC vertex -> Constr Source #

dataTypeOf :: SCC vertex -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Read vertex => Read (SCC vertex) # |
Methods readsPrec :: Int -> ReadS (SCC vertex) Source # readList :: ReadS [SCC vertex] Source # readPrec :: ReadPrec (SCC vertex) Source # readListPrec :: ReadPrec [SCC vertex] Source #
Show vertex => Show (SCC vertex) # |
Methods showsPrec :: Int -> SCC vertex -> ShowS Source # show :: SCC vertex -> String Source # showList :: [SCC vertex] -> ShowS Source #
Generic (SCC vertex) # |
Associated Types type Rep (SCC vertex) :: * -> * Source # Methods from :: SCC vertex -> Rep (SCC vertex) x Source # to :: Rep (SCC vertex) x -> SCC vertex Source #
NFData a => NFData (SCC a) # |
Methods rnf :: SCC a -> () Source #
Generic1 * SCC # |
Associated Types type Rep1 SCC (f :: SCC -> *) :: k -> * Source # Methods from1 :: f a -> Rep1 SCC f a Source # to1 :: Rep1 SCC f a -> f a Source #
type Rep (SCC vertex) # |
type Rep (SCC vertex) = D1 * (MetaData "SCC" "Data.Graph" "containers-0.5.10.2" 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" 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