single-clustering 0.6.1

A high-performance network clustering library implementing community detection algorithms like Louvain and Leiden. Features efficient graph representation, abstract grouping systems, and K-NN graph creation from high-dimensional data. Provides parallel computation support via Rayon for handling large networks.
Documentation

single-clustering

⚠️ Development Status: This library is currently under heavy development and should not be considered production ready. APIs may change significantly between versions.

A Rust library for community detection and graph clustering algorithms with a focus on performance and flexibility.

Features

  • Efficient Network Representation: CSR (Compressed Sparse Row) format for optimal memory usage and performance
  • Community Detection Algorithms:
    • Leiden Algorithm: State-of-the-art method with guaranteed well-connected communities
    • Louvain Method: Classic modularity optimization (work-in-progress)
  • Quality Functions: Multiple partition quality metrics
    • Modularity optimization
    • Reichardt-Bornholdt (RB) configuration model with tunable resolution
  • Flexible Architecture: Generic trait-based design supporting different network types and grouping strategies
  • Performance Optimized: Caching strategies and efficient data structures for large networks

Usage

use single_clustering::network::CSRNetwork;
use single_clustering::community_search::leiden::{LeidenOptimizer, LeidenConfig};
use single_clustering::community_search::leiden::partition::ModularityPartition;

// Create a CSR network from your data
let network = CSRNetwork::new(edges, weights, node_count);

// Configure the Leiden algorithm
let config = LeidenConfig {
    max_iterations: 100,
    tolerance: 1e-6,
    seed: Some(42),
    ..Default::default()
};

// Initialize the optimizer
let mut optimizer = LeidenOptimizer::new(config);

// Find communities using modularity optimization
let partition: ModularityPartition<f64, _> = optimizer.find_partition(network)?;

// Access results
for node in 0..partition.node_count() {
    println!("Node {} is in community {}", node, partition.membership(node));
}
println!("Modularity: {:.4}", partition.quality());

Installation

Add this to your Cargo.toml:

[dependencies]
single-clustering = "0.6.0"

Current Status

  • ✅ Leiden Algorithm: Core implementation with modularity and RB quality functions
  • ✅ CSR Network Representation: Efficient storage for large graphs
  • ✅ Quality Functions: Modularity and Reichardt-Bornholdt implementations
  • 🚧 Louvain Algorithm: Basic implementation (work-in-progress)
  • 🚧 Documentation: API documentation and examples (ongoing)
  • ❌ Benchmarks: Performance testing suite (planned)
  • ❌ Python Bindings: PyO3 integration (planned)

Contributing

This project is in active development. Contributions, bug reports, and feature requests are welcome!

License

This crate is licensed under the BSD 3-Clause License.