Data.PlanarGraph

Documentation

newtype Arc s

An Arc is a directed edge in a planar graph. The type s is used to tie this arc to a particular graph.

Constructors

Arc

Fields

_unArc :: Int

Instances

Bounded (Arc k s)

Enum (Arc k s)

Eq (Arc k s)

Ord (Arc k s)

Show (Arc k s)

data Direction

Constructors

Negative

Positive

Instances

Bounded Direction

Enum Direction

Eq Direction

Ord Direction

Read Direction

Show Direction

rev :: Direction -> Direction

Reverse the direcion

data Dart s

A dart represents a bi-directed edge. I.e. a dart has a direction, however the dart of the oposite direction is always present in the planar graph as well.

Constructors

Dart

Fields

_arc :: !(Arc s)

_direction :: !Direction

Instances

Enum (Dart k s)

Eq (Dart k s)

Ord (Dart k s)

Show (Dart k s)

arc :: forall s s. Lens (Dart s) (Dart s) (Arc s) (Arc s)

direction :: forall s. Lens' (Dart s) Direction

twin :: Dart s -> Dart s

Get the twin of this dart (edge)

>>> twin (dart 0 "+1")
Dart (Arc 0) -1
>>> twin (dart 0 "-1")
Dart (Arc 0) +1

isPositive :: Dart s -> Bool

test if a dart is Positive

data World

The world in which the graph lives

Constructors

Primal_

Dual_

Instances

Eq World

Show World

type family Dual sp

Equations

Dual Primal_ = Dual_

Dual Dual_ = Primal_

newtype VertexId s w

A vertex in a planar graph. A vertex is tied to a particular planar graph by the phantom type s, and to a particular world w.

Constructors

VertexId

Fields

_unVertexId :: Int

Instances

Enum (VertexId k s w)

Eq (VertexId k s w)

Ord (VertexId k s w)

Show (VertexId k s w)

data PlanarGraph s w v e f

A *connected* Planar graph with bidirected edges. I.e. the edges (darts) are directed, however, for every directed edge, the edge in the oposite direction is also in the graph.

The types v, e, and f are the are the types of the data associated with the vertices, edges, and faces, respectively.

The orbits in the embedding are assumed to be in counterclockwise order.

Instances

(Eq v, Eq e, Eq f) => Eq (PlanarGraph k s w v e f)

(Show v, Show e, Show f) => Show (PlanarGraph k s w v e f)

embedding :: forall s w v e f s w. Lens (PlanarGraph s w v e f) (PlanarGraph s w v e f) (Permutation (Dart s)) (Permutation (Dart s))

vertexData :: forall s w v e f w v. Lens (PlanarGraph s w v e f) (PlanarGraph s w v e f) (Vector v) (Vector v)

dartData :: Lens (PlanarGraph s w v e f) (PlanarGraph s w v e' f) (Vector (Dart s, e)) (Vector (Dart s, e'))

lens to access the Dart Data

faceData :: forall s w v e f w f. Lens (PlanarGraph s w v e f) (PlanarGraph s w v e f) (Vector f) (Vector f)

edgeData :: Lens (PlanarGraph s w v e f) (PlanarGraph s w v e' f) (Vector (Dart s, e)) (Vector (Dart s, e'))

edgeData is just an alias for dartData

planarGraph :: Permutation (Dart s) -> PlanarGraph s Primal_ () () ()

Construct a planar graph

planarGraph' :: [[(Dart s, e)]] -> PlanarGraph s Primal_ () e ()

Construct a planar graph.

numVertices :: PlanarGraph s w v e f -> Int

Get the number of vertices

>>> numVertices myGraph
4

numDarts :: PlanarGraph s w v e f -> Int

Get the number of Darts

>>> numDarts myGraph
12

numEdges :: PlanarGraph s w v e f -> Int

Get the number of Edges

>>> numEdges myGraph
6

numFaces :: PlanarGraph s w v e f -> Int

Get the number of faces

>>> numFaces myGraph
4

darts' :: PlanarGraph s w v e f -> Vector (Dart s)

Enumerate all darts

darts :: PlanarGraph s w v e f -> Vector (Dart s, e)

Get all darts together with their data

>>> mapM_ print $ darts myGraph
(Dart (Arc 0) -1,"a-")
(Dart (Arc 2) +1,"c+")
(Dart (Arc 1) +1,"b+")
(Dart (Arc 0) +1,"a+")
(Dart (Arc 4) -1,"e-")
(Dart (Arc 1) -1,"b-")
(Dart (Arc 3) -1,"d-")
(Dart (Arc 5) +1,"g+")
(Dart (Arc 4) +1,"e+")
(Dart (Arc 3) +1,"d+")
(Dart (Arc 2) -1,"c-")
(Dart (Arc 5) -1,"g-")

edges' :: PlanarGraph s w v e f -> Vector (Dart s)

Enumerate all edges. We report only the Positive darts

edges :: PlanarGraph s w v e f -> Vector (Dart s, e)

Enumerate all edges with their edge data. We report only the Positive darts.

>>> mapM_ print $ edges myGraph
(Dart (Arc 2) +1,"c+")
(Dart (Arc 1) +1,"b+")
(Dart (Arc 0) +1,"a+")
(Dart (Arc 5) +1,"g+")
(Dart (Arc 4) +1,"e+")
(Dart (Arc 3) +1,"d+")

vertices' :: PlanarGraph s w v e f -> Vector (VertexId s w)

Enumerate all vertices

>>> vertices' myGraph
[VertexId 0,VertexId 1,VertexId 2,VertexId 3]

vertices :: PlanarGraph s w v e f -> Vector (VertexId s w, v)

Enumerate all vertices, together with their vertex data

faces' :: PlanarGraph s w v e f -> Vector (FaceId s w)

Enumerate all faces in the planar graph

faces :: PlanarGraph s w v e f -> Vector (FaceId s w, f)

All faces with their face data.

tailOf :: Dart s -> PlanarGraph s w v e f -> VertexId s w

The tail of a dart, i.e. the vertex this dart is leaving from

headOf :: Dart s -> PlanarGraph s w v e f -> VertexId s w

The vertex this dart is heading in to

endPoints :: Dart s -> PlanarGraph s w v e f -> (VertexId s w, VertexId s w)

endPoints d g = (tailOf d g, headOf d g)

incidentEdges :: VertexId s w -> PlanarGraph s w v e f -> Vector (Dart s)

All edges incident to vertex v, in counterclockwise order around v.

incomingEdges :: VertexId s w -> PlanarGraph s w v e f -> Vector (Dart s)

All incoming edges incident to vertex v, in counterclockwise order around v.

outgoingEdges :: VertexId s w -> PlanarGraph s w v e f -> Vector (Dart s)

All outgoing edges incident to vertex v, in counterclockwise order around v.

neighboursOf :: VertexId s w -> PlanarGraph s w v e f -> Vector (VertexId s w)

Gets the neighbours of a particular vertex, in counterclockwise order around the vertex.

vDataOf :: VertexId s w -> Lens' (PlanarGraph s w v e f) v

Get the vertex data associated with a node. Note that updating this data may be expensive!!

eDataOf :: Dart s -> Lens' (PlanarGraph s w v e f) e

Edge data of a given dart

fDataOf :: FaceId s w -> Lens' (PlanarGraph s w v e f) f

Data of a face of a given face

endPointDataOf :: Dart s -> Getter (PlanarGraph s w v e f) (v, v)

Data corresponding to the endpoints of the dart

endPointData :: Dart s -> PlanarGraph s w v e f -> (v, v)

Data corresponding to the endpoints of the dart

dual :: PlanarGraph s w v e f -> PlanarGraph s (Dual w) f e v

The dual of this graph

>>> :{
 let fromList = V.fromList
     answer = fromList [ fromList [dart 0 "-1"]
                       , fromList [dart 2 "+1",dart 4 "+1",dart 1 "-1",dart 0 "+1"]
                       , fromList [dart 1 "+1",dart 3 "-1",dart 2 "-1"]
                       , fromList [dart 4 "-1",dart 3 "+1",dart 5 "+1",dart 5 "-1"]
                       ]
 in (dual myGraph)^.embedding.orbits == answer
:}
True

newtype FaceId s w

A face

Constructors

FaceId

Fields

_unFaceId :: VertexId s (Dual w)

Instances

Eq (FaceId k s w)

Ord (FaceId k s w)

Show (FaceId k s w)

leftFace :: Dart s -> PlanarGraph s w v e f -> FaceId s w

The face to the left of the dart

>>> leftFace (dart 1 "+1") myGraph
FaceId 1
>>> leftFace (dart 1 "-1") myGraph
FaceId 2
>>> leftFace (dart 2 "+1") myGraph
FaceId 2
>>> leftFace (dart 0 "+1") myGraph
FaceId 0

rightFace :: Dart s -> PlanarGraph s w v e f -> FaceId s w

The face to the right of the dart

>>> rightFace (dart 1 "+1") myGraph
FaceId 2
>>> rightFace (dart 1 "-1") myGraph
FaceId 1
>>> rightFace (dart 2 "+1") myGraph
FaceId 1
>>> rightFace (dart 0 "+1") myGraph
FaceId 1

boundary :: FaceId s w -> PlanarGraph s w v e f -> Vector (Dart s)

The darts bounding this face, for internal faces in clockwise order, for the outer face in counter clockwise order.