Struct lib_dachshund::dachshund::simple_undirected_graph::SimpleUndirectedGraph

pub struct SimpleUndirectedGraph {
    pub nodes: HashMap<NodeId, Node>,
    pub ids: Vec<NodeId>,
}

Keeps track of a simple undirected graph, composed of nodes without any type information.

Fields

nodes: HashMap<NodeId, Node>

ids: Vec<NodeId>

Implementations

impl SimpleUndirectedGraph

pub fn as_input_rows(&self, graph_id: usize) -> String

pub fn get_node_degree(&self, id: NodeId) -> usize

pub fn get_clustering_coefficient(&self, id: NodeId) -> Option<f64>

pub fn get_avg_clustering(&self) -> f64

pub fn triangle_count(&self, node_id: NodeId) -> usize

pub fn triples_count(&self, node_id: NodeId) -> usize

pub fn get_transitivity(&self) -> f64

pub fn get_approx_avg_clustering(&self, samples: usize) -> f64

pub fn get_approx_transitivity(&self, samples: usize) -> f64

pub fn get_shortest_paths(
    &self,
    source: NodeId,
    nodes_in_connected_component: Option<&Vec<NodeId>>
) -> (HashMap<NodeId, Option<usize>>, HashMap<NodeId, HashSet<NodeId>>)

pub fn get_shortest_paths_bfs(
    &self,
    source: NodeId
) -> (Vec<NodeId>, HashMap<NodeId, u32>, HashMap<NodeId, Vec<NodeId>>)

Single source paths in a unweighted, undirected graph by bfs. Returns nodes in the order of exploration, distances, and predecesors.

pub fn enumerate_shortest_paths(
    &self,
    dist: &HashMap<NodeId, Option<usize>>,
    parents: &HashMap<NodeId, HashSet<NodeId>>,
    destination: NodeId
) -> HashMap<NodeId, Vec<Vec<NodeId>>>

pub fn visit_nodes_from_root(
    &self,
    root: &NodeId,
    visited: &mut BTreeSet<NodeId>
)

pub fn get_is_connected(&self) -> Result<bool, &'static str>

pub fn create_empty() -> Self

pub fn get_node_betweenness_starting_from_sources(
    &self,
    sources: &[NodeId],
    check_is_connected: bool,
    nodes_in_connected_component: Option<&Vec<NodeId>>
) -> Result<HashMap<NodeId, f64>, &'static str>

pub fn get_node_betweenness(&self) -> Result<HashMap<NodeId, f64>, &'static str>

pub fn get_node_betweenness_brandes(
    &self
) -> Result<HashMap<NodeId, f64>, &'static str>

pub fn get_degree_matrix(&self) -> (DMatrix<f64>, Vec<NodeId>)

pub fn get_adjacency_matrix_given_node_ids(
    &self,
    node_ids: &[NodeId]
) -> DMatrix<f64>

pub fn get_adjacency_matrix(&self) -> (DMatrix<f64>, Vec<NodeId>)

pub fn get_laplacian_matrix(&self) -> (DMatrix<f64>, Vec<NodeId>)

pub fn get_algebraic_connectivity(&self) -> f64

pub fn get_eigenvector_centrality(
    &self,
    eps: f64,
    max_iter: usize
) -> HashMap<NodeId, f64>

pub fn _get_connected_components_membership(
    &self,
    ignore_nodes: Option<&HashSet<NodeId>>,
    ignore_edges: Option<&HashSet<(NodeId, NodeId)>>
) -> (HashMap<NodeId, usize>, usize)

pub fn _get_connected_components(
    &self,
    ignore_nodes: Option<&HashSet<NodeId>>,
    ignore_edges: Option<&HashSet<(NodeId, NodeId)>>
) -> Vec<Vec<NodeId>>

pub fn get_connected_components(&self) -> Vec<Vec<NodeId>>

pub fn _get_k_cores(
    &self,
    k: usize,
    removed: &mut HashSet<NodeId>
) -> Vec<Vec<NodeId>>

pub fn get_k_cores(&self, k: usize) -> Vec<Vec<NodeId>>

pub fn get_coreness(&self) -> (Vec<Vec<Vec<NodeId>>>, HashMap<NodeId, usize>)

pub fn _get_k_trusses(
    &self,
    k: usize,
    ignore_nodes: &HashSet<NodeId>
) -> (Vec<BTreeSet<(NodeId, NodeId)>>, HashSet<BTreeSet<NodeId>>)

pub fn get_k_trusses(
    &self,
    k: usize
) -> (Vec<BTreeSet<(NodeId, NodeId)>>, HashSet<BTreeSet<NodeId>>)

Trait Implementations

impl GraphBase for SimpleUndirectedGraph

fn get_core_ids(&self) -> &Vec<NodeId>

core and non-core IDs are the same for a SimpleUndirectedGraph.

fn get_non_core_ids(&self) -> Option<&Vec<NodeId>>

core and non-core IDs are the same for a SimpleUndirectedGraph.

fn get_mut_nodes(&mut self) -> &mut HashMap<NodeId, Node>

fn has_node(&self, node_id: NodeId) -> bool

fn get_node(&self, node_id: NodeId) -> &Node

fn count_edges(&self) -> usize

impl GraphBuilder<SimpleUndirectedGraph> for SimpleUndirectedGraphBuilder

fn _new(
    nodes: HashMap<NodeId, Node>,
    core_ids: Vec<NodeId>,
    non_core_ids: Vec<NodeId>
) -> CLQResult<SimpleUndirectedGraph>

fn init_nodes(
    core_ids: &[NodeId],
    non_core_ids: &[NodeId],
    non_core_type_ids: &HashMap<NodeId, NodeTypeId>
) -> HashMap<NodeId, Node>

fn populate_edges(
    rows: &[EdgeRow],
    node_map: &mut HashMap<NodeId, Node>
) -> CLQResult<()>

given a set of initialized Nodes, populates the respective neighbors fields appropriately.

fn trim_edges(
    node_map: &mut HashMap<NodeId, Node>,
    min_degree: &usize
) -> HashSet<NodeId>

Trims edges greedily, until all edges in the graph have degree at least min_degree. Note that this function does not delete any nodes -- just finds nodes to delete. It is called by prune, which actually does the deletion.

fn new(
    graph_id: GraphId,
    rows: &[EdgeRow],
    min_degree: Option<usize>
) -> CLQResult<TGraph>

creates a TGraph object from a vector of rows. Client must provide graph_id which must match with each row's graph_id. If min_degree is provided, the graph is additionally pruned.

fn prune(
    graph: TGraph,
    rows: &[EdgeRow],
    min_degree: usize
) -> CLQResult<TGraph>

Takes an already-built graph and the edge rows used to create it, returning a new graph, where all nodes are assured to have degree at least min_degree. The provision of a TGraph is necessary, since the notion of "degree" does not make sense outside of a graph.

fn get_filtered_sources_targets_rows(
    graph: TGraph,
    min_degree: usize,
    rows: &[EdgeRow]
) -> (Vec<NodeId>, Vec<NodeId>, Vec<EdgeRow>)

called by prune, finds source and target nodes to exclude, as well as edges to exclude when rebuilding the graph from a filtered vector of EdgeRows.