The graphs package

[Tags: bsd3, library]

A "not-very-Haskelly" API for calculating traversals of graphs that may be too large to fit into memory. The algorithms included are inspired by the visitor concept of the Boost Graph Library.

Here is a very simple example of how we might execute a depth-first-search. In this case the visitor simply collects the edges and vertices in the order that the corresponding functions get called. After the necessary imports,

 import Data.Array
 import Data.Monoid
 import Data.Graph.AdjacencyList
 import Data.Graph.Algorithm
 import Data.Graph.Algorithm.DepthFirstSearch

create an adjacency list where the vertices are labeled with integers.

 graph :: Array Int [Int]
 graph = array (0, 3) [(0, [1,2]), (1, [3]), (2, [3]), (3, [])]

We need a data structure that instantiates Monoid to combine the results of our visitor functions.

data Orderings = Orderings
  {  enterV :: [Int]
  ,  enterE :: [(Int, Int)]
  ,  gray   :: [(Int, Int)]
  ,  exitV  :: [Int]
  ,  black  :: [(Int, Int)]
  } deriving Show

instance Monoid Orderings where
 mempty = Orderings [] [] [] [] []
 mappend (Orderings a1 a2 a3 a4 a5)(Orderings b1 b2 b3 b4 b5) =
  Orderings (a1 ++ b1) (a2 ++ b2) (a3 ++ b3) (a4 ++ b4) (a5 ++ b5)

The dfs function's first argument is of type GraphSearch which is a visitor containing the functions to be run at various times during the search. The second argument is the starting vertex for the search.

orderings :: GraphSearch (AdjacencyList Int) Orderings
orderings = GraphSearch
  (v -> return $ mempty {enterV = [v]}
  (e -> return $ mempty {enterE = [e]}
  (e -> return $ mempty {gray   = [e]}
  (v -> return $ mempty {exitV  = [v]}
  (e -> return $ mempty {black  = [e]}

Finally runAdjacencylist unwraps the function in the Adjacencylist newtype and runs it on graph.

 dfsTest :: Orderings
 dfsTest = runAdjacencyList (dfs orderings 0) graph

Running dfsTest in ghci will yield:

Orderings {enterV = [0,2,3,1], enterE = [(0,2),(2,3),(0,1)], gray = [], exitV = [3,2,1,0], black = [(1,3)]}

[Skip to ReadMe]

Properties

Versions0.1, 0.2, 0.3, 0.3.1, 0.3.2, 0.3.2.1, 0.3.2.2, 0.3.2.3, 0.4, 0.4.0.1, 0.4.0.3, 0.4.1, 0.5, 0.5.0.1, 0.6, 0.6.0.1, 0.7
Change logCHANGELOG.markdown
Dependenciesarray (>=0.3 && <0.7), base (==4.*), containers (>=0.3 && <0.6), transformers (>=0.2.2 && <0.6), transformers-compat (>=0.3 && <1), void (>=0.5.5.1 && <1) [details]
LicenseBSD3
CopyrightCopyright (C) 2011-2013 Edward A. Kmett
AuthorEdward A. Kmett
MaintainerEdward A. Kmett <ekmett@gmail.com>
Stabilityexperimental
CategoryAlgorithms, Data Structures, Graphs
Home pagehttp://github.com/ekmett/graphs
Bug trackerhttp://github.com/ekmett/graphs/issues
Source repositoryhead: git clone git://github.com/ekmett/graphs.git
UploadedSun Jan 17 03:09:34 UTC 2016 by EdwardKmett
DistributionsLTSHaskell:0.7, NixOS:0.7, Stackage:0.7
Downloads3100 total (31 in last 30 days)
Votes
0 []
StatusDocs available [build log]
Last success reported on 2016-01-19 [all 1 reports]

Modules

[Index]

Downloads

Maintainers' corner

For package maintainers and hackage trustees

Readme for graphs-0.7

graphs

Hackage Build Status

This provides a "not-very-Haskelly" API for calculating traversals of graphs that may be too large to fit into memory.

Contact Information

Contributions and bug reports are welcome!

Please feel free to contact me through github or on the #haskell IRC channel on irc.freenode.net.

-Edward Kmett