Std.Graph
Graph signature.
A graph is a set of relations between objects, defined as a pair of two sets
G = (V,E).
where $V$ is a set of vertices and E is a set of vertices, which is a subset of V x V
, therefore a more precise definition is a 6-tuple, consisting of a set of nodes, edges, node labels, edge labels, and two functions that maps nodes and edges to their corresponding labels:
G = (N, E, N', E', ν : N -> N', ε : E -> E'),
where set E
is a subset of N × N
.
With this general framework an unlabeled graph can be represented as:
G = (N, E, N, E, ν = λx.x, ε = λx.x)
Another possible representation of an unlabeled graph would be:
G = (N, E, {u}, {v}, ν = λx.u, ε = λx.v).
Implementations are free to choose any suitable representation of graph data structure, if it conforms to the graph signature and all operations follows the described semantics and properties of a graph structure are preserved.
The axiomatic semantics of operations on a graph is described by a set of postconditions. To describe the semantics of an operation in terms of input and output arguments, we project graphs to its fields with the following notation <field>(<graph>)
, e.g., N(g)
is a set of nodes of graph g
.
val empty : t
empty
is an empty graph
val nodes : t -> node Regular.Std.seq
nodes g
returns all nodes of graph g
in an unspecified order
val edges : t -> edge Regular.Std.seq
edges g
returns all edges of graph g
in an unspecified order
val number_of_edges : t -> int
number_of_edges g
returns the size of a graph g
.
val number_of_nodes : t -> int
number_of_nodes g
returns the order of a graph g
All graphs provides a common interface for any opaque data structure
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
All graphs are printable.
include Regular.Std.Printable.S with type t := t
val to_string : t -> string
to_string x
returns a human-readable representation of x
val str : unit -> t -> string
str () t
is formatted output function that matches "%a" conversion format specifier in functions, that prints to string, e.g., sprintf
, failwithf
, errorf
and, surprisingly all Lwt
printing function, including Lwt_io.printf
and logging (or any other function with type ('a,unit,string,...) formatN`. Example:
Or_error.errorf "type %a is not valid for %a"
Type.str ty Exp.str exp
val pps : unit -> t -> string
synonym for str
val ppo : Core_kernel.Out_channel.t -> t -> unit
will print to a standard output_channel
, useful for using in printf
, fprintf
, etc.
val pp_seq : Stdlib.Format.formatter -> t Core_kernel.Sequence.t -> unit
prints a sequence of values of type t
this will include pp
function from Core
that has type t printer
, and can be used in Format.printf
family of functions
include Core_kernel.Pretty_printer.S with type t := t
val pp : Base__.Formatter.t -> t -> unit