sig
module Digraph :
sig
module Concrete :
functor (V : Graph.Sig.COMPARABLE) ->
sig
module V :
sig
type t = V.t
val compare : t -> t -> int
val hash : t -> int
val equal : t -> t -> bool
type label = t
val label : 'a -> 'a
val create : 'a -> 'a
end
module HM :
sig
type 'a return = 'a PMAP(V).return
type 'a t = 'a PMAP(V).t
type key = V.t
val create : ?size:int -> unit -> 'a t
val create_from : 'a t -> 'a t
val empty : 'a return
val clear : 'a t -> unit
val is_empty : 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val remove : key -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val find_and_raise : key -> 'a t -> string -> 'a
val iter : (key -> 'a -> unit) -> 'a t -> unit
val map : (key -> 'a -> key * 'a) -> 'a t -> 'a t
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val copy : 'a t -> 'a t
end
module S :
sig
type elt = V.t
type t = Set.Make(V).t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val min_elt : t -> elt
val max_elt : t -> elt
val choose : t -> elt
val split : elt -> t -> t * bool * t
val find : elt -> t -> elt
val of_list : elt list -> t
end
module E :
sig
type vertex = V.t
type t = V.t * V.t
val compare : t -> t -> int
val src : 'a * 'b -> 'a
val dst : 'a * 'b -> 'b
type label = unit
val label : 'a -> unit
val create : 'a -> unit -> 'b -> 'a * 'b
end
type edge = E.t
val mem_edge : S.t HM.t -> HM.key -> S.elt -> bool
val mem_edge_e : S.t HM.t -> HM.key * S.elt -> bool
val find_edge : S.t HM.t -> HM.key -> S.elt -> HM.key * S.elt
val find_all_edges :
S.t HM.t -> HM.key -> S.elt -> (HM.key * S.elt) list
val unsafe_remove_edge : S.t HM.t -> HM.key -> S.elt -> S.t HM.t
val unsafe_remove_edge_e : S.t HM.t -> HM.key * S.elt -> S.t HM.t
val remove_edge : S.t HM.t -> HM.key -> HM.key -> S.t HM.t
val remove_edge_e : S.t HM.t -> HM.key * HM.key -> S.t HM.t
val iter_succ : (S.elt -> unit) -> S.t HM.t -> HM.key -> unit
val fold_succ :
(S.elt -> 'a -> 'a) -> S.t HM.t -> HM.key -> 'a -> 'a
val iter_succ_e :
(HM.key * S.elt -> unit) -> S.t HM.t -> HM.key -> unit
val fold_succ_e :
(HM.key * S.elt -> 'a -> 'a) -> S.t HM.t -> HM.key -> 'a -> 'a
val succ : S.t HM.t -> HM.key -> S.elt list
val succ_e : S.t HM.t -> HM.key -> (HM.key * S.elt) list
val map_vertex : (HM.key -> HM.key) -> S.t HM.t -> S.t HM.t
module I :
sig
type t = S.t HM.t
module PV :
sig
type t = V.t
val compare : t -> t -> int
val hash : t -> int
val equal : t -> t -> bool
end
module PE = E
val iter_edges :
(HM.key -> S.elt -> unit) -> S.t HM.t -> unit
val fold_edges :
(HM.key -> S.elt -> 'a -> 'a) -> S.t HM.t -> 'a -> 'a
val iter_edges_e :
(HM.key * S.elt -> unit) -> S.t HM.t -> unit
val fold_edges_e :
(HM.key * S.elt -> 'a -> 'a) -> S.t HM.t -> 'a -> 'a
end
type t = S.t HM.t
module PV = I.PV
module PE = I.PE
val iter_edges : (HM.key -> S.elt -> unit) -> S.t HM.t -> unit
val fold_edges :
(HM.key -> S.elt -> 'a -> 'a) -> S.t HM.t -> 'a -> 'a
val iter_edges_e : (HM.key * S.elt -> unit) -> S.t HM.t -> unit
val fold_edges_e :
(HM.key * S.elt -> 'a -> 'a) -> S.t HM.t -> 'a -> 'a
val iter_pred : (V.t -> unit) -> S.t HM.t -> V.t -> unit
val fold_pred : (V.t -> 'a -> 'a) -> S.t HM.t -> V.t -> 'a -> 'a
val pred : S.t HM.t -> V.t -> V.t list
val in_degree : S.t HM.t -> V.t -> int
val iter_pred_e : (V.t * V.t -> unit) -> S.t HM.t -> V.t -> unit
val fold_pred_e :
(V.t * V.t -> 'a -> 'a) -> S.t HM.t -> V.t -> 'a -> 'a
val pred_e : S.t HM.t -> V.t -> (V.t * V.t) list
type vertex = HM.key
val is_directed : bool
val empty : 'a HM.return
val create : ?size:int -> unit -> 'a HM.t
val is_empty : 'a HM.t -> bool
val copy : 'a HM.t -> 'a HM.t
val clear : 'a HM.t -> unit
val nb_vertex : 'a HM.t -> int
val nb_edges : S.t HM.t -> int
val out_degree : S.t HM.t -> HM.key -> int
val mem_vertex : 'a HM.t -> HM.key -> bool
val unsafe_add_vertex : S.t HM.t -> HM.key -> S.t HM.t
val unsafe_add_edge : S.t HM.t -> HM.key -> S.elt -> S.t HM.t
val add_vertex : S.t HM.t -> HM.key -> S.t HM.t
val iter_vertex : (HM.key -> unit) -> 'a HM.t -> unit
val fold_vertex : (HM.key -> 'a -> 'a) -> 'b HM.t -> 'a -> 'a
val add_edge : S.t HM.t -> HM.key -> S.elt -> S.t HM.t
val add_edge_e : S.t HM.t -> HM.key * S.elt -> S.t HM.t
end
module ConcreteBidirectional :
functor (V : Graph.Sig.COMPARABLE) ->
sig
module V :
sig
type t = V.t
val compare : t -> t -> int
val hash : t -> int
val equal : t -> t -> bool
type label = t
val label : 'a -> 'a
val create : 'a -> 'a
end
module HM :
sig
type 'a return = 'a PMAP(V).return
type 'a t = 'a PMAP(V).t
type key = V.t
val create : ?size:int -> unit -> 'a t
val create_from : 'a t -> 'a t
val empty : 'a return
val clear : 'a t -> unit
val is_empty : 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val remove : key -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val find_and_raise : key -> 'a t -> string -> 'a
val iter : (key -> 'a -> unit) -> 'a t -> unit
val map : (key -> 'a -> key * 'a) -> 'a t -> 'a t
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val copy : 'a t -> 'a t
end
module S :
sig
type elt = V.t
type t = Set.Make(V).t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val min_elt : t -> elt
val max_elt : t -> elt
val choose : t -> elt
val split : elt -> t -> t * bool * t
val find : elt -> t -> elt
val of_list : elt list -> t
end
module E :
sig
type vertex = V.t
type t = V.t * V.t
val compare : t -> t -> int
val src : 'a * 'b -> 'a
val dst : 'a * 'b -> 'b
type label = unit
val label : 'a -> unit
val create : 'a -> unit -> 'b -> 'a * 'b
end
type edge = E.t
val mem_edge : ('a * S.t) HM.t -> HM.key -> S.elt -> bool
val mem_edge_e : ('a * S.t) HM.t -> HM.key * S.elt -> bool
val find_edge :
('a * S.t) HM.t -> HM.key -> S.elt -> HM.key * S.elt
val find_all_edges :
('a * S.t) HM.t -> HM.key -> S.elt -> (HM.key * S.elt) list
val unsafe_remove_edge :
(S.t * S.t) HM.t -> HM.key -> S.elt -> (S.t * S.t) HM.t
val unsafe_remove_edge_e :
(S.t * S.t) HM.t -> HM.key * S.elt -> (S.t * S.t) HM.t
val remove_edge :
(S.t * S.t) HM.t -> HM.key -> HM.key -> (S.t * S.t) HM.t
val remove_edge_e :
(S.t * S.t) HM.t -> HM.key * HM.key -> (S.t * S.t) HM.t
val iter_succ :
(S.elt -> unit) -> ('a * S.t) HM.t -> HM.key -> unit
val fold_succ :
(S.elt -> 'a -> 'a) -> ('b * S.t) HM.t -> HM.key -> 'a -> 'a
val iter_succ_e :
(HM.key * S.elt -> unit) -> ('a * S.t) HM.t -> HM.key -> unit
val fold_succ_e :
(HM.key * S.elt -> 'a -> 'a) ->
('b * S.t) HM.t -> HM.key -> 'a -> 'a
val succ : ('a * S.t) HM.t -> HM.key -> S.elt list
val succ_e : ('a * S.t) HM.t -> HM.key -> (HM.key * S.elt) list
val map_vertex :
(HM.key -> HM.key) -> (S.t * S.t) HM.t -> (S.t * S.t) HM.t
module I :
sig
type t = (S.t * S.t) HM.t
module PV :
sig
type t = V.t
val compare : t -> t -> int
val hash : t -> int
val equal : t -> t -> bool
end
module PE = E
val iter_edges :
(HM.key -> S.elt -> unit) -> ('a * S.t) HM.t -> unit
val fold_edges :
(HM.key -> S.elt -> 'a -> 'a) ->
('b * S.t) HM.t -> 'a -> 'a
val iter_edges_e :
(HM.key * S.elt -> unit) -> ('a * S.t) HM.t -> unit
val fold_edges_e :
(HM.key * S.elt -> 'a -> 'a) -> ('b * S.t) HM.t -> 'a -> 'a
end
type t = (S.t * S.t) HM.t
module PV = I.PV
module PE = I.PE
val iter_edges :
(HM.key -> S.elt -> unit) -> ('a * S.t) HM.t -> unit
val fold_edges :
(HM.key -> S.elt -> 'a -> 'a) -> ('b * S.t) HM.t -> 'a -> 'a
val iter_edges_e :
(HM.key * S.elt -> unit) -> ('a * S.t) HM.t -> unit
val fold_edges_e :
(HM.key * S.elt -> 'a -> 'a) -> ('b * S.t) HM.t -> 'a -> 'a
val iter_pred :
(S.elt -> unit) -> (S.t * 'a) HM.t -> HM.key -> unit
val fold_pred :
(S.elt -> 'a -> 'a) -> (S.t * 'b) HM.t -> HM.key -> 'a -> 'a
val pred : (S.t * 'a) HM.t -> HM.key -> S.elt list
val in_degree : (S.t * 'a) HM.t -> HM.key -> int
val iter_pred_e :
(S.elt * HM.key -> unit) -> (S.t * 'a) HM.t -> HM.key -> unit
val fold_pred_e :
(S.elt * HM.key -> 'a -> 'a) ->
(S.t * 'b) HM.t -> HM.key -> 'a -> 'a
val pred_e : (S.t * 'a) HM.t -> HM.key -> (S.elt * HM.key) list
type vertex = HM.key
val is_directed : bool
val empty : 'a HM.return
val create : ?size:int -> unit -> 'a HM.t
val clear : 'a HM.t -> unit
val is_empty : 'a HM.t -> bool
val copy : 'a HM.t -> 'a HM.t
val nb_vertex : 'a HM.t -> int
val nb_edges : ('a * S.t) HM.t -> int
val out_degree : ('a * S.t) HM.t -> HM.key -> int
val mem_vertex : 'a HM.t -> HM.key -> bool
val unsafe_add_vertex :
(S.t * S.t) HM.t -> HM.key -> (S.t * S.t) HM.t
val add_vertex : (S.t * S.t) HM.t -> HM.key -> (S.t * S.t) HM.t
val iter_vertex : (HM.key -> unit) -> 'a HM.t -> unit
val fold_vertex : (HM.key -> 'a -> 'a) -> 'b HM.t -> 'a -> 'a
val unsafe_add_edge :
(S.t * S.t) HM.t -> HM.key -> S.elt -> (S.t * S.t) HM.t
val add_edge :
(S.t * S.t) HM.t -> HM.key -> S.elt -> (S.t * S.t) HM.t
val add_edge_e :
(S.t * S.t) HM.t -> HM.key * S.elt -> (S.t * S.t) HM.t
end
module ConcreteLabeled :
functor
(V : Graph.Sig.COMPARABLE) (Edge : Graph.Sig.ORDERED_TYPE_DFT) ->
sig
module V :
sig
type t = V.t
val compare : t -> t -> int
val hash : t -> int
val equal : t -> t -> bool
type label = t
val label : 'a -> 'a
val create : 'a -> 'a
end
module HM :
sig
type 'a return = 'a PMAP(V).return
type 'a t = 'a PMAP(V).t
type key = V.t
val create : ?size:int -> unit -> 'a t
val create_from : 'a t -> 'a t
val empty : 'a return
val clear : 'a t -> unit
val is_empty : 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val remove : key -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val find_and_raise : key -> 'a t -> string -> 'a
val iter : (key -> 'a -> unit) -> 'a t -> unit
val map : (key -> 'a -> key * 'a) -> 'a t -> 'a t
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val copy : 'a t -> 'a t
end
module VE :
sig type t = V.t * Edge.t val compare : t -> t -> int end
module S :
sig
type elt = VE.t
type t = Set.Make(VE).t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val min_elt : t -> elt
val max_elt : t -> elt
val choose : t -> elt
val split : elt -> t -> t * bool * t
val find : elt -> t -> elt
val of_list : elt list -> t
end
module E :
sig
type vertex = V.t
type label = Edge.t
type t = vertex * label * vertex
val src : 'a * 'b * 'c -> 'a
val dst : 'a * 'b * 'c -> 'c
val label : 'a * 'b * 'c -> 'b
val create : 'a -> 'b -> 'c -> 'a * 'b * 'c
module C :
sig type t = V.t * VE.t val compare : t -> t -> int end
val compare : V.t * Edge.t * V.t -> V.t * Edge.t * V.t -> int
end
type edge = E.t
val mem_edge : S.t HM.t -> HM.key -> V.t -> bool
val mem_edge_e : S.t HM.t -> HM.key * Edge.t * V.t -> bool
exception Found of edge
val find_edge : S.t HM.t -> E.vertex -> V.t -> edge
val find_all_edges :
S.t HM.t -> HM.key -> V.t -> (HM.key * Edge.t * V.t) list
val unsafe_remove_edge : S.t HM.t -> HM.key -> V.t -> S.t HM.t
val unsafe_remove_edge_e :
S.t HM.t -> HM.key * Edge.t * V.t -> S.t HM.t
val remove_edge : S.t HM.t -> HM.key -> HM.key -> S.t HM.t
val remove_edge_e :
S.t HM.t -> HM.key * Edge.t * HM.key -> S.t HM.t
val iter_succ : (V.t -> unit) -> S.t HM.t -> HM.key -> unit
val fold_succ :
(V.t -> 'a -> 'a) -> S.t HM.t -> HM.key -> 'a -> 'a
val iter_succ_e :
(HM.key * Edge.t * V.t -> unit) -> S.t HM.t -> HM.key -> unit
val fold_succ_e :
(HM.key * Edge.t * V.t -> 'a -> 'a) ->
S.t HM.t -> HM.key -> 'a -> 'a
val succ : S.t HM.t -> HM.key -> V.t list
val succ_e : S.t HM.t -> HM.key -> (HM.key * Edge.t * V.t) list
val map_vertex : (HM.key -> HM.key) -> S.t HM.t -> S.t HM.t
module I :
sig
type t = S.t HM.t
module PV :
sig
type t = V.t
val compare : t -> t -> int
val hash : t -> int
val equal : t -> t -> bool
end
module PE = E
val iter_edges : (HM.key -> V.t -> unit) -> S.t HM.t -> unit
val fold_edges :
(HM.key -> V.t -> 'a -> 'a) -> S.t HM.t -> 'a -> 'a
val iter_edges_e :
(HM.key * Edge.t * V.t -> unit) -> S.t HM.t -> unit
val fold_edges_e :
(HM.key * Edge.t * V.t -> 'a -> 'a) -> S.t HM.t -> 'a -> 'a
end
type t = S.t HM.t
module PV = I.PV
module PE = I.PE
val iter_edges : (HM.key -> V.t -> unit) -> S.t HM.t -> unit
val fold_edges :
(HM.key -> V.t -> 'a -> 'a) -> S.t HM.t -> 'a -> 'a
val iter_edges_e :
(HM.key * Edge.t * V.t -> unit) -> S.t HM.t -> unit
val fold_edges_e :
(HM.key * Edge.t * V.t -> 'a -> 'a) -> S.t HM.t -> 'a -> 'a
val iter_pred : (V.t -> unit) -> S.t HM.t -> V.t -> unit
val fold_pred : (V.t -> 'a -> 'a) -> S.t HM.t -> V.t -> 'a -> 'a
val pred : S.t HM.t -> V.t -> V.t list
val in_degree : S.t HM.t -> V.t -> int
val iter_pred_e :
(V.t * Edge.t * V.t -> unit) -> S.t HM.t -> V.t -> unit
val fold_pred_e :
(V.t * Edge.t * V.t -> 'a -> 'a) -> S.t HM.t -> V.t -> 'a -> 'a
val pred_e : S.t HM.t -> V.t -> (V.t * Edge.t * V.t) list
type vertex = HM.key
val is_directed : bool
val empty : 'a HM.return
val create : ?size:int -> unit -> 'a HM.t
val is_empty : 'a HM.t -> bool
val copy : 'a HM.t -> 'a HM.t
val clear : 'a HM.t -> unit
val nb_vertex : 'a HM.t -> int
val nb_edges : S.t HM.t -> int
val out_degree : S.t HM.t -> HM.key -> int
val mem_vertex : 'a HM.t -> HM.key -> bool
val unsafe_add_vertex : S.t HM.t -> HM.key -> S.t HM.t
val unsafe_add_edge : S.t HM.t -> HM.key -> S.elt -> S.t HM.t
val add_vertex : S.t HM.t -> HM.key -> S.t HM.t
val iter_vertex : (HM.key -> unit) -> 'a HM.t -> unit
val fold_vertex : (HM.key -> 'a -> 'a) -> 'b HM.t -> 'a -> 'a
val add_edge_e : S.t HM.t -> HM.key * Edge.t * V.t -> S.t HM.t
val add_edge : S.t HM.t -> HM.key -> V.t -> S.t HM.t
end
module ConcreteBidirectionalLabeled :
functor
(V : Graph.Sig.COMPARABLE) (Edge : Graph.Sig.ORDERED_TYPE_DFT) ->
sig
module V :
sig
type t = V.t
val compare : t -> t -> int
val hash : t -> int
val equal : t -> t -> bool
type label = t
val label : 'a -> 'a
val create : 'a -> 'a
end
module HM :
sig
type 'a return = 'a PMAP(V).return
type 'a t = 'a PMAP(V).t
type key = V.t
val create : ?size:int -> unit -> 'a t
val create_from : 'a t -> 'a t
val empty : 'a return
val clear : 'a t -> unit
val is_empty : 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val remove : key -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val find_and_raise : key -> 'a t -> string -> 'a
val iter : (key -> 'a -> unit) -> 'a t -> unit
val map : (key -> 'a -> key * 'a) -> 'a t -> 'a t
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val copy : 'a t -> 'a t
end
module VE :
sig type t = V.t * Edge.t val compare : t -> t -> int end
module S :
sig
type elt = VE.t
type t = Set.Make(VE).t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val min_elt : t -> elt
val max_elt : t -> elt
val choose : t -> elt
val split : elt -> t -> t * bool * t
val find : elt -> t -> elt
val of_list : elt list -> t
end
module E :
sig
type vertex = V.t
type label = Edge.t
type t = vertex * label * vertex
val src : 'a * 'b * 'c -> 'a
val dst : 'a * 'b * 'c -> 'c
val label : 'a * 'b * 'c -> 'b
val create : 'a -> 'b -> 'c -> 'a * 'b * 'c
module C :
sig type t = V.t * VE.t val compare : t -> t -> int end
val compare : V.t * Edge.t * V.t -> V.t * Edge.t * V.t -> int
end
type edge = E.t
val mem_edge : ('a * S.t) HM.t -> HM.key -> V.t -> bool
val mem_edge_e : ('a * S.t) HM.t -> HM.key * Edge.t * V.t -> bool
exception Found of edge
val find_edge : ('a * S.t) HM.t -> E.vertex -> V.t -> edge
val find_all_edges :
('a * S.t) HM.t ->
HM.key -> V.t -> (HM.key * Edge.t * V.t) list
val unsafe_remove_edge :
(S.t * S.t) HM.t -> HM.key -> HM.key -> (S.t * S.t) HM.t
val unsafe_remove_edge_e :
(S.t * S.t) HM.t ->
HM.key * Edge.t * HM.key -> (S.t * S.t) HM.t
val remove_edge :
(S.t * S.t) HM.t -> HM.key -> HM.key -> (S.t * S.t) HM.t
val remove_edge_e :
(S.t * S.t) HM.t ->
HM.key * Edge.t * HM.key -> (S.t * S.t) HM.t
val iter_succ :
(V.t -> unit) -> ('a * S.t) HM.t -> HM.key -> unit
val fold_succ :
(V.t -> 'a -> 'a) -> ('b * S.t) HM.t -> HM.key -> 'a -> 'a
val iter_succ_e :
(HM.key * Edge.t * V.t -> unit) ->
('a * S.t) HM.t -> HM.key -> unit
val fold_succ_e :
(HM.key * Edge.t * V.t -> 'a -> 'a) ->
('b * S.t) HM.t -> HM.key -> 'a -> 'a
val succ : ('a * S.t) HM.t -> HM.key -> V.t list
val succ_e :
('a * S.t) HM.t -> HM.key -> (HM.key * Edge.t * V.t) list
val map_vertex :
(HM.key -> HM.key) -> (S.t * S.t) HM.t -> (S.t * S.t) HM.t
module I :
sig
type t = (S.t * S.t) HM.t
module PV :
sig
type t = V.t
val compare : t -> t -> int
val hash : t -> int
val equal : t -> t -> bool
end
module PE = E
val iter_edges :
(HM.key -> V.t -> unit) -> ('a * S.t) HM.t -> unit
val fold_edges :
(HM.key -> V.t -> 'a -> 'a) -> ('b * S.t) HM.t -> 'a -> 'a
val iter_edges_e :
(HM.key * Edge.t * V.t -> unit) -> ('a * S.t) HM.t -> unit
val fold_edges_e :
(HM.key * Edge.t * V.t -> 'a -> 'a) ->
('b * S.t) HM.t -> 'a -> 'a
end
type t = (S.t * S.t) HM.t
module PV = I.PV
module PE = I.PE
val iter_edges :
(HM.key -> V.t -> unit) -> ('a * S.t) HM.t -> unit
val fold_edges :
(HM.key -> V.t -> 'a -> 'a) -> ('b * S.t) HM.t -> 'a -> 'a
val iter_edges_e :
(HM.key * Edge.t * V.t -> unit) -> ('a * S.t) HM.t -> unit
val fold_edges_e :
(HM.key * Edge.t * V.t -> 'a -> 'a) ->
('b * S.t) HM.t -> 'a -> 'a
val iter_pred :
(V.t -> unit) -> (S.t * 'a) HM.t -> HM.key -> unit
val fold_pred :
(V.t -> 'a -> 'a) -> (S.t * 'b) HM.t -> HM.key -> 'a -> 'a
val in_degree : (S.t * 'a) HM.t -> HM.key -> int
val iter_pred_e :
(V.t * Edge.t * HM.key -> unit) ->
(S.t * 'a) HM.t -> HM.key -> unit
val fold_pred_e :
(V.t * Edge.t * HM.key -> 'a -> 'a) ->
(S.t * 'b) HM.t -> HM.key -> 'a -> 'a
val pred : (S.t * 'a) HM.t -> HM.key -> V.t list
val pred_e :
(S.t * 'a) HM.t -> HM.key -> (V.t * Edge.t * HM.key) list
type vertex = HM.key
val is_directed : bool
val empty : 'a HM.return
val create : ?size:int -> unit -> 'a HM.t
val clear : 'a HM.t -> unit
val is_empty : 'a HM.t -> bool
val copy : 'a HM.t -> 'a HM.t
val nb_vertex : 'a HM.t -> int
val nb_edges : ('a * S.t) HM.t -> int
val out_degree : ('a * S.t) HM.t -> HM.key -> int
val mem_vertex : 'a HM.t -> HM.key -> bool
val unsafe_add_vertex :
(S.t * S.t) HM.t -> HM.key -> (S.t * S.t) HM.t
val add_vertex : (S.t * S.t) HM.t -> HM.key -> (S.t * S.t) HM.t
val iter_vertex : (HM.key -> unit) -> 'a HM.t -> unit
val fold_vertex : (HM.key -> 'a -> 'a) -> 'b HM.t -> 'a -> 'a
val unsafe_add_edge_e :
(S.t * S.t) HM.t -> HM.key * Edge.t * V.t -> (S.t * S.t) HM.t
val add_edge_e :
(S.t * S.t) HM.t -> HM.key * Edge.t * V.t -> (S.t * S.t) HM.t
val add_edge :
(S.t * S.t) HM.t -> HM.key -> V.t -> (S.t * S.t) HM.t
end
module Abstract :
functor (V : Graph.Sig.VERTEX) ->
sig
module G :
sig
module V :
sig
type t = V.t
val compare : t -> t -> int
val hash : t -> int
val equal : t -> t -> bool
type label = V.label
val create : label -> t
val label : t -> label
end
module HM :
sig
type 'a return = 'a PMAP(V).return
type 'a t = 'a PMAP(V).t
type key = V.t
val create : ?size:int -> unit -> 'a t
val create_from : 'a t -> 'a t
val empty : 'a return
val clear : 'a t -> unit
val is_empty : 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val remove : key -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val find_and_raise : key -> 'a t -> string -> 'a
val iter : (key -> 'a -> unit) -> 'a t -> unit
val map : (key -> 'a -> key * 'a) -> 'a t -> 'a t
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val copy : 'a t -> 'a t
end
module S :
sig
type elt = V.t
type t = Set.Make(V).t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val min_elt : t -> elt
val max_elt : t -> elt
val choose : t -> elt
val split : elt -> t -> t * bool * t
val find : elt -> t -> elt
val of_list : elt list -> t
end
module E :
sig
type vertex = V.t
type t = V.t * V.t
val compare : t -> t -> int
val src : 'a * 'b -> 'a
val dst : 'a * 'b -> 'b
type label = unit
val label : 'a -> unit
val create : 'a -> unit -> 'b -> 'a * 'b
end
type edge = E.t
val mem_edge : S.t HM.t -> HM.key -> S.elt -> bool
val mem_edge_e : S.t HM.t -> HM.key * S.elt -> bool
val find_edge : S.t HM.t -> HM.key -> S.elt -> HM.key * S.elt
val find_all_edges :
S.t HM.t -> HM.key -> S.elt -> (HM.key * S.elt) list
val unsafe_remove_edge :
S.t HM.t -> HM.key -> S.elt -> S.t HM.t
val unsafe_remove_edge_e :
S.t HM.t -> HM.key * S.elt -> S.t HM.t
val remove_edge : S.t HM.t -> HM.key -> HM.key -> S.t HM.t
val remove_edge_e : S.t HM.t -> HM.key * HM.key -> S.t HM.t
val iter_succ : (S.elt -> unit) -> S.t HM.t -> HM.key -> unit
val fold_succ :
(S.elt -> 'a -> 'a) -> S.t HM.t -> HM.key -> 'a -> 'a
val iter_succ_e :
(HM.key * S.elt -> unit) -> S.t HM.t -> HM.key -> unit
val fold_succ_e :
(HM.key * S.elt -> 'a -> 'a) ->
S.t HM.t -> HM.key -> 'a -> 'a
val succ : S.t HM.t -> HM.key -> S.elt list
val succ_e : S.t HM.t -> HM.key -> (HM.key * S.elt) list
val map_vertex : (HM.key -> HM.key) -> S.t HM.t -> S.t HM.t
module I :
sig
type t = S.t HM.t
module PV :
sig
type t = V.t
val compare : t -> t -> int
val hash : t -> int
val equal : t -> t -> bool
end
module PE = E
val iter_edges :
(HM.key -> S.elt -> unit) -> S.t HM.t -> unit
val fold_edges :
(HM.key -> S.elt -> 'a -> 'a) -> S.t HM.t -> 'a -> 'a
val iter_edges_e :
(HM.key * S.elt -> unit) -> S.t HM.t -> unit
val fold_edges_e :
(HM.key * S.elt -> 'a -> 'a) -> S.t HM.t -> 'a -> 'a
end
type t = S.t HM.t
module PV = I.PV
module PE = I.PE
val iter_edges :
(HM.key -> S.elt -> unit) -> S.t HM.t -> unit
val fold_edges :
(HM.key -> S.elt -> 'a -> 'a) -> S.t HM.t -> 'a -> 'a
val iter_edges_e :
(HM.key * S.elt -> unit) -> S.t HM.t -> unit
val fold_edges_e :
(HM.key * S.elt -> 'a -> 'a) -> S.t HM.t -> 'a -> 'a
val iter_pred : (V.t -> unit) -> S.t HM.t -> V.t -> unit
val fold_pred :
(V.t -> 'a -> 'a) -> S.t HM.t -> V.t -> 'a -> 'a
val pred : S.t HM.t -> V.t -> V.t list
val in_degree : S.t HM.t -> V.t -> int
val iter_pred_e :
(V.t * V.t -> unit) -> S.t HM.t -> V.t -> unit
val fold_pred_e :
(V.t * V.t -> 'a -> 'a) -> S.t HM.t -> V.t -> 'a -> 'a
val pred_e : S.t HM.t -> V.t -> (V.t * V.t) list
type vertex = HM.key
val is_directed : bool
val empty : 'a HM.return
val create : ?size:int -> unit -> 'a HM.t
val is_empty : 'a HM.t -> bool
val copy : 'a HM.t -> 'a HM.t
val clear : 'a HM.t -> unit
val nb_vertex : 'a HM.t -> int
val nb_edges : S.t HM.t -> int
val out_degree : S.t HM.t -> HM.key -> int
val mem_vertex : 'a HM.t -> HM.key -> bool
val unsafe_add_vertex : S.t HM.t -> HM.key -> S.t HM.t
val unsafe_add_edge : S.t HM.t -> HM.key -> S.elt -> S.t HM.t
val add_vertex : S.t HM.t -> HM.key -> S.t HM.t
val iter_vertex : (HM.key -> unit) -> 'a HM.t -> unit
val fold_vertex : (HM.key -> 'a -> 'a) -> 'b HM.t -> 'a -> 'a
end
module I :
sig
type t =
Graph.Blocks.Make_Abstract(G).I.t = {
edges : G.t;
mutable size : int;
}
type vertex = G.vertex
type edge = G.edge
module PV :
sig
type t = G.HM.key
val compare : t -> t -> int
val hash : t -> int
val equal : t -> t -> bool
type label = G.V.label
val create : label -> t
val label : t -> label
end
module PE :
sig
type t = G.E.t
val compare : t -> t -> int
type vertex = G.vertex
val src : t -> vertex
val dst : t -> vertex
type label = G.E.label
val create : vertex -> label -> vertex -> t
val label : t -> label
end
val iter_edges : (G.vertex -> G.vertex -> unit) -> t -> unit
val fold_edges :
(G.vertex -> G.vertex -> 'a -> 'a) -> t -> 'a -> 'a
val iter_edges_e : (G.edge -> unit) -> t -> unit
val fold_edges_e : (G.edge -> 'a -> 'a) -> t -> 'a -> 'a
val mem_vertex : G.vertex -> t -> bool
val create : ?size:int -> unit -> t
val clear : t -> unit
end
type t = I.t = { edges : G.t; mutable size : int; }
type vertex = G.vertex
type edge = G.edge
module PV = I.PV
module PE = I.PE
val iter_edges : (G.vertex -> G.vertex -> unit) -> t -> unit
val fold_edges :
(G.vertex -> G.vertex -> 'a -> 'a) -> t -> 'a -> 'a
val iter_edges_e : (G.edge -> unit) -> t -> unit
val fold_edges_e : (G.edge -> 'a -> 'a) -> t -> 'a -> 'a
val create : ?size:int -> unit -> t
val clear : t -> unit
val iter_pred : (I.PV.t -> unit) -> I.t -> I.PV.t -> unit
val fold_pred : (I.PV.t -> 'a -> 'a) -> I.t -> I.PV.t -> 'a -> 'a
val pred : I.t -> I.PV.t -> I.PV.t list
val iter_pred_e : (I.PE.t -> unit) -> I.t -> I.PV.t -> unit
val fold_pred_e :
(I.PE.t -> 'a -> 'a) -> I.t -> I.PV.t -> 'a -> 'a
val pred_e : I.t -> I.PV.t -> I.PE.t list
val is_empty : t -> bool
val nb_vertex : t -> int
module V :
sig
type t = G.HM.key
val compare : t -> t -> int
val hash : t -> int
val equal : t -> t -> bool
type label = G.V.label
val create : label -> t
val label : t -> label
end
module E :
sig
type t = G.E.t
val compare : t -> t -> int
type vertex = G.vertex
val src : t -> vertex
val dst : t -> vertex
type label = G.E.label
val create : vertex -> label -> vertex -> t
val label : t -> label
end
module HM :
sig
type 'a return = 'a G.HM.return
type 'a t = 'a G.HM.t
type key = G.HM.key
val create : ?size:int -> unit -> 'a t
val create_from : 'a t -> 'a t
val empty : 'a return
val clear : 'a t -> unit
val is_empty : 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val remove : key -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val find_and_raise : key -> 'a t -> string -> 'a
val iter : (key -> 'a -> unit) -> 'a t -> unit
val map : (key -> 'a -> key * 'a) -> 'a t -> 'a t
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val copy : 'a t -> 'a t
end
module S :
sig
type elt = G.S.elt
type t = G.S.t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val min_elt : t -> elt
val max_elt : t -> elt
val choose : t -> elt
val split : elt -> t -> t * bool * t
val find : elt -> t -> elt
val of_list : elt list -> t
end
val unsafe_add_edge : G.t -> G.vertex -> G.S.elt -> G.t
val unsafe_remove_edge : G.t -> G.vertex -> G.vertex -> G.t
val unsafe_remove_edge_e : G.t -> G.edge -> G.t
val is_directed : bool
val remove_edge : t -> G.vertex -> G.vertex -> G.t
val remove_edge_e : t -> G.edge -> G.t
val out_degree : t -> G.vertex -> int
val in_degree : t -> G.vertex -> int
val nb_edges : t -> int
val succ : t -> G.vertex -> G.vertex list
val mem_vertex : t -> G.vertex -> bool
val mem_edge : t -> G.vertex -> G.vertex -> bool
val mem_edge_e : t -> G.edge -> bool
val find_edge : t -> G.vertex -> G.vertex -> G.edge
val find_all_edges : t -> G.vertex -> G.vertex -> G.edge list
val iter_vertex : (G.vertex -> unit) -> t -> unit
val fold_vertex : (G.vertex -> 'a -> 'a) -> t -> 'a -> 'a
val iter_succ : (G.vertex -> unit) -> t -> G.vertex -> unit
val fold_succ :
(G.vertex -> 'a -> 'a) -> t -> G.vertex -> 'a -> 'a
val succ_e : t -> G.vertex -> G.edge list
val iter_succ_e : (G.edge -> unit) -> t -> G.vertex -> unit
val fold_succ_e :
(G.edge -> 'a -> 'a) -> t -> G.vertex -> 'a -> 'a
val map_vertex : (G.vertex -> G.vertex) -> t -> t
val copy : t -> t
end
module AbstractLabeled :
functor (V : Graph.Sig.VERTEX) (E : Graph.Sig.ORDERED_TYPE_DFT) ->
sig
module G :
sig
module V :
sig
type t = V.t
val compare : t -> t -> int
val hash : t -> int
val equal : t -> t -> bool
type label = V.label
val create : label -> t
val label : t -> label
end
module HM :
sig
type 'a return = 'a PMAP(V).return
type 'a t = 'a PMAP(V).t
type key = V.t
val create : ?size:int -> unit -> 'a t
val create_from : 'a t -> 'a t
val empty : 'a return
val clear : 'a t -> unit
val is_empty : 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val remove : key -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val find_and_raise : key -> 'a t -> string -> 'a
val iter : (key -> 'a -> unit) -> 'a t -> unit
val map : (key -> 'a -> key * 'a) -> 'a t -> 'a t
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val copy : 'a t -> 'a t
end
module VE :
sig type t = V.t * E.t val compare : t -> t -> int end
module S :
sig
type elt = VE.t
type t = Set.Make(VE).t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val min_elt : t -> elt
val max_elt : t -> elt
val choose : t -> elt
val split : elt -> t -> t * bool * t
val find : elt -> t -> elt
val of_list : elt list -> t
end
module E :
sig
type vertex = V.t
type label = E.t
type t = vertex * label * vertex
val src : 'a * 'b * 'c -> 'a
val dst : 'a * 'b * 'c -> 'c
val label : 'a * 'b * 'c -> 'b
val create : 'a -> 'b -> 'c -> 'a * 'b * 'c
module C :
sig type t = V.t * VE.t val compare : t -> t -> int end
val compare : V.t * E.t * V.t -> V.t * E.t * V.t -> int
end
type edge = E.t
val mem_edge : S.t HM.t -> HM.key -> V.t -> bool
val mem_edge_e : S.t HM.t -> HM.key * E.t * V.t -> bool
exception Found of edge
val find_edge : S.t HM.t -> E.vertex -> V.t -> edge
val find_all_edges :
S.t HM.t -> HM.key -> V.t -> (HM.key * E.t * V.t) list
val unsafe_remove_edge :
S.t HM.t -> HM.key -> V.t -> S.t HM.t
val unsafe_remove_edge_e :
S.t HM.t -> HM.key * E.t * V.t -> S.t HM.t
val remove_edge : S.t HM.t -> HM.key -> HM.key -> S.t HM.t
val remove_edge_e :
S.t HM.t -> HM.key * E.t * HM.key -> S.t HM.t
val iter_succ : (V.t -> unit) -> S.t HM.t -> HM.key -> unit
val fold_succ :
(V.t -> 'a -> 'a) -> S.t HM.t -> HM.key -> 'a -> 'a
val iter_succ_e :
(HM.key * E.t * V.t -> unit) -> S.t HM.t -> HM.key -> unit
val fold_succ_e :
(HM.key * E.t * V.t -> 'a -> 'a) ->
S.t HM.t -> HM.key -> 'a -> 'a
val succ : S.t HM.t -> HM.key -> V.t list
val succ_e : S.t HM.t -> HM.key -> (HM.key * E.t * V.t) list
val map_vertex : (HM.key -> HM.key) -> S.t HM.t -> S.t HM.t
module I :
sig
type t = S.t HM.t
module PV :
sig
type t = V.t
val compare : t -> t -> int
val hash : t -> int
val equal : t -> t -> bool
end
module PE = E
val iter_edges :
(HM.key -> V.t -> unit) -> S.t HM.t -> unit
val fold_edges :
(HM.key -> V.t -> 'a -> 'a) -> S.t HM.t -> 'a -> 'a
val iter_edges_e :
(HM.key * E.t * V.t -> unit) -> S.t HM.t -> unit
val fold_edges_e :
(HM.key * E.t * V.t -> 'a -> 'a) ->
S.t HM.t -> 'a -> 'a
end
type t = S.t HM.t
module PV = I.PV
module PE = I.PE
val iter_edges : (HM.key -> V.t -> unit) -> S.t HM.t -> unit
val fold_edges :
(HM.key -> V.t -> 'a -> 'a) -> S.t HM.t -> 'a -> 'a
val iter_edges_e :
(HM.key * E.t * V.t -> unit) -> S.t HM.t -> unit
val fold_edges_e :
(HM.key * E.t * V.t -> 'a -> 'a) -> S.t HM.t -> 'a -> 'a
val iter_pred : (V.t -> unit) -> S.t HM.t -> V.t -> unit
val fold_pred :
(V.t -> 'a -> 'a) -> S.t HM.t -> V.t -> 'a -> 'a
val pred : S.t HM.t -> V.t -> V.t list
val in_degree : S.t HM.t -> V.t -> int
val iter_pred_e :
(V.t * E.t * V.t -> unit) -> S.t HM.t -> V.t -> unit
val fold_pred_e :
(V.t * E.t * V.t -> 'a -> 'a) ->
S.t HM.t -> V.t -> 'a -> 'a
val pred_e : S.t HM.t -> V.t -> (V.t * E.t * V.t) list
type vertex = HM.key
val is_directed : bool
val empty : 'a HM.return
val create : ?size:int -> unit -> 'a HM.t
val is_empty : 'a HM.t -> bool
val copy : 'a HM.t -> 'a HM.t
val clear : 'a HM.t -> unit
val nb_vertex : 'a HM.t -> int
val nb_edges : S.t HM.t -> int
val out_degree : S.t HM.t -> HM.key -> int
val mem_vertex : 'a HM.t -> HM.key -> bool
val unsafe_add_vertex : S.t HM.t -> HM.key -> S.t HM.t
val unsafe_add_edge : S.t HM.t -> HM.key -> S.elt -> S.t HM.t
val add_vertex : S.t HM.t -> HM.key -> S.t HM.t
val iter_vertex : (HM.key -> unit) -> 'a HM.t -> unit
val fold_vertex : (HM.key -> 'a -> 'a) -> 'b HM.t -> 'a -> 'a
end
module I :
sig
type t =
Graph.Blocks.Make_Abstract(G).I.t = {
edges : G.t;
mutable size : int;
}
type vertex = G.vertex
type edge = G.edge
module PV :
sig
type t = G.HM.key
val compare : t -> t -> int
val hash : t -> int
val equal : t -> t -> bool
type label = G.V.label
val create : label -> t
val label : t -> label
end
module PE :
sig
type t = G.E.t
val compare : t -> t -> int
type vertex = G.vertex
val src : t -> vertex
val dst : t -> vertex
type label = G.E.label
val create : vertex -> label -> vertex -> t
val label : t -> label
end
val iter_edges : (G.vertex -> G.vertex -> unit) -> t -> unit
val fold_edges :
(G.vertex -> G.vertex -> 'a -> 'a) -> t -> 'a -> 'a
val iter_edges_e : (G.edge -> unit) -> t -> unit
val fold_edges_e : (G.edge -> 'a -> 'a) -> t -> 'a -> 'a
val mem_vertex : G.vertex -> t -> bool
val create : ?size:int -> unit -> t
val clear : t -> unit
end
type t = I.t = { edges : G.t; mutable size : int; }
type vertex = G.vertex
type edge = G.edge
module PV = I.PV
module PE = I.PE
val iter_edges : (G.vertex -> G.vertex -> unit) -> t -> unit
val fold_edges :
(G.vertex -> G.vertex -> 'a -> 'a) -> t -> 'a -> 'a
val iter_edges_e : (G.edge -> unit) -> t -> unit
val fold_edges_e : (G.edge -> 'a -> 'a) -> t -> 'a -> 'a
val create : ?size:int -> unit -> t
val clear : t -> unit
val iter_pred : (I.PV.t -> unit) -> I.t -> I.PV.t -> unit
val fold_pred : (I.PV.t -> 'a -> 'a) -> I.t -> I.PV.t -> 'a -> 'a
val pred : I.t -> I.PV.t -> I.PV.t list
val iter_pred_e : (I.PE.t -> unit) -> I.t -> I.PV.t -> unit
val fold_pred_e :
(I.PE.t -> 'a -> 'a) -> I.t -> I.PV.t -> 'a -> 'a
val pred_e : I.t -> I.PV.t -> I.PE.t list
val is_empty : t -> bool
val nb_vertex : t -> int
module V :
sig
type t = G.HM.key
val compare : t -> t -> int
val hash : t -> int
val equal : t -> t -> bool
type label = G.V.label
val create : label -> t
val label : t -> label
end
module E :
sig
type t = G.E.t
val compare : t -> t -> int
type vertex = G.vertex
val src : t -> vertex
val dst : t -> vertex
type label = G.E.label
val create : vertex -> label -> vertex -> t
val label : t -> label
end
module HM :
sig
type 'a return = 'a G.HM.return
type 'a t = 'a G.HM.t
type key = G.HM.key
val create : ?size:int -> unit -> 'a t
val create_from : 'a t -> 'a t
val empty : 'a return
val clear : 'a t -> unit
val is_empty : 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val remove : key -> 'a t -> 'a t
val mem : key -> 'a t -> bool
val find : key -> 'a t -> 'a
val find_and_raise : key -> 'a t -> string -> 'a
val iter : (key -> 'a -> unit) -> 'a t -> unit
val map : (key -> 'a -> key * 'a) -> 'a t -> 'a t
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val copy : 'a t -> 'a t
end
module S :
sig
type elt = G.S.elt
type t = G.S.t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val min_elt : t -> elt
val max_elt : t -> elt
val choose : t -> elt
val split : elt -> t -> t * bool * t
val find : elt -> t -> elt
val of_list : elt list -> t
end
val unsafe_add_edge : G.t -> G.vertex -> G.S.elt -> G.t
val unsafe_remove_edge : G.t -> G.vertex -> G.vertex -> G.t
val unsafe_remove_edge_e : G.t -> G.edge -> G.t
val is_directed : bool
val remove_edge : t -> G.vertex -> G.vertex -> G.t
val remove_edge_e : t -> G.edge -> G.t
val out_degree : t -> G.vertex -> int
val in_degree : t -> G.vertex -> int
val nb_edges : t -> int
val succ : t -> G.vertex -> G.vertex list
val mem_vertex : t -> G.vertex -> bool
val mem_edge : t -> G.vertex -> G.vertex -> bool
val mem_edge_e : t -> G.edge -> bool
val find_edge : t -> G.vertex -> G.vertex -> G.edge
val find_all_edges : t -> G.vertex -> G.vertex -> G.edge list
val iter_vertex : (G.vertex -> unit) -> t -> unit
val fold_vertex : (G.vertex -> 'a -> 'a) -> t -> 'a -> 'a
val iter_succ : (G.vertex -> unit) -> t -> G.vertex -> unit
val fold_succ :
(G.vertex -> 'a -> 'a) -> t -> G.vertex -> 'a -> 'a
val succ_e : t -> G.vertex -> G.edge list
val iter_succ_e : (G.edge -> unit) -> t -> G.vertex -> unit
val fold_succ_e :
(G.edge -> 'a -> 'a) -> t -> G.vertex -> 'a -> 'a
val map_vertex : (G.vertex -> G.vertex) -> t -> t
val copy : t -> t
end
end
end