|This module defines various utility functions used throughout.
|node :: LNode a -> Node|
|label :: LNode a -> a|
|edge :: LEdge b -> Edge|
|eLabel :: LEdge b -> b|
|addLabels :: Graph g => g a b -> [Node] -> [LNode a]|
|filterNodes :: Graph g => (g a b -> LNode a -> Bool) -> g a b -> [LNode a]|
|filterNodes' :: Graph g => (g a b -> Node -> Bool) -> g a b -> [Node]|
|pathValues :: LPath a -> [LNode a]|
|undir :: (Eq b, DynGraph gr) => gr a b -> gr a b|
|oneWay :: (DynGraph g, Eq b) => g a b -> g a b|
|nlmap :: DynGraph gr => (LNode a -> c) -> gr a b -> gr c b|
|dotizeGraph :: (DynGraph gr, Ord b) => gr a b -> gr (AttributeNode a) (AttributeEdge b)|
|toPosGraph :: (DynGraph gr, Ord b) => gr a b -> gr (PosLabel a) b|
|getPositions :: (DynGraph gr, Ord b) => gr a b -> [PosLabel a]|
|createLookup :: [[Node]] -> IntMap Int|
|setCluster :: DynGraph gr => IntMap Int -> gr a b -> gr (GenCluster a) b|
|assignCluster :: ClusterLabel a c => LNode a -> NodeCluster c a|
|single :: [a] -> Bool|
|longerThan :: Int -> [a] -> Bool|
|longest :: [[a]] -> [a]|
|groupElems :: Ord b => (a -> b) -> [a] -> [(b, [a])]|
|sortMinMax :: Ord a => [a] -> ([a], a, a)|
|blockPrint :: Show a => [a] -> String|
|shuffle :: RandomGen g => g -> [a] -> ([a], g)|
|mean :: [Double] -> Double|
|statistics :: [Double] -> (Double, Double)|
|statistics' :: [Int] -> (Int, Int)|
|fixPoint :: Eq a => (a -> a) -> a -> a|
|fixPointGraphs :: (Eq a, Eq b, Graph g) => (g a b -> g a b) -> g a b -> g a b|
|fixPointBy :: (a -> a -> Bool) -> (a -> a) -> a -> a|
|sq :: Num a => a -> a|
|fI :: Num a => Int -> a|
Extracting data from graphs.
The node number of an LNode.
|The label of an LNode
|Extract the Edge from the LEdge.
|The label of an LEdge
|Obtain the labels for a list of Nodes.
It is assumed that each Node is indeed present in the given graph.
|Find all the labelled nodes in the graph that match the given predicate.
|Find all the nodes in the graph that match the given predicate.
Extract the actual LNodes from an LPath.
|Make the graph undirected, i.e. for every edge from A to B, there
exists an edge from B to A. The provided function
Data.Graph.Inductive.Basic.undir duplicates loops as well, which
isn't wanted. It is assumed that no edges are already duplicates
[i.e. if there exists an edge (n1,n2), then there doesn't exist
(n2,n1)]. This function also preserves edge labels: if two edges
exist between two nodes with different edge labels, then both edges
will be duplicated.
|This is a pseudo-inverse of undir: any edges that are both successor
and predecessor become successor edges only.
|Map over the labels on the nodes, using the node values as well.
|These next two are re-exported from Data.GraphViz
Spatial positioning of graphs. Use the graphToGraph function in
Data.GraphViz to determine potential graph layouts.
Pass the plain graph through graphToGraph. This is an IO action,
however since the state doesn't change it's safe to use unsafePerformIO
to convert this to a normal function.
|Convert the graph into one with positions stored in the node labels.
|Returns the positions of the nodes in the graph, as found using Graphviz.
Cluster utility functions.
Create a cluster-lookup IntMap.
|Used when the clusters are assigned in a lookup IntMap instance.
|A function to convert an LNode to the required NodeCluster
for use with the Graphviz library.
List utility functions.
Return true if and only if the list contains a single element.
|If we need to only tell if the list contains more than n elements,
there's no need to find its length.
|Returns the longest list in a list of lists.
|groupElems :: Ord b => (a -> b) -> [a] -> [(b, [a])]||Source|
|Group elements by the given grouping function.
|sortMinMax :: Ord a => [a] -> ([a], a, a)||Source|
|Returns the unique elements of the list in ascending order,
as well as the minimum and maximum elements.
|Attempt to convert a list of elements into a square format
in as much of a square shape as possible.
|Shuffle a list of elements.
This isn't the most efficient version, but should serve for small lists.
The adaptation mainly involved altering the code so that the new
random seed is also returned.
An efficient mean function by Don Stewart, available from:
|-> (Double, Double)||(Mean, Standard Deviation)
|Calculate the mean and standard deviation of a list of elements.
|-> (Int, Int)||(Mean, Standard Deviation)
|Calculate the mean and standard deviation of a list of Int values.
|fixPoint :: Eq a => (a -> a) -> a -> a||Source|
Other utility functions.
Find the fixed point of a function with the given initial value.
|fixPointGraphs :: (Eq a, Eq b, Graph g) => (g a b -> g a b) -> g a b -> g a b||Source|
|Find the fixed point of a graph transformation function.
|fixPointBy :: (a -> a -> Bool) -> (a -> a) -> a -> a||Source|
|Find the fixed point of a function with the given initial value,
using the given equality function.
|Squaring a number.
|Shorthand for fromIntegral
|Produced by Haddock version 2.3.0|