Struct hypergraph::core::Hypergraph

pub struct Hypergraph<V, HE> {
    pub vertices: IndexMap<V, IndexSet<HyperedgeVertices>>,
    pub hyperedges: IndexMap<HyperedgeVertices, IndexSet<HE>>,
}

A directed hypergraph composed of generic vertices and hyperedges.

Fields

vertices: IndexMap<V, IndexSet<HyperedgeVertices>>

Vertices are stored as an IndexMap whose keys are the weights and values are an IndexSet containing the hyperedges which are including the current vertex.

hyperedges: IndexMap<HyperedgeVertices, IndexSet<HE>>

Hyperedges are stored as an IndexMap whose keys are a vector of vertices indexes and values are an IndexSet of weights. Having an IndexSet of weights allows having two or more hyperedges containing the same set of vertices (non-simple hypergraph).

Implementations

impl<V, HE> Hypergraph<V, HE> where
    V: SharedTrait,
    HE: SharedTrait, 

pub fn add_hyperedge(
    &mut self,
    vertices: &[usize],
    weight: HE
) -> Option<WeightedHyperedgeIndex>

Adds a hyperedge as an array of vertices indexes and a custom weight in the hypergraph. Returns the weighted index of the hyperedge.

pub fn count_hyperedges(&self) -> usize

Returns the number of hyperedges in the hypergraph.

pub fn get_hyperedges_connections(
    &self,
    from: VertexIndex,
    to: VertexIndex
) -> Vec<VertexIndex>

Gets the list of all hyperedges containing a matching connection from one vertex to another.

pub fn get_hyperedge_vertices(
    &self,
    index: HyperedgeIndex
) -> Option<HyperedgeVertices>

Gets the hyperedge’s vertices.

pub fn get_hyperedge_weight(
    &self,
    [hyperedge_index, weight_index]: WeightedHyperedgeIndex
) -> Option<&HE>

Gets the weight of a hyperedge from its weighted index.

pub fn get_hyperedges_intersections(
    &self,
    hyperedges: &[HyperedgeIndex]
) -> HyperedgeVertices

Gets the intersections of a set of hyperedges as a vector of vertices.

pub fn remove_hyperedge(
    &mut self,
    [hyperedge_index, weight_index]: WeightedHyperedgeIndex
) -> bool

Removes a hyperedge based on its index. IndexMap doesn’t allow holes by design, see: https://github.com/bluss/indexmap/issues/90#issuecomment-455381877 As a consequence, we have two options. Either we use shift_remove and it will result in an expensive regeneration of all the indexes in the map or we use swap_remove and deal with the fact that the last element will be swapped in place of the removed one and will thus get a new index. We use the latter solution for performance reasons.

pub fn update_hyperedge_weight(
    &mut self,
    [hyperedge_index, weight_index]: WeightedHyperedgeIndex,
    weight: HE
) -> bool

Updates the weight of a hyperedge based on its weighted index.

pub fn update_hyperedge_vertices(
    &mut self,
    hyperedge_index: usize,
    vertices: &[usize]
) -> bool

Updates the vertices of a hyperedge based on its index.

impl<V, HE> Hypergraph<V, HE> where
    V: SharedTrait,
    HE: SharedTrait, 

pub fn add_vertex(&mut self, weight: V) -> VertexIndex

Adds a vertex as a custom weight in the hypergraph. Returns the index of the vertex.

pub fn count_vertices(&self) -> usize

Returns the number of vertices in the hypergraph.

pub fn get_dijkstra_connections(
    &self,
    from: VertexIndex,
    to: VertexIndex
) -> Option<Vec<VertexIndex>>

Gets a list of the shortest path of vertices between two vertices. The implementation of the algorithm is based on https://doc.rust-lang.org/std/collections/binary_heap/#examples

pub fn get_vertex_connections(&self, from: VertexIndex) -> Vec<VertexIndex>

Gets the list of all vertices connected to a given vertex.

pub fn get_vertex_hyperedges(
    &self,
    index: VertexIndex
) -> Option<Vec<HyperedgeVertices>>

Gets the hyperedges as vectors of vertices of a vertex from its index.

pub fn get_vertex_weight(&self, index: VertexIndex) -> Option<&V>

Gets the weight of a vertex from its index.

pub fn remove_vertex(&mut self, index: VertexIndex) -> bool

Removes a vertex based on its index. IndexMap doesn’t allow holes by design, see: https://github.com/bluss/indexmap/issues/90#issuecomment-455381877 As a consequence, we have two options. Either we use shift_remove and it will result in an expensive regeneration of all the indexes in the map or we use swap_remove and deal with the fact that the last element will be swapped in place of the removed one and will thus get a new index. We use the latter solution for performance reasons.

pub fn update_vertex_weight(&mut self, index: VertexIndex, weight: V) -> bool

Updates the weight of a vertex based on its index.

impl<V, HE> Hypergraph<V, HE> where
    V: SharedTrait,
    HE: SharedTrait, 

Hypergraph implementations.

pub fn new() -> Self

Creates a new hypergraph with no allocation.

pub fn with_capacity(vertices: usize, hyperedges: usize) -> Self

Creates a new hypergraph with the specified capacity.

pub fn render_to_graphviz_dot(&self)

Renders the hypergraph to Graphviz dot format. Due to Graphviz dot inability to render hypergraphs out of the box, unaries are rendered as vertex peripheries which can’t be labelled.

Trait Implementations

impl<V: Eq + Hash + Debug, HE: Debug> Debug for Hypergraph<V, HE>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, V, HE> Default for Hypergraph<V, HE> where
    V: SharedTrait + ExtendedDebug<'a>,
    HE: SharedTrait + ExtendedDebug<'a>, 

fn default() -> Self

Returns the “default value” for a type.