Struct AdjacencyReport 

pub struct AdjacencyReport { /* private fields */ }

Observable adjacency-construction results for a set of edges.

Examples

use whitaker_common::test_support::decomposition::{EdgeInput, adjacency_report};

let report = adjacency_report(3, &[
    EdgeInput { left: 0, right: 1, weight: 5 },
]);
assert!(report.is_ok());
let report = report.unwrap();
assert_eq!(report.node_count(), 3);
assert!(report.is_symmetric());

Implementations

impl AdjacencyReport

pub fn node_count(&self) -> usize

Returns the number of nodes in the adjacency graph.

use whitaker_common::test_support::decomposition::{EdgeInput, adjacency_report};

let report = adjacency_report(4, &[]).expect("valid input");
assert_eq!(report.node_count(), 4);

pub fn neighbours_of(&self, node: usize) -> Option<&[(usize, u64)]>

Returns the neighbour list for node, sorted by neighbour index.

Returns None if node is out of range.

use whitaker_common::test_support::decomposition::{EdgeInput, adjacency_report};

let report = adjacency_report(3, &[
    EdgeInput { left: 0, right: 2, weight: 7 },
]).expect("valid input");
assert_eq!(report.neighbours_of(0), Some(&[(2, 7)][..]));
assert_eq!(report.neighbours_of(10), None);

pub fn all_indices_in_bounds(&self) -> bool

Returns true if all neighbour indices are within bounds.

use whitaker_common::test_support::decomposition::{EdgeInput, adjacency_report};

let report = adjacency_report(3, &[
    EdgeInput { left: 0, right: 1, weight: 5 },
]).expect("valid input");
assert!(report.all_indices_in_bounds());

pub fn is_symmetric(&self) -> bool

Returns true if the adjacency lists are symmetric: for every entry (node -> neighbour, weight), the mirrored entry exists.

use whitaker_common::test_support::decomposition::{EdgeInput, adjacency_report};

let report = adjacency_report(3, &[
    EdgeInput { left: 0, right: 2, weight: 7 },
]).expect("valid input");
assert!(report.is_symmetric());

pub fn is_sorted(&self) -> bool

Returns true if each per-node neighbour list is sorted by neighbour index.

use whitaker_common::test_support::decomposition::{EdgeInput, adjacency_report};

let report = adjacency_report(4, &[
    EdgeInput { left: 0, right: 1, weight: 5 },
    EdgeInput { left: 0, right: 3, weight: 3 },
]).expect("valid input");
assert!(report.is_sorted());

Trait Implementations

impl Clone for AdjacencyReport

fn clone(&self) -> AdjacencyReport

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AdjacencyReport

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

Formats the value using the given formatter.

impl PartialEq for AdjacencyReport

fn eq(&self, other: &AdjacencyReport) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for AdjacencyReport

impl StructuralPartialEq for AdjacencyReport