Struct GraphMetrics 

pub struct GraphMetrics { /* private fields */ }

Statistical metrics for a dependency graph.

Examples

use ascii_dag::layout::generic::metrics::GraphMetrics;

let get_deps = |&id: &usize| match id {
    1 => vec![],
    2 => vec![1],
    3 => vec![1, 2],
    _ => vec![],
};

let items = [1, 2, 3];
let metrics = GraphMetrics::compute(&items, get_deps);

println!("Nodes: {}", metrics.node_count());
println!("Max depth: {}", metrics.max_depth());
println!("Avg dependencies: {:.2}", metrics.avg_dependencies());

Implementations

impl GraphMetrics

pub fn compute<Id, F>(items: &[Id], get_dependencies: F) -> Self

where Id: Clone + Eq + Hash, F: Fn(&Id) -> Vec<Id> + Clone,

Compute metrics for a graph.

Examples

use ascii_dag::layout::generic::metrics::GraphMetrics;

let get_deps = |&id: &usize| match id {
    1 => vec![],
    2 => vec![1],
    3 => vec![2],
    _ => vec![],
};

let items = [1, 2, 3];
let metrics = GraphMetrics::compute(&items, get_deps);
assert_eq!(metrics.node_count(), 3);

Examples found in repository

examples/dependency_analysis.rs (line 176)

fn example_metrics_dashboard() {
    println!("3. Dependency Graph Metrics");
    println!("   Statistical analysis of the dependency structure\n");

    // Build system example
    let get_deps = |file: &&str| match *file {
        "app.exe" => vec!["main.o", "utils.o", "io.o"],
        "main.o" => vec!["main.c", "types.h"],
        "utils.o" => vec!["utils.c", "types.h"],
        "io.o" => vec!["io.c", "types.h"],
        "main.c" => vec![],
        "utils.c" => vec![],
        "io.c" => vec![],
        "types.h" => vec![],
        _ => vec![],
    };

    let files = [
        "app.exe", "main.o", "utils.o", "io.o", "main.c", "utils.c", "io.c", "types.h",
    ];

    let metrics = GraphMetrics::compute(&files, get_deps);

    println!("   📈 Graph Statistics:");
    println!("      Total files: {}", metrics.node_count());
    println!("      Total dependencies: {}", metrics.edge_count());
    println!("      Root files (sources): {}", metrics.root_count());
    println!("      Leaf files (outputs): {}", metrics.leaf_count());
    println!("      Max depth: {}", metrics.max_depth());
    println!("      Max impact: {} files", metrics.max_descendants());
    println!("      Avg dependencies: {:.2}", metrics.avg_dependencies());
    println!("      Density: {:.2}%", metrics.density() * 100.0);
    println!();

    println!("   🔍 Graph Properties:");
    println!("      Is tree: {}", metrics.is_tree());
    println!("      Is forest: {}", metrics.is_forest());
    println!("      Is sparse: {}", metrics.is_sparse());
    println!("      Is dense: {}", metrics.is_dense());
    println!();

    // Visualize with DAG
    println!("   📊 Visualization:");
    let mut dag = DAG::new();
    dag.add_node(1, "types.h");
    dag.add_node(2, "main.c");
    dag.add_node(3, "main.o");
    dag.add_node(4, "app.exe");
    dag.add_edge(2, 3);
    dag.add_edge(1, 3);
    dag.add_edge(3, 4);

    println!("{}", dag.render());

    // Find the most impactful file
    let mut max_impact = 0;
    let mut most_impactful = "";
    for file in &files {
        let impact = compute_descendants_fn(&files, file, get_deps).len();
        if impact > max_impact {
            max_impact = impact;
            most_impactful = file;
        }
    }

    println!(
        "   ⚡ Most impactful file: '{}' (affects {} other files)",
        most_impactful, max_impact
    );
    println!();
}

pub fn node_count(&self) -> usize

Total number of nodes in the graph.

Examples found in repository

examples/dependency_analysis.rs (line 179)

fn example_metrics_dashboard() {
    println!("3. Dependency Graph Metrics");
    println!("   Statistical analysis of the dependency structure\n");

    // Build system example
    let get_deps = |file: &&str| match *file {
        "app.exe" => vec!["main.o", "utils.o", "io.o"],
        "main.o" => vec!["main.c", "types.h"],
        "utils.o" => vec!["utils.c", "types.h"],
        "io.o" => vec!["io.c", "types.h"],
        "main.c" => vec![],
        "utils.c" => vec![],
        "io.c" => vec![],
        "types.h" => vec![],
        _ => vec![],
    };

    let files = [
        "app.exe", "main.o", "utils.o", "io.o", "main.c", "utils.c", "io.c", "types.h",
    ];

    let metrics = GraphMetrics::compute(&files, get_deps);

    println!("   📈 Graph Statistics:");
    println!("      Total files: {}", metrics.node_count());
    println!("      Total dependencies: {}", metrics.edge_count());
    println!("      Root files (sources): {}", metrics.root_count());
    println!("      Leaf files (outputs): {}", metrics.leaf_count());
    println!("      Max depth: {}", metrics.max_depth());
    println!("      Max impact: {} files", metrics.max_descendants());
    println!("      Avg dependencies: {:.2}", metrics.avg_dependencies());
    println!("      Density: {:.2}%", metrics.density() * 100.0);
    println!();

    println!("   🔍 Graph Properties:");
    println!("      Is tree: {}", metrics.is_tree());
    println!("      Is forest: {}", metrics.is_forest());
    println!("      Is sparse: {}", metrics.is_sparse());
    println!("      Is dense: {}", metrics.is_dense());
    println!();

    // Visualize with DAG
    println!("   📊 Visualization:");
    let mut dag = DAG::new();
    dag.add_node(1, "types.h");
    dag.add_node(2, "main.c");
    dag.add_node(3, "main.o");
    dag.add_node(4, "app.exe");
    dag.add_edge(2, 3);
    dag.add_edge(1, 3);
    dag.add_edge(3, 4);

    println!("{}", dag.render());

    // Find the most impactful file
    let mut max_impact = 0;
    let mut most_impactful = "";
    for file in &files {
        let impact = compute_descendants_fn(&files, file, get_deps).len();
        if impact > max_impact {
            max_impact = impact;
            most_impactful = file;
        }
    }

    println!(
        "   ⚡ Most impactful file: '{}' (affects {} other files)",
        most_impactful, max_impact
    );
    println!();
}

pub fn edge_count(&self) -> usize

Total number of edges (dependencies) in the graph.

Examples found in repository

examples/dependency_analysis.rs (line 180)

fn example_metrics_dashboard() {
    println!("3. Dependency Graph Metrics");
    println!("   Statistical analysis of the dependency structure\n");

    // Build system example
    let get_deps = |file: &&str| match *file {
        "app.exe" => vec!["main.o", "utils.o", "io.o"],
        "main.o" => vec!["main.c", "types.h"],
        "utils.o" => vec!["utils.c", "types.h"],
        "io.o" => vec!["io.c", "types.h"],
        "main.c" => vec![],
        "utils.c" => vec![],
        "io.c" => vec![],
        "types.h" => vec![],
        _ => vec![],
    };

    let files = [
        "app.exe", "main.o", "utils.o", "io.o", "main.c", "utils.c", "io.c", "types.h",
    ];

    let metrics = GraphMetrics::compute(&files, get_deps);

    println!("   📈 Graph Statistics:");
    println!("      Total files: {}", metrics.node_count());
    println!("      Total dependencies: {}", metrics.edge_count());
    println!("      Root files (sources): {}", metrics.root_count());
    println!("      Leaf files (outputs): {}", metrics.leaf_count());
    println!("      Max depth: {}", metrics.max_depth());
    println!("      Max impact: {} files", metrics.max_descendants());
    println!("      Avg dependencies: {:.2}", metrics.avg_dependencies());
    println!("      Density: {:.2}%", metrics.density() * 100.0);
    println!();

    println!("   🔍 Graph Properties:");
    println!("      Is tree: {}", metrics.is_tree());
    println!("      Is forest: {}", metrics.is_forest());
    println!("      Is sparse: {}", metrics.is_sparse());
    println!("      Is dense: {}", metrics.is_dense());
    println!();

    // Visualize with DAG
    println!("   📊 Visualization:");
    let mut dag = DAG::new();
    dag.add_node(1, "types.h");
    dag.add_node(2, "main.c");
    dag.add_node(3, "main.o");
    dag.add_node(4, "app.exe");
    dag.add_edge(2, 3);
    dag.add_edge(1, 3);
    dag.add_edge(3, 4);

    println!("{}", dag.render());

    // Find the most impactful file
    let mut max_impact = 0;
    let mut most_impactful = "";
    for file in &files {
        let impact = compute_descendants_fn(&files, file, get_deps).len();
        if impact > max_impact {
            max_impact = impact;
            most_impactful = file;
        }
    }

    println!(
        "   ⚡ Most impactful file: '{}' (affects {} other files)",
        most_impactful, max_impact
    );
    println!();
}

pub fn root_count(&self) -> usize

Number of root nodes (nodes with no dependencies).

Examples found in repository

examples/dependency_analysis.rs (line 181)

fn example_metrics_dashboard() {
    println!("3. Dependency Graph Metrics");
    println!("   Statistical analysis of the dependency structure\n");

    // Build system example
    let get_deps = |file: &&str| match *file {
        "app.exe" => vec!["main.o", "utils.o", "io.o"],
        "main.o" => vec!["main.c", "types.h"],
        "utils.o" => vec!["utils.c", "types.h"],
        "io.o" => vec!["io.c", "types.h"],
        "main.c" => vec![],
        "utils.c" => vec![],
        "io.c" => vec![],
        "types.h" => vec![],
        _ => vec![],
    };

    let files = [
        "app.exe", "main.o", "utils.o", "io.o", "main.c", "utils.c", "io.c", "types.h",
    ];

    let metrics = GraphMetrics::compute(&files, get_deps);

    println!("   📈 Graph Statistics:");
    println!("      Total files: {}", metrics.node_count());
    println!("      Total dependencies: {}", metrics.edge_count());
    println!("      Root files (sources): {}", metrics.root_count());
    println!("      Leaf files (outputs): {}", metrics.leaf_count());
    println!("      Max depth: {}", metrics.max_depth());
    println!("      Max impact: {} files", metrics.max_descendants());
    println!("      Avg dependencies: {:.2}", metrics.avg_dependencies());
    println!("      Density: {:.2}%", metrics.density() * 100.0);
    println!();

    println!("   🔍 Graph Properties:");
    println!("      Is tree: {}", metrics.is_tree());
    println!("      Is forest: {}", metrics.is_forest());
    println!("      Is sparse: {}", metrics.is_sparse());
    println!("      Is dense: {}", metrics.is_dense());
    println!();

    // Visualize with DAG
    println!("   📊 Visualization:");
    let mut dag = DAG::new();
    dag.add_node(1, "types.h");
    dag.add_node(2, "main.c");
    dag.add_node(3, "main.o");
    dag.add_node(4, "app.exe");
    dag.add_edge(2, 3);
    dag.add_edge(1, 3);
    dag.add_edge(3, 4);

    println!("{}", dag.render());

    // Find the most impactful file
    let mut max_impact = 0;
    let mut most_impactful = "";
    for file in &files {
        let impact = compute_descendants_fn(&files, file, get_deps).len();
        if impact > max_impact {
            max_impact = impact;
            most_impactful = file;
        }
    }

    println!(
        "   ⚡ Most impactful file: '{}' (affects {} other files)",
        most_impactful, max_impact
    );
    println!();
}

pub fn leaf_count(&self) -> usize

Number of leaf nodes (nodes that nothing depends on).

Examples found in repository

examples/dependency_analysis.rs (line 182)

fn example_metrics_dashboard() {
    println!("3. Dependency Graph Metrics");
    println!("   Statistical analysis of the dependency structure\n");

    // Build system example
    let get_deps = |file: &&str| match *file {
        "app.exe" => vec!["main.o", "utils.o", "io.o"],
        "main.o" => vec!["main.c", "types.h"],
        "utils.o" => vec!["utils.c", "types.h"],
        "io.o" => vec!["io.c", "types.h"],
        "main.c" => vec![],
        "utils.c" => vec![],
        "io.c" => vec![],
        "types.h" => vec![],
        _ => vec![],
    };

    let files = [
        "app.exe", "main.o", "utils.o", "io.o", "main.c", "utils.c", "io.c", "types.h",
    ];

    let metrics = GraphMetrics::compute(&files, get_deps);

    println!("   📈 Graph Statistics:");
    println!("      Total files: {}", metrics.node_count());
    println!("      Total dependencies: {}", metrics.edge_count());
    println!("      Root files (sources): {}", metrics.root_count());
    println!("      Leaf files (outputs): {}", metrics.leaf_count());
    println!("      Max depth: {}", metrics.max_depth());
    println!("      Max impact: {} files", metrics.max_descendants());
    println!("      Avg dependencies: {:.2}", metrics.avg_dependencies());
    println!("      Density: {:.2}%", metrics.density() * 100.0);
    println!();

    println!("   🔍 Graph Properties:");
    println!("      Is tree: {}", metrics.is_tree());
    println!("      Is forest: {}", metrics.is_forest());
    println!("      Is sparse: {}", metrics.is_sparse());
    println!("      Is dense: {}", metrics.is_dense());
    println!();

    // Visualize with DAG
    println!("   📊 Visualization:");
    let mut dag = DAG::new();
    dag.add_node(1, "types.h");
    dag.add_node(2, "main.c");
    dag.add_node(3, "main.o");
    dag.add_node(4, "app.exe");
    dag.add_edge(2, 3);
    dag.add_edge(1, 3);
    dag.add_edge(3, 4);

    println!("{}", dag.render());

    // Find the most impactful file
    let mut max_impact = 0;
    let mut most_impactful = "";
    for file in &files {
        let impact = compute_descendants_fn(&files, file, get_deps).len();
        if impact > max_impact {
            max_impact = impact;
            most_impactful = file;
        }
    }

    println!(
        "   ⚡ Most impactful file: '{}' (affects {} other files)",
        most_impactful, max_impact
    );
    println!();
}

pub fn max_depth(&self) -> usize

Maximum depth (longest dependency chain from a root).

Examples found in repository

examples/dependency_analysis.rs (line 183)

fn example_metrics_dashboard() {
    println!("3. Dependency Graph Metrics");
    println!("   Statistical analysis of the dependency structure\n");

    // Build system example
    let get_deps = |file: &&str| match *file {
        "app.exe" => vec!["main.o", "utils.o", "io.o"],
        "main.o" => vec!["main.c", "types.h"],
        "utils.o" => vec!["utils.c", "types.h"],
        "io.o" => vec!["io.c", "types.h"],
        "main.c" => vec![],
        "utils.c" => vec![],
        "io.c" => vec![],
        "types.h" => vec![],
        _ => vec![],
    };

    let files = [
        "app.exe", "main.o", "utils.o", "io.o", "main.c", "utils.c", "io.c", "types.h",
    ];

    let metrics = GraphMetrics::compute(&files, get_deps);

    println!("   📈 Graph Statistics:");
    println!("      Total files: {}", metrics.node_count());
    println!("      Total dependencies: {}", metrics.edge_count());
    println!("      Root files (sources): {}", metrics.root_count());
    println!("      Leaf files (outputs): {}", metrics.leaf_count());
    println!("      Max depth: {}", metrics.max_depth());
    println!("      Max impact: {} files", metrics.max_descendants());
    println!("      Avg dependencies: {:.2}", metrics.avg_dependencies());
    println!("      Density: {:.2}%", metrics.density() * 100.0);
    println!();

    println!("   🔍 Graph Properties:");
    println!("      Is tree: {}", metrics.is_tree());
    println!("      Is forest: {}", metrics.is_forest());
    println!("      Is sparse: {}", metrics.is_sparse());
    println!("      Is dense: {}", metrics.is_dense());
    println!();

    // Visualize with DAG
    println!("   📊 Visualization:");
    let mut dag = DAG::new();
    dag.add_node(1, "types.h");
    dag.add_node(2, "main.c");
    dag.add_node(3, "main.o");
    dag.add_node(4, "app.exe");
    dag.add_edge(2, 3);
    dag.add_edge(1, 3);
    dag.add_edge(3, 4);

    println!("{}", dag.render());

    // Find the most impactful file
    let mut max_impact = 0;
    let mut most_impactful = "";
    for file in &files {
        let impact = compute_descendants_fn(&files, file, get_deps).len();
        if impact > max_impact {
            max_impact = impact;
            most_impactful = file;
        }
    }

    println!(
        "   ⚡ Most impactful file: '{}' (affects {} other files)",
        most_impactful, max_impact
    );
    println!();
}

pub fn max_descendants(&self) -> usize

Maximum number of descendants any single node has.

This represents the “blast radius” of the most impactful node.

Examples found in repository

examples/dependency_analysis.rs (line 184)

fn example_metrics_dashboard() {
    println!("3. Dependency Graph Metrics");
    println!("   Statistical analysis of the dependency structure\n");

    // Build system example
    let get_deps = |file: &&str| match *file {
        "app.exe" => vec!["main.o", "utils.o", "io.o"],
        "main.o" => vec!["main.c", "types.h"],
        "utils.o" => vec!["utils.c", "types.h"],
        "io.o" => vec!["io.c", "types.h"],
        "main.c" => vec![],
        "utils.c" => vec![],
        "io.c" => vec![],
        "types.h" => vec![],
        _ => vec![],
    };

    let files = [
        "app.exe", "main.o", "utils.o", "io.o", "main.c", "utils.c", "io.c", "types.h",
    ];

    let metrics = GraphMetrics::compute(&files, get_deps);

    println!("   📈 Graph Statistics:");
    println!("      Total files: {}", metrics.node_count());
    println!("      Total dependencies: {}", metrics.edge_count());
    println!("      Root files (sources): {}", metrics.root_count());
    println!("      Leaf files (outputs): {}", metrics.leaf_count());
    println!("      Max depth: {}", metrics.max_depth());
    println!("      Max impact: {} files", metrics.max_descendants());
    println!("      Avg dependencies: {:.2}", metrics.avg_dependencies());
    println!("      Density: {:.2}%", metrics.density() * 100.0);
    println!();

    println!("   🔍 Graph Properties:");
    println!("      Is tree: {}", metrics.is_tree());
    println!("      Is forest: {}", metrics.is_forest());
    println!("      Is sparse: {}", metrics.is_sparse());
    println!("      Is dense: {}", metrics.is_dense());
    println!();

    // Visualize with DAG
    println!("   📊 Visualization:");
    let mut dag = DAG::new();
    dag.add_node(1, "types.h");
    dag.add_node(2, "main.c");
    dag.add_node(3, "main.o");
    dag.add_node(4, "app.exe");
    dag.add_edge(2, 3);
    dag.add_edge(1, 3);
    dag.add_edge(3, 4);

    println!("{}", dag.render());

    // Find the most impactful file
    let mut max_impact = 0;
    let mut most_impactful = "";
    for file in &files {
        let impact = compute_descendants_fn(&files, file, get_deps).len();
        if impact > max_impact {
            max_impact = impact;
            most_impactful = file;
        }
    }

    println!(
        "   ⚡ Most impactful file: '{}' (affects {} other files)",
        most_impactful, max_impact
    );
    println!();
}

pub fn avg_dependencies(&self) -> f64

Average number of dependencies per node.

Examples found in repository

examples/dependency_analysis.rs (line 185)

fn example_metrics_dashboard() {
    println!("3. Dependency Graph Metrics");
    println!("   Statistical analysis of the dependency structure\n");

    // Build system example
    let get_deps = |file: &&str| match *file {
        "app.exe" => vec!["main.o", "utils.o", "io.o"],
        "main.o" => vec!["main.c", "types.h"],
        "utils.o" => vec!["utils.c", "types.h"],
        "io.o" => vec!["io.c", "types.h"],
        "main.c" => vec![],
        "utils.c" => vec![],
        "io.c" => vec![],
        "types.h" => vec![],
        _ => vec![],
    };

    let files = [
        "app.exe", "main.o", "utils.o", "io.o", "main.c", "utils.c", "io.c", "types.h",
    ];

    let metrics = GraphMetrics::compute(&files, get_deps);

    println!("   📈 Graph Statistics:");
    println!("      Total files: {}", metrics.node_count());
    println!("      Total dependencies: {}", metrics.edge_count());
    println!("      Root files (sources): {}", metrics.root_count());
    println!("      Leaf files (outputs): {}", metrics.leaf_count());
    println!("      Max depth: {}", metrics.max_depth());
    println!("      Max impact: {} files", metrics.max_descendants());
    println!("      Avg dependencies: {:.2}", metrics.avg_dependencies());
    println!("      Density: {:.2}%", metrics.density() * 100.0);
    println!();

    println!("   🔍 Graph Properties:");
    println!("      Is tree: {}", metrics.is_tree());
    println!("      Is forest: {}", metrics.is_forest());
    println!("      Is sparse: {}", metrics.is_sparse());
    println!("      Is dense: {}", metrics.is_dense());
    println!();

    // Visualize with DAG
    println!("   📊 Visualization:");
    let mut dag = DAG::new();
    dag.add_node(1, "types.h");
    dag.add_node(2, "main.c");
    dag.add_node(3, "main.o");
    dag.add_node(4, "app.exe");
    dag.add_edge(2, 3);
    dag.add_edge(1, 3);
    dag.add_edge(3, 4);

    println!("{}", dag.render());

    // Find the most impactful file
    let mut max_impact = 0;
    let mut most_impactful = "";
    for file in &files {
        let impact = compute_descendants_fn(&files, file, get_deps).len();
        if impact > max_impact {
            max_impact = impact;
            most_impactful = file;
        }
    }

    println!(
        "   ⚡ Most impactful file: '{}' (affects {} other files)",
        most_impactful, max_impact
    );
    println!();
}

pub fn density(&self) -> f64

Graph density (ratio of actual edges to possible edges).

Returns a value between 0.0 (no edges) and 1.0 (complete graph).

Examples found in repository

examples/dependency_analysis.rs (line 186)

fn example_metrics_dashboard() {
    println!("3. Dependency Graph Metrics");
    println!("   Statistical analysis of the dependency structure\n");

    // Build system example
    let get_deps = |file: &&str| match *file {
        "app.exe" => vec!["main.o", "utils.o", "io.o"],
        "main.o" => vec!["main.c", "types.h"],
        "utils.o" => vec!["utils.c", "types.h"],
        "io.o" => vec!["io.c", "types.h"],
        "main.c" => vec![],
        "utils.c" => vec![],
        "io.c" => vec![],
        "types.h" => vec![],
        _ => vec![],
    };

    let files = [
        "app.exe", "main.o", "utils.o", "io.o", "main.c", "utils.c", "io.c", "types.h",
    ];

    let metrics = GraphMetrics::compute(&files, get_deps);

    println!("   📈 Graph Statistics:");
    println!("      Total files: {}", metrics.node_count());
    println!("      Total dependencies: {}", metrics.edge_count());
    println!("      Root files (sources): {}", metrics.root_count());
    println!("      Leaf files (outputs): {}", metrics.leaf_count());
    println!("      Max depth: {}", metrics.max_depth());
    println!("      Max impact: {} files", metrics.max_descendants());
    println!("      Avg dependencies: {:.2}", metrics.avg_dependencies());
    println!("      Density: {:.2}%", metrics.density() * 100.0);
    println!();

    println!("   🔍 Graph Properties:");
    println!("      Is tree: {}", metrics.is_tree());
    println!("      Is forest: {}", metrics.is_forest());
    println!("      Is sparse: {}", metrics.is_sparse());
    println!("      Is dense: {}", metrics.is_dense());
    println!();

    // Visualize with DAG
    println!("   📊 Visualization:");
    let mut dag = DAG::new();
    dag.add_node(1, "types.h");
    dag.add_node(2, "main.c");
    dag.add_node(3, "main.o");
    dag.add_node(4, "app.exe");
    dag.add_edge(2, 3);
    dag.add_edge(1, 3);
    dag.add_edge(3, 4);

    println!("{}", dag.render());

    // Find the most impactful file
    let mut max_impact = 0;
    let mut most_impactful = "";
    for file in &files {
        let impact = compute_descendants_fn(&files, file, get_deps).len();
        if impact > max_impact {
            max_impact = impact;
            most_impactful = file;
        }
    }

    println!(
        "   ⚡ Most impactful file: '{}' (affects {} other files)",
        most_impactful, max_impact
    );
    println!();
}

pub fn is_tree(&self) -> bool

Check if this is a tree (single root, no multiple paths to same node).

Examples found in repository

examples/dependency_analysis.rs (line 190)

fn example_metrics_dashboard() {
    println!("3. Dependency Graph Metrics");
    println!("   Statistical analysis of the dependency structure\n");

    // Build system example
    let get_deps = |file: &&str| match *file {
        "app.exe" => vec!["main.o", "utils.o", "io.o"],
        "main.o" => vec!["main.c", "types.h"],
        "utils.o" => vec!["utils.c", "types.h"],
        "io.o" => vec!["io.c", "types.h"],
        "main.c" => vec![],
        "utils.c" => vec![],
        "io.c" => vec![],
        "types.h" => vec![],
        _ => vec![],
    };

    let files = [
        "app.exe", "main.o", "utils.o", "io.o", "main.c", "utils.c", "io.c", "types.h",
    ];

    let metrics = GraphMetrics::compute(&files, get_deps);

    println!("   📈 Graph Statistics:");
    println!("      Total files: {}", metrics.node_count());
    println!("      Total dependencies: {}", metrics.edge_count());
    println!("      Root files (sources): {}", metrics.root_count());
    println!("      Leaf files (outputs): {}", metrics.leaf_count());
    println!("      Max depth: {}", metrics.max_depth());
    println!("      Max impact: {} files", metrics.max_descendants());
    println!("      Avg dependencies: {:.2}", metrics.avg_dependencies());
    println!("      Density: {:.2}%", metrics.density() * 100.0);
    println!();

    println!("   🔍 Graph Properties:");
    println!("      Is tree: {}", metrics.is_tree());
    println!("      Is forest: {}", metrics.is_forest());
    println!("      Is sparse: {}", metrics.is_sparse());
    println!("      Is dense: {}", metrics.is_dense());
    println!();

    // Visualize with DAG
    println!("   📊 Visualization:");
    let mut dag = DAG::new();
    dag.add_node(1, "types.h");
    dag.add_node(2, "main.c");
    dag.add_node(3, "main.o");
    dag.add_node(4, "app.exe");
    dag.add_edge(2, 3);
    dag.add_edge(1, 3);
    dag.add_edge(3, 4);

    println!("{}", dag.render());

    // Find the most impactful file
    let mut max_impact = 0;
    let mut most_impactful = "";
    for file in &files {
        let impact = compute_descendants_fn(&files, file, get_deps).len();
        if impact > max_impact {
            max_impact = impact;
            most_impactful = file;
        }
    }

    println!(
        "   ⚡ Most impactful file: '{}' (affects {} other files)",
        most_impactful, max_impact
    );
    println!();
}

pub fn is_forest(&self) -> bool

Check if this is a forest (multiple trees, no cycles).

Examples found in repository

examples/dependency_analysis.rs (line 191)

fn example_metrics_dashboard() {
    println!("3. Dependency Graph Metrics");
    println!("   Statistical analysis of the dependency structure\n");

    // Build system example
    let get_deps = |file: &&str| match *file {
        "app.exe" => vec!["main.o", "utils.o", "io.o"],
        "main.o" => vec!["main.c", "types.h"],
        "utils.o" => vec!["utils.c", "types.h"],
        "io.o" => vec!["io.c", "types.h"],
        "main.c" => vec![],
        "utils.c" => vec![],
        "io.c" => vec![],
        "types.h" => vec![],
        _ => vec![],
    };

    let files = [
        "app.exe", "main.o", "utils.o", "io.o", "main.c", "utils.c", "io.c", "types.h",
    ];

    let metrics = GraphMetrics::compute(&files, get_deps);

    println!("   📈 Graph Statistics:");
    println!("      Total files: {}", metrics.node_count());
    println!("      Total dependencies: {}", metrics.edge_count());
    println!("      Root files (sources): {}", metrics.root_count());
    println!("      Leaf files (outputs): {}", metrics.leaf_count());
    println!("      Max depth: {}", metrics.max_depth());
    println!("      Max impact: {} files", metrics.max_descendants());
    println!("      Avg dependencies: {:.2}", metrics.avg_dependencies());
    println!("      Density: {:.2}%", metrics.density() * 100.0);
    println!();

    println!("   🔍 Graph Properties:");
    println!("      Is tree: {}", metrics.is_tree());
    println!("      Is forest: {}", metrics.is_forest());
    println!("      Is sparse: {}", metrics.is_sparse());
    println!("      Is dense: {}", metrics.is_dense());
    println!();

    // Visualize with DAG
    println!("   📊 Visualization:");
    let mut dag = DAG::new();
    dag.add_node(1, "types.h");
    dag.add_node(2, "main.c");
    dag.add_node(3, "main.o");
    dag.add_node(4, "app.exe");
    dag.add_edge(2, 3);
    dag.add_edge(1, 3);
    dag.add_edge(3, 4);

    println!("{}", dag.render());

    // Find the most impactful file
    let mut max_impact = 0;
    let mut most_impactful = "";
    for file in &files {
        let impact = compute_descendants_fn(&files, file, get_deps).len();
        if impact > max_impact {
            max_impact = impact;
            most_impactful = file;
        }
    }

    println!(
        "   ⚡ Most impactful file: '{}' (affects {} other files)",
        most_impactful, max_impact
    );
    println!();
}

pub fn is_sparse(&self) -> bool

Check if the graph is sparse (few edges relative to nodes).

Examples found in repository

examples/dependency_analysis.rs (line 192)

fn example_metrics_dashboard() {
    println!("3. Dependency Graph Metrics");
    println!("   Statistical analysis of the dependency structure\n");

    // Build system example
    let get_deps = |file: &&str| match *file {
        "app.exe" => vec!["main.o", "utils.o", "io.o"],
        "main.o" => vec!["main.c", "types.h"],
        "utils.o" => vec!["utils.c", "types.h"],
        "io.o" => vec!["io.c", "types.h"],
        "main.c" => vec![],
        "utils.c" => vec![],
        "io.c" => vec![],
        "types.h" => vec![],
        _ => vec![],
    };

    let files = [
        "app.exe", "main.o", "utils.o", "io.o", "main.c", "utils.c", "io.c", "types.h",
    ];

    let metrics = GraphMetrics::compute(&files, get_deps);

    println!("   📈 Graph Statistics:");
    println!("      Total files: {}", metrics.node_count());
    println!("      Total dependencies: {}", metrics.edge_count());
    println!("      Root files (sources): {}", metrics.root_count());
    println!("      Leaf files (outputs): {}", metrics.leaf_count());
    println!("      Max depth: {}", metrics.max_depth());
    println!("      Max impact: {} files", metrics.max_descendants());
    println!("      Avg dependencies: {:.2}", metrics.avg_dependencies());
    println!("      Density: {:.2}%", metrics.density() * 100.0);
    println!();

    println!("   🔍 Graph Properties:");
    println!("      Is tree: {}", metrics.is_tree());
    println!("      Is forest: {}", metrics.is_forest());
    println!("      Is sparse: {}", metrics.is_sparse());
    println!("      Is dense: {}", metrics.is_dense());
    println!();

    // Visualize with DAG
    println!("   📊 Visualization:");
    let mut dag = DAG::new();
    dag.add_node(1, "types.h");
    dag.add_node(2, "main.c");
    dag.add_node(3, "main.o");
    dag.add_node(4, "app.exe");
    dag.add_edge(2, 3);
    dag.add_edge(1, 3);
    dag.add_edge(3, 4);

    println!("{}", dag.render());

    // Find the most impactful file
    let mut max_impact = 0;
    let mut most_impactful = "";
    for file in &files {
        let impact = compute_descendants_fn(&files, file, get_deps).len();
        if impact > max_impact {
            max_impact = impact;
            most_impactful = file;
        }
    }

    println!(
        "   ⚡ Most impactful file: '{}' (affects {} other files)",
        most_impactful, max_impact
    );
    println!();
}

pub fn is_dense(&self) -> bool

Check if the graph is dense (many edges relative to nodes).

Examples found in repository

examples/dependency_analysis.rs (line 193)

fn example_metrics_dashboard() {
    println!("3. Dependency Graph Metrics");
    println!("   Statistical analysis of the dependency structure\n");

    // Build system example
    let get_deps = |file: &&str| match *file {
        "app.exe" => vec!["main.o", "utils.o", "io.o"],
        "main.o" => vec!["main.c", "types.h"],
        "utils.o" => vec!["utils.c", "types.h"],
        "io.o" => vec!["io.c", "types.h"],
        "main.c" => vec![],
        "utils.c" => vec![],
        "io.c" => vec![],
        "types.h" => vec![],
        _ => vec![],
    };

    let files = [
        "app.exe", "main.o", "utils.o", "io.o", "main.c", "utils.c", "io.c", "types.h",
    ];

    let metrics = GraphMetrics::compute(&files, get_deps);

    println!("   📈 Graph Statistics:");
    println!("      Total files: {}", metrics.node_count());
    println!("      Total dependencies: {}", metrics.edge_count());
    println!("      Root files (sources): {}", metrics.root_count());
    println!("      Leaf files (outputs): {}", metrics.leaf_count());
    println!("      Max depth: {}", metrics.max_depth());
    println!("      Max impact: {} files", metrics.max_descendants());
    println!("      Avg dependencies: {:.2}", metrics.avg_dependencies());
    println!("      Density: {:.2}%", metrics.density() * 100.0);
    println!();

    println!("   🔍 Graph Properties:");
    println!("      Is tree: {}", metrics.is_tree());
    println!("      Is forest: {}", metrics.is_forest());
    println!("      Is sparse: {}", metrics.is_sparse());
    println!("      Is dense: {}", metrics.is_dense());
    println!();

    // Visualize with DAG
    println!("   📊 Visualization:");
    let mut dag = DAG::new();
    dag.add_node(1, "types.h");
    dag.add_node(2, "main.c");
    dag.add_node(3, "main.o");
    dag.add_node(4, "app.exe");
    dag.add_edge(2, 3);
    dag.add_edge(1, 3);
    dag.add_edge(3, 4);

    println!("{}", dag.render());

    // Find the most impactful file
    let mut max_impact = 0;
    let mut most_impactful = "";
    for file in &files {
        let impact = compute_descendants_fn(&files, file, get_deps).len();
        if impact > max_impact {
            max_impact = impact;
            most_impactful = file;
        }
    }

    println!(
        "   ⚡ Most impactful file: '{}' (affects {} other files)",
        most_impactful, max_impact
    );
    println!();
}

Trait Implementations

impl Clone for GraphMetrics

fn clone(&self) -> GraphMetrics

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GraphMetrics

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

Formats the value using the given formatter.