Struct ConGraph 

pub struct ConGraph { /* private fields */ }

A connectivity only hypergraph object. Essentially a wrapper around HGraph with simpler add nodes/edges and simpler serialization to and from disk.

Implementations

impl ConGraph

pub fn new() -> ConGraph

pub fn add_node(&mut self) -> u32

Panics if new node cannot be added.

pub fn add_nodes(&mut self, num_nodes: usize) -> Vec<u32>

Adds num_nodes nodes to the graph, returning a vector containing the nodes created. panics if it runs out of nodes to allocate.

pub fn remove_node(&mut self, node: u32)

Removes the node and any empty edges if the provided node is the last on in the edge. Singleton edges are allowed. For example, if you remove 2 from the edge {1, 2} the graph will retain the edge {1} so that way further nodes can be added back to the edge. If 1 is then removed the empty edge will be deleted.

pub fn remove_nodes(&mut self, nodes: Vec<u32>)

Removes a collection of nodes and any resulting empty edges.

pub fn nodes(&self) -> Vec<u32>

All node IDs that are currently in use.

pub fn add_edge(&mut self, nodes: impl AsRef<[u32]>) -> u64

Creates an undirected edge among the given nodes with duplicate nodes removed. Duplicate edges are not allowed.

panics

• If not all nodes are present in the hypergraph
• If you run out of possible id’s usable with the EdgeID storage type

pub fn remove_edge(&mut self, edge_id: u64)

pub fn find_id<E>(&self, nodes: E) -> Option<u64>

where E: AsRef<[u32]>,

In case you forget it :)

pub fn edges(&self) -> Vec<u64>

All edge IDs currently in use within the hypergraph.

pub fn cut(&self, cut_nodes: impl AsRef<[u32]>) -> usize

Computes the number of edges that have one vertex in the provided cut_nodes and one in the remaining set. For example, an edge with only support on the cut_nodes would not count. Neither would an edge without any nodes in cut_nodes. The type ToSet is any collection that can be converted to a sparse set representation.

pub fn to_disk(&self, path: &Path)

Saves the disk in the same format as the graph is displayed. panics if the path is incorrect or the file cannot be written.

pub fn from_file(path: &Path) -> Option<Self>

Trait Implementations

impl Clone for ConGraph

fn clone(&self) -> ConGraph

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ConGraph

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

Formats the value using the given formatter.

impl Default for ConGraph

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ConGraph

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ConGraph

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

Formats the value using the given formatter.

impl FromStr for ConGraph

type Err = String

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl HyperGraph for ConGraph

type NodeID = u32

type EdgeID = u64

fn query_edge(&self, edge: &Self::EdgeID) -> Option<Vec<Self::NodeID>>

Retrieve the nodes associated with the given EdgeID

fn containing_edges_of_nodes( &self, nodes: impl AsRef<[Self::NodeID]>, ) -> Vec<Self::EdgeID>

Find all edge ids such that the given nodes are a subset or equal to the edge.

fn containing_edges(&self, edge: &Self::EdgeID) -> Vec<Self::EdgeID>

Find all edges such that the nodes of a given edge are a strict subset of.

fn link(&self, edge: &Self::EdgeID) -> Vec<(Self::EdgeID, Vec<Self::NodeID>)>

Computes the link of the provided nodes by pairs of edge ids and what the link of the provided nodes are within the associated id. Ex: If the graph has edges {1, 2, 3}, {2, 3, 4}, {3, 4, 5}, and {2, 3} with ids 1,2, 3, and 4 respectively, then the link of edge_id = 4 would be vec![(1, [1]), (2, [2])].

fn link_of_nodes( &self, nodes: impl AsRef<[Self::NodeID]>, ) -> Vec<(Self::EdgeID, Vec<Self::NodeID>)>

Computes the link of the provided nodes by pairs of edge ids and what the link of the provided nodes are within the associated id. Ex: If the graph has edges {1, 2, 3}, {2, 3, 4}, and {3, 4, 5}, with ids 1,2, and 3 respectively, then the link of [3] would be vec![(1, [1, 2]), (2, [2, 4]), (3, [4, 5])].

fn maximal_edges(&self, edge_id: &Self::EdgeID) -> Vec<Self::EdgeID>

Finds the edges containing the edge associated with the provided ID that are not contained in any other edge. If the edge of the provided ID is maximal, it is not included in its return. Ex: {1, 2, 3}, {1,2, 3, 4}, {1, 2, 3, 4, 5} and you give the id of {1, 2, 3}, then the id of {1, 2, 3, 4, 5} will be returned.

fn maximal_edges_of_nodes( &self, nodes: impl AsRef<[Self::NodeID]>, ) -> Vec<Self::EdgeID>

Finds all edges containing provided nodes that are not contained in any other edge. If the provided nodes are a maximal edge, then that edges ID is returned.

fn edges_of_size(&self, card: usize) -> Vec<Self::EdgeID>

Warning: Has to filter all edges so takes Theta(|E|) time.

fn skeleton(&self, cardinality: usize) -> Vec<Self::EdgeID>

Returns the edges that have cardinality less than or equal to the input cardinality. Takes Theta(|E|) time.

fn boundary_up(&self, edge_id: &Self::EdgeID) -> Vec<Vec<Self::NodeID>>

Returns edges that constitute the boundary up operator, which adds a single node to the provided edge. Example: If a graph has edges {1, 2}, {1,2, 3}, {1,2,4}, and {1, 2, 3, 4} with ids 1, 2, 3, and 4 respectively, then boundary_up(1) would give vec![2, 3].

fn boundary_down(&self, edge_id: &Self::EdgeID) -> Vec<Vec<Self::NodeID>>

Finds the edges that are the same as the provided edge_id but have a single node removed. For example, {1, 2} would be in boundary_down of {1, 2, 3} if both edges were present. Returns an empty vec if the edge_id is incorrect.

fn boundary_up_of_nodes( &self, nodes: impl AsRef<[Self::NodeID]>, ) -> Vec<Vec<Self::NodeID>>

Finds all edges which contain one more node than the provided node.

fn boundary_down_of_nodes( &self, nodes: impl AsRef<[Self::NodeID]>, ) -> Vec<Vec<Self::NodeID>>

Finds all edges that have one node removed from the provided nodes.

impl Serialize for ConGraph

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.