# Index of values

A
add [Strat.STRAT] |
add [Flow.FLOW] |
add [Nonnegative.WEIGHT] | Addition of weights.
add [Path.WEIGHT] | Addition of weights.
add_edge [Dominator.G] |
add_edge [Builder.S] |
add_edge [Sig_pack.S] | `add_edge g v1 v2` adds an edge from the vertex `v1` to the vertex `v2` in the graph `g`.
add_edge [Sig.I] | `add_edge g v1 v2` adds an edge from the vertex `v1` to the vertex `v2` in the graph `g`.
add_edge [Sig.P] | `add_edge g v1 v2` adds an edge from the vertex `v1` to the vertex `v2` in the graph `g`.
add_edge_e [DGraphSubTree.Tree] |
add_edge_e [Contraction.G] |
add_edge_e [Gmap.E_DST] |
add_edge_e [Builder.S] |
add_edge_e [Sig_pack.S] | `add_edge_e g e` adds the edge `e` in the graph `g`.
add_edge_e [Sig.I] | `add_edge_e g e` adds the edge `e` in the graph `g`.
add_edge_e [Sig.P] | `add_edge_e g e` adds the edge `e` in the graph `g`.
add_transitive_closure [Oper.S] | `add_transitive_closure ?reflexive g` replaces `g` by its transitive closure.
add_transitive_closure [Sig_pack.S] | `add_transitive_closure ?reflexive g` replaces `g` by its transitive closure.
add_vertex [DGraphSubTree.Tree] |
add_vertex [Gmap.V_DST] |
add_vertex [Builder.S] |
add_vertex [Sig_pack.S] | `add_vertex g v` adds the vertex `v` from the graph `g`.
add_vertex [Sig.I] | `add_vertex g v` adds the vertex `v` to the graph `g`.
add_vertex [Sig.P] | `add_vertex g v` adds the vertex `v` to the graph `g`.
all_shortest_paths [Path.BellmanFord] | `shortest_path g vs` computes the distances of shortest paths from vertex `vs` to all other vertices in graph `g`.
allminsep [Minsep.MINSEP] | `allminsep g` computes the list of all minimal separators of g.
analyze [Fixpoint.Analysis] | the actual analysis of one edge; provided the edge and the incoming data, it needs to compute the outgoing data
analyze [Fixpoint.Make] | `analyze f g` computes the fixpoint on the given graph using the work list algorithm.
B
bellman_ford [Sig_pack.S] | `bellman_ford g v` finds a negative cycle from `v`, and returns it, or raises `Not_found` if there is no such cycle
bounding_box [XDot] | `bounding_box pos w h` converts a bounding box of center `pos`, width `w` and height `h` from a Dot file to a pair of corners (lower left and upper right) in the world coordinate system.
C
ccw [Delaunay.CCC] | The counterclockwise relation `ccw p q r` states that the circle through points `(p,q,r)` is traversed counterclockwise when we encounter the points in cyclic order `p,q,r,p,...` *
check_path [Path.Check] | `check_path pc v1 v2` checks whether there is a path from `v1` to `v2` in the graph associated to the path checker `pc`.
check_path [Sig_pack.S.PathCheck] |
choose_edge [Oper.Choose] | `choose_edge g` returns an edge from the graph.
choose_vertex [Oper.Choose] | `choose_vertex g` returns a vertex from the graph.
clear [Traverse.GM.Mark] |
clear [Sig_pack.S.Mark] | `clear g` sets all marks to 0 from all the vertives of `g`.
clear [Sig_pack.S] | Remove all vertices and edges from the given graph.
clear [Sig.MARK] | `clear g` sets all the marks to 0 for all the vertices of `g`.
clear [Sig.I] | Remove all vertices and edges from the given graph.
coherent_player [Strat.Algo] | `coherent_player g p` returns `true` iff the completion `p` is coherent w.r.t.
coherent_strat [Strat.Algo] | `coherent_strat g s` returns `true` iff the strategy `s` is coherent w.r.t.
color_to_color_with_transparency [Graphviz] |
coloring [Coloring.Mark] | `coloring g k` colors the nodes of graph `g` using k colors, assigning the marks integer values between 1 and k.
coloring [Coloring.Make] | `coloring g k` colors the graph `g` with `k` colors and returns the coloring as a hash table mapping nodes to their colors.
compare [Cliquetree.CliqueTree.CliqueTreeE] |
compare [Cliquetree.CliqueTree.CliqueTreeV] |
compare [Cliquetree.CliqueTree.CliqueV] |
compare [Flow.FLOW] |
compare [Nonnegative.WEIGHT] | Weights must be ordered.
compare [Path.WEIGHT] | Weights must be ordered.
compare [Util.DataV] |
compare [Sig_pack.S.E] |
compare [Sig_pack.S.V] |
compare [Sig.COMPARABLE] |
compare [Sig.ORDERED_TYPE] |
compare [Sig.EDGE] |
compare [Sig.VERTEX] |
complement [Oper.S] | `complement g` returns a new graph which is the complement of `g`: each edge present in `g` is not present in the resulting graph and vice-versa.
complement [Sig_pack.S] | `complement g` builds a new graph which is the complement of `g`: each edge present in `g` is not present in the resulting graph and vice-versa.
compute_all [Dominator.Make] | Computes all dominance functions.
compute_dom_frontier [Dominator.Make] | Computes the dominance frontier.
compute_dom_graph [Dominator.Make] |
compute_idom [Dominator.Make] | Computes the dominator tree, using the Lengauer-Tarjan algorithm.
contract [Contraction.Make] | `contract p g` will perform edge contraction on the graph `g`.
copy [Builder.S] |
copy [Sig_pack.S] | `copy g` returns a copy of `g`.
copy [Sig.I] | `copy g` returns a copy of `g`.
create [DGraphRandModel] |
create [DGraphSubTree.Tree.V] |
create [DGraphSubTree.Tree] |
create [Cliquetree.CliqueTree.CliqueTreeE] |
create [Cliquetree.CliqueTree.CliqueTreeV] |
create [Cliquetree.CliqueTree.CliqueV] |
create [Dominator.G] |
create [Path.Check] | `create g` builds a new path checker for the graph `g`; if the graph is mutable, it must not be mutated while this path checker is in use (through the function `check_path` below).
create [Util.DataV] |
create [Sig_pack.S.PathCheck] |
create [Sig_pack.S.E] | `create v1 l v2` creates an edge from `v1` to `v2` with label `l`
create [Sig_pack.S.V] |
create [Sig_pack.S] | Return an empty graph.
create [Sig.I] | `create ()` returns an empty graph.
create [Sig.EDGE] | `create v1 l v2` creates an edge from `v1` to `v2` with label `l`
create [Sig.VERTEX] |
D
data [Cliquetree.CliqueTree.CliqueTreeV] |
data [Util.DataV] |
de_bruijn [Classic.S] | `de_bruijn n` builds the de Bruijn graph of order `n`.
de_bruijn [Sig_pack.S.Classic] | `de_bruijn n` builds the de Bruijn graph of order `n`.
default [Cliquetree.CliqueTree.CliqueTreeE] |
default [Sig.ORDERED_TYPE_DFT] |
default_edge_attributes [Graphviz.GraphWithDotAttrs] | Edge attributes
default_vertex_attributes [Graphviz.GraphWithDotAttrs] | Vertex attributes
dfs [Traverse.Mark] | `dfs g` traverses `g` in depth-first search, marking all nodes.
dfs [Sig_pack.S.Marking] |
direction [Fixpoint.Analysis] | the direction of the analysis
display_with_gv [Sig_pack.S] | Displays the given graph using the external tools "dot" and "gv" and returns when gv's window is closed
divisors [Classic.S] | `divisors n` builds the graph of divisors.
divisors [Sig_pack.S.Classic] | `divisors n` builds the graph of divisors.
dom_to_sdom [Dominator.Make] |
dominators_to_dom [Dominator.Make] | Given a function from a node to it's dominators, returns a function `dom : V.t -> V.t -> bool` s.t.
dominators_to_dom_tree [Dominator.Make] | Computes a dominator tree (function from x to a list of nodes immediately dominated by x) for the given CFG and dominator function.
dominators_to_idoms [Dominator.Make] | Given a function from a node to it's dominators, returns a function `idoms : G.V.t -> G.V.t -> bool` s.t.
dominators_to_sdom [Dominator.Make] | Given a function from a node to it's dominators, returns a function `sdom : V.t -> V.t -> bool` s.t.
dominators_to_sdominators [Dominator.Make] | Given a a function from a node to it's dominators, returns a function from a node to it's strict dominators.
dot_output [Sig_pack.S] | DOT output in a file
draw_with [XDotDraw] | Iterates on the drawing operations and updates the implicit drawing state
dst [Graphml.G.E] |
dst [Fixpoint.G.E] |
dst [Gml.G.E] |
dst [Flow.G_FORD_FULKERSON.E] |
dst [Kruskal.G.E] |
dst [Path.G.E] |
dst [Sig_pack.S.E] |
dst [Sig.EDGE] | Edge destination.
E
edge_attributes [Graphviz.GraphWithDotAttrs] |
empty [Contraction.G] |
empty [Strat.STRAT] |
empty [Gmap.E_DST] |
empty [Gmap.V_DST] |
empty [Builder.S] |
empty [Sig.P] | The empty graph.
equal [DGraphSubTree.Tree.V] |
equal [DGraphSubTree.G.V] |
equal [Fixpoint.Analysis] | predicate to determine the fixpoint
equal [Cliquetree.CliqueTree.CliqueTreeV] |
equal [Cliquetree.CliqueTree.CliqueV] |
equal [Gml.G.V] |
equal [Util.DataV] |
equal [Sig_pack.S.V] |
equal [Sig.COMPARABLE] |
equal [Sig.HASHABLE] |
equal [Sig.VERTEX] |
F
filter_map [Gmap.Edge] | `filter_map f g` applies `f` to each edge of `g` and so builds a new graph based on `g`; if `None` is returned by `f` the edge is omitted in the new graph.
filter_map [Gmap.Vertex] | `filter_map f g` applies `f` to each vertex of `g` and so builds a new graph based on `g`; if `None` is returned by `f` the vertex is omitted in the new graph.
find [Kruskal.UNIONFIND] |
find_all_edges [Sig_pack.S] |
find_all_edges [Sig.G] | `find_all_edges g v1 v2` returns all the edges from `v1` to `v2`.
find_edge [DGraphSubTree.G] |
find_edge [Sig_pack.S] |
find_edge [Sig.G] | `find_edge g v1 v2` returns the edge from `v1` to `v2` if it exists.
find_negative_cycle [Path.BellmanFord] | `find_negative_cycle g` looks for a negative-length cycle in graph `g` and returns it.
find_negative_cycle_from [Path.BellmanFord] | `find_negative_cycle_from g vs` looks for a negative-length cycle in graph `g` that is reachable from vertex `vs` and returns it as a list of edges.
find_vertex [Sig_pack.S] | `vertex g i` returns a vertex of label `i` in `g`.
flow [Flow.FLOW] |
fold [Topological.Make_stable] |
fold [Topological.Make] | `fold action g seed` allows iterating over the graph `g` in topological order.
fold [Delaunay.Triangulation] |
fold [Sig_pack.S.Topological] |
fold_edges [Sig_pack.S] |
fold_edges [Sig.G] | Fold on all edges of a graph.
fold_edges_e [Contraction.G] |
fold_edges_e [Gmap.E_SRC] |
fold_edges_e [Path.G] |
fold_edges_e [Sig_pack.S] |
fold_edges_e [Sig.G] | Fold on all edges of a graph.
fold_pred [Sig_pack.S] |
fold_pred [Sig.G] |
fold_pred_e [Flow.G_GOLDBERG] |
fold_pred_e [Sig_pack.S] |
fold_pred_e [Sig.G] |
fold_stable [Sig_pack.S.Topological] |
fold_succ [Strat.G] |
fold_succ [Minsep.G] |
fold_succ [Coloring.GM] |
fold_succ [Coloring.G] |
fold_succ [Traverse.G] |
fold_succ [Sig_pack.S] |
fold_succ [Sig.G] |
fold_succ_e [Flow.G_GOLDBERG] |
fold_succ_e [Sig_pack.S] |
fold_succ_e [Sig.G] |
fold_vertex [Contraction.G] |
fold_vertex [Leaderlist.G] |
fold_vertex [Fixpoint.G] |
fold_vertex [Strat.G] |
fold_vertex [Minsep.G] |
fold_vertex [Gmap.V_SRC] |
fold_vertex [Dominator.G] |
fold_vertex [Kruskal.G] |
fold_vertex [Coloring.GM] |
fold_vertex [Coloring.G] |
fold_vertex [Traverse.G] |
fold_vertex [Sig_pack.S] |
fold_vertex [Sig.G] | Fold on all vertices of a graph.
ford_fulkerson [Sig_pack.S] | Ford Fulkerson maximum flow algorithm
fprint_graph [Graphviz.Neato] | `fprint_graph ppf graph` pretty prints the graph `graph` in the CGL language on the formatter `ppf`.
fprint_graph [Graphviz.Dot] | `fprint_graph ppf graph` pretty prints the graph `graph` in the CGL language on the formatter `ppf`.
from_dot [DGraphContainer.Dot] |
from_dot_with_commands [DGraphContainer.Dot] |
from_graph [DGraphContainer.Make] |
from_graph [DGraphTreeModel.SubTreeMake] |
from_graph [DGraphModel.Make] | Creates a model using graphviz.
from_graph_with_commands [DGraphContainer.Make] |
from_model [DGraphTreeModel.SubTreeDotModelMake] |
from_model [DGraphTreeLayout.MakeFromDotModel] |
from_tree [DGraphTreeLayout.Make] |
full [Classic.S] | `full n` builds a graph with `n` vertices and all possible edges.
full [Sig_pack.S.Classic] | `full n` builds a graph with `n` vertices and all possible edges.
G
game [Strat.Algo] | `game g p a b` returns `true` iff `a` wins in `g` given the completion `p` (i.e.
get [Coloring.GM.Mark] |
get [Traverse.GM.Mark] |
get [Traverse.Bfs] |
get [Traverse.Dfs] |
get [Sig_pack.S.Mark] |
get [Sig.MARK] | Mark value (in O(1)).
get_graph_vertex [DGraphTreeModel.S.TreeManipulation] |
get_graph_vertex [DGraphSubTree.S] |
get_initial [Strat.PLAYER] |
get_root [DGraphSubTree.S] |
get_structure [DGraphTreeModel.S.TreeManipulation] |
get_structure [DGraphSubTree.S] |
get_subgraph [Graphviz.GraphWithDotAttrs] | The box (if exists) which the vertex belongs to.
get_tree_vertices [DGraphTreeModel.S.TreeManipulation] |
get_tree_vertices [DGraphSubTree.S] |
goldberg [Sig_pack.S] | Goldberg maximum flow algorithm
graph [Rand.Planar.S] | `graph xrange yrange prob v` generates a random planar graph with exactly `v` vertices.
graph [Rand.S] | `graph v e` generates a random graph with exactly `v` vertices and `e` edges.
graph [Sig_pack.S.Rand] | `random v e` generates a random with `v` vertices and `e` edges.
graph_attributes [Graphviz.GraphWithDotAttrs] | Graph, vertex and edge attributes.
H
handle_error [Graphviz.Neato] |
has_cycle [Traverse.Mark] | `has_cycle g` checks for a cycle in `g`.
has_cycle [Traverse.Dfs] | `has_cycle g` checks for a cycle in `g`.
has_cycle [Sig_pack.S.Marking] |
has_cycle [Sig_pack.S.Dfs] |
hash [DGraphSubTree.Tree.V] |
hash [DGraphSubTree.G.V] |
hash [Cliquetree.CliqueTree.CliqueTreeV] |
hash [Cliquetree.CliqueTree.CliqueV] |
hash [Gml.G.V] |
hash [Util.DataV] |
hash [Sig_pack.S.V] |
hash [Sig.COMPARABLE] |
hash [Sig.HASHABLE] |
hash [Sig.VERTEX] |
I
idom_to_dom [Dominator.Make] |
idom_to_dom_tree [Dominator.Make] | Computes a dominator tree (function from x to a list of nodes immediately dominated by x) for the given CFG and idom function.
idom_to_dominators [Dominator.Make] |
idom_to_idoms [Dominator.Make] |
in_circle [Delaunay.CCC] | The relation `in_circle p q r s` states that `s` lies inside the circle `(p,q,r)` if `ccw p q r` is true, or outside that circle if `ccw p q r` is false.
in_degree [Sig_pack.S] | `in_degree g v` returns the in-degree of `v` in `g`.
in_degree [Sig.G] | `in_degree g v` returns the in-degree of `v` in `g`.
init [Kruskal.UNIONFIND] |
intersect [Oper.S] | `intersect g1 g2` returns a new graph which is the intersection of `g1` and `g2`: each vertex and edge present in `g1` *and* `g2` is present in the resulting graph.
intersect [Sig_pack.S] | `intersect g1 g2` returns a new graph which is the intersection of `g1` and `g2`: each vertex and edge present in `g1` *and* `g2` is present in the resulting graph.
is_chordal [Cliquetree.CliqueTree] | `is_chordal g` uses the clique tree construction to test if a graph is chordal or not.
is_directed [Graphml.G] |
is_directed [Coloring.GM] |
is_directed [Coloring.G] |
is_directed [Traverse.G] |
is_directed [Sig_pack.S] | is this an implementation of directed graphs?
is_directed [Sig.G] | Is this an implementation of directed graphs?
is_empty [Sig_pack.S] |
is_empty [Sig.G] |
is_final [Strat.PLAYER] |
is_ghost_edge [DGraphTreeModel.S.TreeManipulation] |
is_ghost_edge [DGraphSubTree.S] |
is_ghost_node [DGraphTreeModel.S.TreeManipulation] |
is_ghost_node [DGraphSubTree.S] |
iter [Topological.Make_stable] |
iter [Topological.Make] | `iter action` calls `action node` repeatedly.
iter [Traverse.Bfs] |
iter [Traverse.Dfs] | `iter pre post g` visits all nodes of `g` in depth-first search, applying `pre` to each visited node before its successors, and `post` after them.
iter [Delaunay.Triangulation] | `iter f t` iterates over all edges of the triangulation `t`.
iter [Sig_pack.S.Topological] |
iter [Sig_pack.S.Bfs] |
iter [Sig_pack.S.Dfs] | `iter pre post g` visits all nodes of `g` in depth-first search, applying `pre` to each visited node before its successors, and `post` after them.
iter_component [Traverse.Bfs] |
iter_component [Traverse.Dfs] |
iter_component [Sig_pack.S.Bfs] |
iter_component [Sig_pack.S.Dfs] |
iter_edges [Sig_pack.S] |
iter_edges [Sig.G] | Iter on all edges of a graph.
iter_edges_e [Graphml.G] |
iter_edges_e [Gml.G] |
iter_edges_e [Flow.G_GOLDBERG] |
iter_edges_e [Kruskal.G] |
iter_edges_e [Sig_pack.S] |
iter_edges_e [Sig.G] | Iter on all edges of a graph.
iter_pred [DGraphSubTree.G] |
iter_pred [Sig_pack.S] |
iter_pred [Sig.G] |
iter_pred_e [Flow.G_FORD_FULKERSON] |
iter_pred_e [Sig_pack.S] |
iter_pred_e [Sig.G] |
iter_stable [Sig_pack.S.Topological] |
iter_succ [DGraphSubTree.G] |
iter_succ [Minsep.G] |
iter_succ [Topological.G] |
iter_succ [Coloring.GM] |
iter_succ [Coloring.G] |
iter_succ [Traverse.GM] |
iter_succ [Traverse.G] |
iter_succ [Path.G] |
iter_succ [Components.G] |
iter_succ [Sig_pack.S] |
iter_succ [Sig.G] |
iter_succ_e [Flow.G_FORD_FULKERSON] |
iter_succ_e [Path.G] |
iter_succ_e [Sig_pack.S] |
iter_succ_e [Sig.G] |
iter_triangles [Delaunay.Triangulation] |
iter_vertex [Graphml.G] |
iter_vertex [Minsep.G] |
iter_vertex [Gml.G] |
iter_vertex [Dominator.G] |
iter_vertex [Flow.G_GOLDBERG] |
iter_vertex [Topological.G] |
iter_vertex [Coloring.GM] |
iter_vertex [Coloring.G] |
iter_vertex [Traverse.GM] |
iter_vertex [Traverse.G] |
iter_vertex [Path.G] |
iter_vertex [Components.G] |
iter_vertex [Sig_pack.S] |
iter_vertex [Sig.G] | Iter on all vertices of a graph.
J
join [Fixpoint.Analysis] | operation how to join data when paths meet
L
label [DGraphSubTree.Tree.V] |
label [DGraphSubTree.G.V] |
label [Cliquetree.CliqueTree.CliqueTreeV] |
label [Cliquetree.CliqueTree.CliqueV] |
label [Gml.G.E] |
label [Gml.G.V] |
label [Flow.G_FORD_FULKERSON.E] |
label [Kruskal.G.E] |
label [Path.G.E] |
label [Util.DataV] |
label [Sig_pack.S.E] |
label [Sig_pack.S.V] |
label [Sig.EDGE] | Get the label of an edge.
label [Sig.VERTEX] |
labeled [Rand.S] | `labeled f` is similar to `graph` except that edges are labeled using function `f`.
labeled [Sig_pack.S.Rand] | `random_labeled f` is similar to `random` except that edges are labeled using function `f`
layout_of_dot [XDot.Make] | Using the dot file and graphviz, create an xdot and extracts its layout.
layout_of_xdot [XDot.Make] | Extracts a layout of an xdot file
leader_lists [Leaderlist.Make] | `leader_lists graph root` computes the leader lists or basic blocks of the given graph.
list_from_vertex [Oper.Neighbourhood] | Neighbourhood of a vertex as a list.
list_from_vertices [Oper.Neighbourhood] | Neighbourhood of a list of vertices as a list.
list_of_allminsep [Minsep.MINSEP] | Less efficient that `allminsep`
M
make [DGraphSubTree.Make_from_dot_model] |
make [DGraphSubTree.Make] |
make [Imperative.Matrix.S] | Creation.
map [Gmap.Edge] | `map f g` applies `f` to each edge of `g` and so builds a new graph based on `g`
map [Gmap.Vertex] | `map f g` applies `f` to each vertex of `g` and so builds a new graph based on `g`
map_vertex [Sig_pack.S] | map iterator on vertex
map_vertex [Sig.G] | Map on all vertices of a graph.
max_capacity [Flow.FLOW] |
maxflow [Flow.Ford_Fulkerson] | `maxflow g v1 v2` searchs the maximal flow from source `v1` to terminal `v2` using the Ford-Fulkerson algorithm.
maxflow [Flow.Goldberg] | `maxflow g v1 v2` searchs the maximal flow from source `v1` to terminal `v2` using the Goldberg algorithm.
maxwidth [Cliquetree.CliqueTree] | `maxwidth g tri tree` returns the maxwidth characteristic of the triangulation `tri` of graph `g` given the clique tree `tree` of `tri`.
mcs_clique [Cliquetree.CliqueTree] | `mcs_clique g` return an perfect elimination order of `g` (if it is chordal), the clique tree of `g` and its root.
mcsm [Mcs_m.MaximalCardinalitySearch.I] | `mcsm g` return a tuple `(o, e)` where o is a perfect elimination order of `g'` where `g'` is the triangulation `e` applied to `g`.
mcsm [Mcs_m.MaximalCardinalitySearch.P] | `mcsm g` returns a tuple `(o, e)` where `o` is a perfect elimination order of `g'` where `g'` is the triangulation `e` applied to `g`.
md [Md.I] | `md g` return a tuple `(g', e, o)` where `g'` is a triangulated graph, `e` is the triangulation of `g` and `o` is a perfect elimination order of `g'`
md [Md.P] | `md g` return a tuple `(g', e, o)` where `g'` is a triangulated graph, `e` is the triangulation of `g` and `o` is a perfect elimination order of `g'`
mem_edge [Sig_pack.S] |
mem_edge [Sig.G] |
mem_edge_e [Sig_pack.S] |
mem_edge_e [Sig.G] |
mem_vertex [Strat.G] |
mem_vertex [Sig_pack.S] |
mem_vertex [Sig.G] |
merge_edges_e [Merge.I] |
merge_edges_e [Merge.S] | If no element of `el` belongs to `g` then `merge_edges_e g (e::el)` is the graph `g`.
merge_edges_with_label [Merge.I] |
merge_edges_with_label [Merge.S] | The graph `merge_edges_with_label ?src ?tgt ?label g l` is the graph `merge_edges_e ?src ?dst g el` with `el` being the list of all edges of `g` carrying the label `l`.
merge_ends [Merge.I] |
merge_ends [Merge.S] | A vertex `v` of `g` is called an end if every edge of `g` arriving to `v` also starts from `v`.
merge_isolabelled_edges [Merge.I] |
merge_isolabelled_edges [Merge.S] | The graph `merge_isolabelled_edges g` is obtained from `g` by identifying two vertices when they are the sources (destinations) of two edges sharing the same label.
merge_scc [Merge.I] |
merge_scc [Merge.S] | The vertex of every strongly connected component are identified.
merge_starts [Merge.I] |
merge_starts [Merge.S] | A vertex `v` of `g` is called a start if every edge of `g` starting from `v` also arrives to `v`.
merge_vertex [Merge.I] |
merge_vertex [Merge.S] | If no element of `vl` belongs to `g` then `merge_vertex g (v::vl)` is the graph `g`.
min_capacity [Flow.FLOW] |
mirror [Oper.S] | `mirror g` returns a new graph which is the mirror image of `g`: each edge from `u` to `v` has been replaced by an edge from `v` to `u`.
mirror [Sig_pack.S] | `mirror g` returns a new graph which is the mirror image of `g`: each edge from `u` to `v` has been replaced by an edge from `v` to `u`.
mk_cluster_layout [XDot] | Creates a cluster layout
mk_edge_layout [XDot] | Creates an edge layout
mk_node_layout [XDot] | Creates a node layout
N
nb_edges [Sig_pack.S] |
nb_edges [Sig.G] |
nb_vertex [Dominator.G] |
nb_vertex [Flow.G_GOLDBERG] |
nb_vertex [Coloring.GM] |
nb_vertex [Coloring.G] |
nb_vertex [Path.G] |
nb_vertex [Sig_pack.S] |
nb_vertex [Sig.G] |
next [Strat.STRAT] |
normalize_color [XDotDraw] | Reads the color string and converts to rgb if in an another format
O
out_degree [Coloring.GM] |
out_degree [Coloring.G] |
out_degree [Sig_pack.S] | `out_degree g v` returns the out-degree of `v` in `g`.
out_degree [Sig.G] | `out_degree g v` returns the out-degree of `v` in `g`.
output_graph [Graphviz.Neato] | `output_graph oc graph` pretty prints the graph `graph` in the dot language on the channel `oc`.
output_graph [Graphviz.Dot] | `output_graph oc graph` pretty prints the graph `graph` in the dot language on the channel `oc`.
P
parse [XDotDraw] |
parse [Dot.Parse] | Parses a dot file
parse [Gml.Parse] |
parse_bounding_box_and_clusters [Dot.Parse] | Parses a dot file and returns the graph, its bounding box and a hash table from clusters to dot attributes
parse_dot_ast [Dot] |
parse_dot_file [Sig_pack.S] |
parse_gml_file [Sig_pack.S] |
postfix [Traverse.Dfs] | applies only a postfix function.
postfix [Sig_pack.S.Dfs] | applies only a postfix function
postfix_component [Traverse.Dfs] |
postfix_component [Sig_pack.S.Dfs] |
pred [Leaderlist.G] |
pred [Fixpoint.G] |
pred [Dominator.G] |
pred [Sig_pack.S] | `pred g v` returns the predecessors of `v` in `g`.
pred [Sig.G] | `pred g v` returns the predecessors of `v` in `g`.
pred_e [Fixpoint.G] |
pred_e [Sig_pack.S] | `pred_e g v` returns the edges going to `v` in `g`.
pred_e [Sig.G] | `pred_e g v` returns the edges going to `v` in `g`.
prefix [Traverse.Dfs] | applies only a prefix function; note that this function is more efficient than `iter` and is tail-recursive.
prefix [Sig_pack.S.Dfs] | applies only a prefix function
prefix_component [Traverse.Dfs] |
prefix_component [Sig_pack.S.Dfs] |
print [Graphml.Print] | `print fmt graph` print the GraphMl representation of the given graph on the given formatter
print [Gml.Print] |
print_gml [Sig_pack.S] |
print_gml_file [Sig_pack.S] |
R
random_few_edges [Rand.S] |
random_many_edges [Rand.S] |
read_bounding_box [XDot] |
read_cluster_layout [XDot] |
read_dot [DGraphModel] | Creates a model from a dot file.
read_edge_layout [XDot] |
read_node_layout [XDot] | Reads xdot layouts from the dot ast
read_xdot [DGraphModel] | Creates a model from an xdot file (the layout is not recomputed)
remove_edge [Builder.S] |
remove_edge [Sig_pack.S] | `remove_edge g v1 v2` removes the edge going from `v1` to `v2` from the graph `g`.
remove_edge [Sig.I] | `remove_edge g v1 v2` removes the edge going from `v1` to `v2` from the graph `g`.
remove_edge [Sig.P] | `remove_edge g v1 v2` removes the edge going from `v1` to `v2` from the graph `g`.
remove_edge_e [Builder.S] |
remove_edge_e [Sig_pack.S] | `remove_edge_e g e` removes the edge `e` from the graph `g`.
remove_edge_e [Sig.I] | `remove_edge_e g e` removes the edge `e` from the graph `g`.
remove_edge_e [Sig.P] | `remove_edge_e g e` removes the edge `e` from the graph `g`.
remove_vertex [Builder.S] |
remove_vertex [Sig_pack.S] | `remove g v` removes the vertex `v` from the graph `g` (and all the edges going from `v` in `g`).
remove_vertex [Sig.I] | `remove g v` removes the vertex `v` from the graph `g` (and all the edges going from `v` in `g`).
remove_vertex [Sig.P] | `remove g v` removes the vertex `v` from the graph `g` (and all the edges going from `v` in `g`).
S
scc [Components.Make] | `scc g` computes the strongly connected components of `g`.
scc [Sig_pack.S.Components] | strongly connected components
scc_array [Components.Make] | `scc_array` computes the strongly connected components of `g`.
scc_array [Sig_pack.S.Components] |
scc_list [Components.Make] | `scc_list` computes the strongly connected components of `g`.
scc_list [Sig_pack.S.Components] |
set [Coloring.GM.Mark] |
set [Traverse.GM.Mark] |
set [Sig_pack.S.Mark] |
set [Sig.MARK] | Set the mark of the given vertex.
set_command [Graphviz.Neato] | Several functions provided by this module run the external program neato.
set_data [Util.DataV] |
set_from_vertex [Oper.Neighbourhood] | Neighbourhood of a vertex as a set.
set_from_vertices [Oper.Neighbourhood] | Neighbourhood of a list of vertices as a set.
set_of_allminsep [Minsep.MINSEP] | Less efficient that `allminsep`
shortest_path [Path.Dijkstra] | `shortest_path g v1 v2` computes the shortest path from vertex `v1` to vertex `v2` in graph `g`.
shortest_path [Sig_pack.S] | Dijkstra's shortest path algorithm.
spanningtree [Kruskal.Generic] |
spanningtree [Kruskal.Make] |
spanningtree [Sig_pack.S] | Kruskal algorithm
src [Graphml.G.E] |
src [Fixpoint.G.E] |
src [Gml.G.E] |
src [Flow.G_FORD_FULKERSON.E] |
src [Kruskal.G.E] |
src [Path.G.E] |
src [Sig_pack.S.E] |
src [Sig.EDGE] | Edge origin.
start [Traverse.Bfs] |
start [Traverse.Dfs] |
step [Traverse.Bfs] |
step [Traverse.Dfs] |
strategy [Strat.Algo] | `strategy g p s` returns `true` iff `s` wins in `g` given the completion `p`, whatever strategy plays the other player.
strategyA [Strat.Algo] | `strategyA g p` returns `true` iff there exists `a` winning stragegy for the true player.
string_scale_size [XDotDraw] | `string_scale_size font font_size text`.
sub [Flow.FLOW] |
succ [Leaderlist.G] |
succ [Fixpoint.G] |
succ [Strat.G] |
succ [Minsep.G] |
succ [Dominator.G] |
succ [Sig_pack.S] | `succ g v` returns the successors of `v` in `g`.
succ [Sig.G] | `succ g v` returns the successors of `v` in `g`.
succ_e [Fixpoint.G] |
succ_e [Sig_pack.S] | `succ_e g v` returns the edges going from `v` in `g`.
succ_e [Sig.G] | `succ_e g v` returns the edges going from `v` in `g`.
T
transitive_closure [Oper.S] | `transitive_closure ?reflexive g` returns the transitive closure of `g` (as a new graph).
transitive_closure [Sig_pack.S] | `transitive_closure ?reflexive g` returns the transitive closure of `g` (as a new graph).
tree [DGraphTreeModel.S] |
triangulate [Md.I] | `triangulate g` return the graph `g'` produced by applying miminum degree to `g`.
triangulate [Md.P] | `triangulate g` return the graph `g'` produced by applying miminum degree to `g`.
triangulate [Mcs_m.MaximalCardinalitySearch.I] | `triangulate g` triangulates `g` using the MCS-M algorithm
triangulate [Mcs_m.MaximalCardinalitySearch.P] | `triangulate g` computes a triangulation of `g` using the MCS-M algorithm
triangulate [Delaunay.Triangulation] | `triangulate a` computes the Delaunay triangulation of a set of points, given as an array `a`.
turn [Strat.PLAYER] |
U
union [Kruskal.UNIONFIND] |
union [Oper.S] | `union g1 g2` returns a new graph which is the union of `g1` and `g2`: each vertex and edge present in `g1` *or* `g2` is present in the resulting graph.
union [Sig_pack.S] | `union g1 g2` returns a new graph which is the union of `g1` and `g2`: each vertex and edge present in `g1` *or* `g2` is present in the resulting graph.
V
vertex [Cliquetree.CliqueTree.CliqueV] |
vertex_attributes [Graphviz.GraphWithDotAttrs] |
vertex_name [Graphviz.GraphWithDotAttrs] |
vertex_only [Classic.S] | `vertex_only n` builds a graph with `n` vertices and no edge.
vertex_only [Sig_pack.S.Classic] | `vertex_only n` builds a graph with `n` vertices and no edge.
vertices [Cliquetree.CliqueTree.CliqueTreeE] | Vertices in the clique tree edge (intersection of the two clique extremities).
view [DGraphView.S] | View as a Gnome Canvas.
view_cluster [DGraphViewItem] |
view_edge [DGraphViewItem] |
view_node [DGraphViewItem] |
W
weight [Nonnegative.WEIGHT] | Get the weight of an edge.
weight [Path.WEIGHT] | Get the weight of an edge.
Z
zero [Flow.FLOW] |
zero [Nonnegative.WEIGHT] | Neutral element for `Nonnegative.WEIGHT.add`.
zero [Path.WEIGHT] | Neutral element for `Path.WEIGHT.add`.