yog - v5.0.0

yog/community/internal

Internal utilities shared by Louvain and Leiden algorithms.

This module contains helper functions for modularity-based community detection. These are implementation details used by the Louvain and Leiden modules.

Internal Types

Functions

These functions are primarily for internal use:

Note: This module is exposed for advanced users who want to implement custom variants of modularity-based algorithms. Most users should use the louvain or leiden modules directly.

Types

CommunityState

</>

Internal state for modularity-based algorithms.

pub type CommunityState {
  CommunityState(
    assignments: dict.Dict(Int, Int),
    node_weights: dict.Dict(Int, Float),
    community_totals: dict.Dict(Int, Float),
    community_internals: dict.Dict(Int, Float),
    total_weight: Float,
  )
}

Constructors 

  • CommunityState(
  assignments: dict.Dict(Int, Int),
  node_weights: dict.Dict(Int, Float),
  community_totals: dict.Dict(Int, Float),
  community_internals: dict.Dict(Int, Float),
  total_weight: Float,
)

Values

calculate_community_totals

</> 
pub fn calculate_community_totals(
  assignments: dict.Dict(Int, Int),
  node_weights: dict.Dict(Int, Float),
) -> dict.Dict(Int, Float)

Calculate total weight incident to each community.

calculate_ki_in

</> 
pub fn calculate_ki_in(
  graph: model.Graph(n, Int),
  state: CommunityState,
  node: Int,
  target_comm: Int,
) -> Float

Calculate sum of edge weights from node to target community. Calculate sum of edge weights from node to target community.

calculate_modularity_gain

</> 
pub fn calculate_modularity_gain(
  graph: model.Graph(n, Int),
  node: Int,
  current_comm: Int,
  target_comm: Int,
  node_weight: Float,
  state: CommunityState,
) -> Float

Calculate modularity gain from moving a node between communities.

calculate_node_weights

</> 
pub fn calculate_node_weights(
  graph: model.Graph(n, Int),
) -> dict.Dict(Int, Float)

Calculate degree (weight) for each node. Calculate degree (weight) for each node.

calculate_total_weight

</> 
pub fn calculate_total_weight(
  graph: model.Graph(n, Int),
) -> Float

Calculate total edge weight in graph. Calculate total edge weight in graph.

count_unique_communities

</> 
pub fn count_unique_communities(
  assignments: dict.Dict(Int, Int),
) -> Int

Count unique communities in assignments.

get_community_nodes

</> 
pub fn get_community_nodes(
  assignments: dict.Dict(Int, Int),
) -> dict.Dict(Int, set.Set(Int))

Convert assignments to community -> nodes mapping.

get_neighbor_communities

</> 
pub fn get_neighbor_communities(
  graph: model.Graph(n, Int),
  state: CommunityState,
  node: Int,
) -> List(Int)

Get communities that are neighbors of a node.

move_node

</> 
pub fn move_node(
  state: CommunityState,
  node: Int,
  from_comm: Int,
  to_comm: Int,
  node_weight: Float,
) -> CommunityState

Move a node from one community to another.

normalize_assignments

</> 
pub fn normalize_assignments(
  assignments: dict.Dict(Int, Int),
) -> dict.Dict(Int, Int)

Normalize community IDs to be contiguous from 0 to k-1. This ensures that if there are k communities, they are numbered 0, 1, …, k-1 with no gaps, which is required for various property tests and downstream algorithms.

phase2_aggregate

</> 
pub fn phase2_aggregate(
  graph: model.Graph(n, Int),
  assignments: dict.Dict(Int, Int),
) -> model.Graph(Nil, Int)

Aggregate graph by merging communities into super-nodes.

rebuild_state

</> 
pub fn rebuild_state(
  aggregated_graph: model.Graph(Nil, Int),
) -> CommunityState

Rebuild state for aggregated graph.

shuffle

</> 
pub fn shuffle(items: List(a), seed: Int) -> List(a)

Deterministic shuffle using Linear Congruential Generator.

✨ Search Document