Index of values


A
add [Flow.FLOW]
add [Path.WEIGHT]
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 [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 [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 from the graph g.
add_vertex [Sig.P]
add_vertex g v adds the vertex v from the graph g.

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,... *
clear [Traverse.GM.Mark]
clear [Sig_pack.S.Mark]
clear g removes all the marks from all the vertives of g.
clear [Sig.IA.Mark]
clear g removes all the marks from all the vertives of g.
compare [Flow.G_GOLDBERG.E]
compare [Flow.FLOW]
compare [Path.WEIGHT]
compare [Sig_pack.S.E]
compare [Sig_pack.S.V]
compare [Sig.COMPARABLE]
compare [Sig.ORDERED_TYPE]
compare [Sig.G.E]
compare [Sig.G.V]
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.
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 [Flow.G_GOLDBERG.E]
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]
Return an empty graph.
create [Sig.G.E]
create v1 l v2 creates an edge from v1 to v2 with label l
create [Sig.G.V]

D
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 [Sig.ORDERED_TYPE_DFT]
dfs [Traverse.Mark]
dfs g traverses g in depth-first search, marking all nodes.
dfs [Sig_pack.S.Marking]
divisors [Classic.S]
divisors n builds the graph of divisors.
divisors [Sig_pack.S.Classic]
divisors n builds the graph of divisors.
dot_output [Sig_pack.S]
DOT output
dst [Flow.G_FORD_FULKERSON.E]
dst [Flow.G_GOLDBERG.E]
dst [Kruskal.G.E]
dst [Path.G.E]
dst [Sig_pack.S.E]
dst [Sig.G.E]

E
empty [Builder.S]
empty [Sig.P]
The empty graph.
equal [Sig_pack.S.V]
equal [Sig.COMPARABLE]
equal [Sig.HASHABLE]
equal [Sig.G.V]

F
find [Kruskal.UNIONFIND]
find_vertex [Sig_pack.S]
vertex g i returns a vertex of label i in g.
flow [Flow.FLOW]
fold [Topological.Make]
fold action seed g 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_edges_e [Sig_pack.S]
fold_edges_e [Sig.G]
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_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 [Traverse.G]
fold_vertex [Sig_pack.S]
fold_vertex [Sig.G]
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.
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
get [Traverse.GM.Mark]
get [Traverse.Bfs]
get [Traverse.Dfs]
get [Sig_pack.S.Mark]
get [Sig.IA.Mark]
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.

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 [Sig_pack.S.V]
hash [Sig.COMPARABLE]
hash [Sig.HASHABLE]
hash [Sig.G.V]

I
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 [Topological.G]
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_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]
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_edges_e [Flow.G_GOLDBERG]
iter_edges_e [Kruskal.G]
iter_edges_e [Sig_pack.S]
iter_edges_e [Sig.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_succ [Components.G]
iter_succ [Topological.G]
iter_succ [Traverse.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_vertex [Flow.G_GOLDBERG]
iter_vertex [Kruskal.G]
iter_vertex [Components.G]
iter_vertex [Topological.G]
iter_vertex [Traverse.G]
iter_vertex [Sig_pack.S]
iter_vertex [Sig.G]

L
label [Flow.G_FORD_FULKERSON.E]
label [Flow.G_GOLDBERG.E]
label [Kruskal.G.E]
label [Path.G.E]
label [Sig_pack.S.E]
label [Sig_pack.S.V]
label [Sig.G.E]
label [Sig.G.V]
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

M
make [Imperative.Matrix.S]
Creation.
map_vertex [Sig_pack.S]
map iterator on vertex
map_vertex [Sig.G]
map iterator on vertex
max_capacity [Flow.FLOW]
maxflow [Flow.Ford_Fulkerson]
maxflow g v1 v2 searchs the maximal flow from v1 to v2 using the Ford-Fulkerson algorithm.
maxflow [Flow.Goldberg]
maxflow g v1 v2 searchs the maximal flow from v1 to v2 using the Goldberg algorithm.
mem_edge [Sig_pack.S]
mem_edge [Sig.G]
mem_edge_e [Sig_pack.S]
mem_edge_e [Sig.G]
mem_vertex [Sig_pack.S]
mem_vertex [Sig.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.

N
nb_edges [Sig_pack.S]
nb_edges [Sig.G]
nb_vertex [Flow.G_GOLDBERG]
nb_vertex [Sig_pack.S]
nb_vertex [Sig.G]

O
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
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 [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 [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
prefix [Sig_pack.S.Dfs]
applies only a prefix function
prefix_component [Traverse.Dfs]
prefix_component [Sig_pack.S.Dfs]

R
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 [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 [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]
strongly connected components
set [Traverse.GM.Mark]
set [Sig_pack.S.Mark]
set [Sig.IA.Mark]
set_command [Graphviz.Neato]
Several functions provided by this module run the external program neato.
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 [Flow.G_FORD_FULKERSON.E]
src [Flow.G_GOLDBERG.E]
src [Kruskal.G.E]
src [Sig_pack.S.E]
src [Sig.G.E]
start [Traverse.Bfs]
start [Traverse.Dfs]
step [Traverse.Bfs]
step [Traverse.Dfs]
sub [Flow.FLOW]
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 [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).
triangulate [Delaunay.Triangulation]
triangulate a computes the Delaunay triangulation of a set of points, given as an array a.

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_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.

W
weight [Path.WEIGHT]

Z
zero [Flow.FLOW]
zero [Path.WEIGHT]