Std.Node
Graph
nodes. Semantics of operations is denoted using mathematical model, described in Graph
interface.
The node
and label
types are almost always have identical representation. For labeled graphs the comparison function for the node
is different than the comparison function for the label, therefore it is a good idea to hide their representation equality in the interface.
create x
creates a node labeled with x
.
For unlabeled graphs this is an identity function.
mem n g
is true
if n
is a member of nodes N
of graph g
.
For labeled graphs the membership is tested without taking into account the label of the node.
val succs : t -> graph -> t Regular.Std.seq
succs node graph
returns a sequence of successors of a node
in a a given graph
val preds : t -> graph -> t Regular.Std.seq
preds node graph
returns a sequence of predecessors of a node
in a a given graph
val inputs : t -> graph -> edge Regular.Std.seq
inputs node graph
is incoming edges of a node
in graph
val outputs : t -> graph -> edge Regular.Std.seq
outputs node graph
is outcomming edges of a node
in graph
degree ?dir n
when in_or_out
is `In
then returns the amount of incoming edges, otherwise returns the amount of outcomming edges. If parameter dir
is left absent, then return the amount of adjacent nodes (i.e., a sum of incoming and outcomming edges).
insert n g
returns new graph g'
that has a set of nodes N
extended with node n
. If N
was contained n
, then the g == g'
. Use update
to change existing nodes.
Postconditions:
- N(g') = N(g) ∪ {n}.
update n l g
for a graph with labeled nodes if node n
is not in N(g)
then returns g
else returns graph g
where node n
is labeled with l
.
For unlabeled graph returns g
.
Postconditions:
- n ∉ N(g) -> n ∉ N(g'). - n ∈ N(g) → ν(g')n = l.
remove n g
returns graph g'
, with a node n
removed from a set of nodes N
.
Postconditions:
- E(g) ⊆ E(g') - N(g) ⊆ N(g') - N(g') = N(g) \ {n}.
edge x y g
if graph g
has an edge between nodes x
and y
then it is returned.
node provides common data structures, like Table, Map, Set, Hash_set, etc.
include Regular.Std.Opaque.S with type t := t
include Core_kernel.Comparable.S with type t := t
val comparator : (t, comparator_witness) Base__.Comparator.comparator
module Replace_polymorphic_compare : sig ... end
module Map : sig ... end
module Set : sig ... end
include Core_kernel.Hashable.S with type t := t
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t ->
Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
val hashable : t Core_kernel__.Hashtbl.Hashable.t
module Table : sig ... end
module Hash_set : sig ... end
module Hash_queue : sig ... end