Struct modular_decomposition::MDTree

pub struct MDTree { /* private fields */ }

A modular decomposition tree. The tree contains at least one node.

Implementations

impl MDTree

pub fn node_count(&self) -> usize

Return the number of nodes in the modular decomposition tree.

pub fn root(&self) -> ModuleIndex

Return the root node index.

pub fn module_kind(&self, module: ModuleIndex) -> Option<&ModuleKind>

Access the ModuleKind of a module.

If the module does not exist, return None.

pub fn module_kinds(&self) -> impl Iterator<Item = &ModuleKind>

Return an iterator yielding references to ModuleKinds for all nodes.

pub fn children( &self, module: ModuleIndex ) -> impl Iterator<Item = ModuleIndex> + '_

Return an iterator for the children of a node.

pub fn into_digraph(self) -> DiGraph<ModuleKind, ()>

Convert to DiGraph.

Examples found in repository

examples/adj_vector_graph.rs (line 74)

fn main() {
    let graph = Graph::from_edges([(0, 1), (1, 2), (2, 3)]);
    let tree = modular_decomposition(&graph).map(|tree| tree.into_digraph()).unwrap_or_default();
    println!("{:?}", Dot::with_config(&tree, &[EdgeNoLabel]));

    let mut factorizing_permutation = Vec::new();
    let root = tree.externals(Incoming).next().unwrap();
    let mut dfs = Dfs::new(&tree, root);
    while let Some(node) = dfs.next(&tree) {
        if let ModuleKind::Node(u) = tree[node] {
            factorizing_permutation.push(u);
        }
    }
    let factorizing_permutation: Vec<_> = factorizing_permutation.iter().map(|u| u.index()).collect();
    println!("{:?}", factorizing_permutation);
}

Trait Implementations

impl Clone for MDTree

fn clone(&self) -> MDTree

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for MDTree

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

Formats the value using the given formatter.