Struct CycleBasisResult 

pub struct CycleBasisResult {
    pub cycles: Vec<Vec<i64>>,
    pub scc_decomposition: SccResult,
    pub cycles_skipped: usize,
    pub bounds_applied: CycleBasisBounds,
}

Result of minimal cycle basis computation.

Contains a set of cycles that form a basis for all cycles in the graph. Every cycle in the graph can be expressed as a combination of basis cycles.

Example

use sqlitegraph::{algo::cycle_basis, SqliteGraph};

let graph = SqliteGraph::open_in_memory()?;
// ... add nodes and edges ...

let result = cycle_basis(&graph)?;

println!("Found {} basis cycles", result.cycles.len());
println!("Nodes in cycles: {:?}", result.cyclic_nodes());

for node in result.cyclic_nodes() {
    if result.is_cyclic(node) {
        println!("Node {} is in a cycle: {}", node, result.explain_cycle(node));
    }
}

Fields

cycles: Vec<Vec<i64>>

The cycle basis: list of cycles.

Each cycle is a vector of node IDs forming a closed loop. Cycles are canonicalized (minimum node ID is first) for consistent comparison and deduplication.

scc_decomposition: SccResult

SCC decomposition used for cycle extraction.

Useful for understanding which cycles belong to which SCC. Non-trivial SCCs (len() > 1) contain cycles.

cycles_skipped: usize

Number of cycles skipped due to bounds.

Incremented when:

• max_cycles limit is reached
• max_cycle_length filters a cycle
• max_per_scc limit is reached for an SCC

bounds_applied: CycleBasisBounds

Bounds applied during computation.

Records what limits were used, useful for understanding if the result is complete or partial.

Implementations

impl CycleBasisResult

pub fn cyclic_nodes(&self) -> AHashSet<i64>

Returns all nodes involved in any cycle.

This is the union of all nodes in all basis cycles. Useful for identifying “problematic” nodes that need cycle resolution.

Example

let cyclic = result.cyclic_nodes();
// cyclic contains: {1, 2, 3, 4, 5}

pub fn is_cyclic(&self, node: i64) -> bool

Checks if a node is part of any cycle.

Returns true if the node appears in any basis cycle. This is a fast check compared to cycles_containing.

Example

assert!(result.is_cyclic(1));  // In cycle [1, 2, 3]
assert!(!result.is_cyclic(99)); // Not in any cycle

pub fn cycles_containing(&self, node: i64) -> Vec<&[i64]>

Returns cycles that contain a specific node.

Returns references to the cycles (as slices) that include the given node. Useful for understanding all cycles a node participates in.

Example

let cycles = result.cycles_containing(1);
assert_eq!(cycles.len(), 2);  // Node 1 is in 2 cycles

pub fn explain_cycle(&self, node: i64) -> String

Explains why a node is cyclic.

Returns a human-readable explanation of the cycles involving the given node. If the node is not cyclic, returns a message saying so.

Example

let explanation = result.explain_cycle(1);
println!("{}", explanation);
// Output:
// Node 1 is in 2 cycle(s):
//   1. [1, 2, 3]
//   2. [1, 4, 5]

pub fn cyclic_scc_count(&self) -> usize

Returns the number of non-trivial SCCs (those containing cycles).

pub fn has_cycles(&self) -> bool

Returns true if the graph has any cycles.

Trait Implementations

impl Clone for CycleBasisResult

fn clone(&self) -> CycleBasisResult

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CycleBasisResult

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

Formats the value using the given formatter.