Module Digraph.ConcreteBidirectionalLabeled

Parameters

Signature

module V : sig ... end
module HM : sig ... end
module VE : sig ... end
module S : sig ... end
module E : sig ... 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 ... end
type t = (S.t * S.t) HM.t
module PV = I.PV
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
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