feat: impl of ByRandom

Author: zeon256

Cargo.lock

@@ -13,6 +13,7 @@ keywords = ["dsu", "disjoint-set", "union-find", "no-std"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+rand = { version = "0.9.2", default-features = false }
 
 [dev-dependencies]
-heapless = "0.7.16"
+heapless = "0.7.16"

Cargo.toml

@@ -68,11 +68,15 @@
 
 pub mod quickfind;
 pub mod quickunion;
+pub mod rng;
 
 use core::marker::PhantomData;
 use core::ops::AddAssign;
 
+use rand::RngCore;
+
 pub use crate::quickfind::QuickFind;
+use crate::quickunion::Heuristic;
 pub use crate::quickunion::QuickUnion;
 pub use crate::quickunion::{ByRank, BySize, Unweighted};
 
@@ -149,13 +153,14 @@ where
 {
     representative: A::RepresentativeContainer<'a, T, N>,
     heuristic: A::HeuristicContainer<'a, N>,
+    rng: A::RngKind<'a>,
     algorithm: PhantomData<A>,
 }
 
 impl<'a, A, T, const N: usize> UnionFind<'a, A, T, N>
 where
     T: VertexType,
-    A: AlgorithmContainer + Union<T> + Find<T> + Connected<T>,
+    A: AlgorithmContainer + Union<T, A::HeuristicKind<'a>> + Find<T> + Connected<T>,
 {
     /// Checks whether 2 nodes are connected to each other
     pub fn connected(&mut self, a: T::IdentifierType, b: T::IdentifierType) -> bool {
@@ -170,14 +175,15 @@ where
     /// Unions 2 node. If those 2 nodes are already part of the same component
     /// then this does nothing
     pub fn union_sets(&mut self, a: T::IdentifierType, b: T::IdentifierType) {
-        A::union_sets(self.representative.as_mut(), self.heuristic.as_mut(), a, b)
-    }
-
-    /// Gets the representative slice
-    pub fn representative(&self) -> &A::RepresentativeContainer<'a, T, N> {
-        &self.representative
+        A::union_sets(
+            self.representative.as_mut(),
+            self.heuristic.as_mut(),
+            a,
+            b,
+            self.rng.as_mut(),
+        )
     }
-
+    /// Gets the representative slice pub fn representative(&self) -> &A::RepresentativeContainer<'a, T, N> { &self.representative }
     /// Gets the heuristic slice
     pub fn heuristic(&self) -> &A::HeuristicContainer<'a, N> {
         &self.heuristic
@@ -186,6 +192,8 @@ where
 
 /// This trait represents the kind of containers that is required for a particular algorithm to function
 pub trait AlgorithmContainer {
+    type HeuristicKind<'a>: Heuristic<RngProvider = Self::RngKind<'a>>;
+
     /// Any kind of contiguous container
     ///
     /// # Examples
@@ -199,35 +207,30 @@ pub trait AlgorithmContainer {
     /// # Examples
     /// - `[T; N]`
     /// - `heaples::Vec<T, N>`
-    type RepresentativeContainer<'a, R: VertexType + 'a, const N: usize>: AsRef<[R]> + AsMut<[R]>;
+    type RepresentativeContainer<'a, V: VertexType + 'a, const N: usize>: AsRef<[V]> + AsMut<[V]>;
+
+    /// Any kind of RNG
+    type RngKind<'a>: RngCore + AsMut<Self::RngKind<'a>>;
 }
 
 /// Union operation
-pub trait Union<T>
-where
-    T: VertexType,
-{
+pub trait Union<T: VertexType, H: Heuristic> {
     fn union_sets(
         representative: &mut [T],
         heuristic: &mut [usize],
         a: T::IdentifierType,
         b: T::IdentifierType,
+        rng: &mut H::RngProvider,
     );
 }
 
 /// Find operation
-pub trait Find<T>
-where
-    T: VertexType,
-{
+pub trait Find<T: VertexType> {
     fn find(representative: &mut [T], a: T::IdentifierType) -> T;
 }
 
 /// Connected operation
-pub trait Connected<T>
-where
-    T: VertexType,
-{
+pub trait Connected<T: VertexType> {
     fn connected(representative: &mut [T], a: T::IdentifierType, b: T::IdentifierType) -> bool;
 }
 

src/lib.rs

@@ -1,19 +1,48 @@
 //! Quick Find implementations
 
-use crate::{AlgorithmContainer, Connected, Find, Union, UnionFind, VertexType};
+use core::marker::PhantomData;
+
+use crate::{
+    quickunion::Heuristic, rng::PhantomRng, AlgorithmContainer, Borrowed, Connected, Find, Owned,
+    Union, UnionFind, VertexType,
+};
 
 /// [`QuickFind`] algorithm
 #[derive(Debug, Default)]
-pub struct QuickFind<const IS_SLICE: bool = false>;
+pub struct QuickFind<K = Owned> {
+    _p: PhantomData<K>,
+}
+
+pub struct NoHeuristic;
+
+impl Heuristic for NoHeuristic {
+    type RngProvider = PhantomRng;
+
+    fn handle_decision<T>(
+        _a: T::IdentifierType,
+        _b: T::IdentifierType,
+        _heuristic: &mut [usize],
+        _representative: &mut [T],
+        _r: &mut Self::RngProvider,
+    ) where
+        T: VertexType,
+    {
+        unreachable!("Should not be called!")
+    }
+}
 
-impl AlgorithmContainer for QuickFind<false> {
+impl AlgorithmContainer for QuickFind<Owned> {
+    type HeuristicKind<'a> = NoHeuristic;
     type HeuristicContainer<'a, const N: usize> = [usize; 0];
     type RepresentativeContainer<'a, R: VertexType + 'a, const N: usize> = [R; N];
+    type RngKind<'a> = PhantomRng;
 }
 
-impl AlgorithmContainer for QuickFind<true> {
+impl AlgorithmContainer for QuickFind<Borrowed> {
+    type HeuristicKind<'a> = NoHeuristic;
     type HeuristicContainer<'a, const N: usize> = [usize; 0];
     type RepresentativeContainer<'a, R: VertexType + 'a, const N: usize> = &'a mut [R];
+    type RngKind<'a> = PhantomRng;
 }
 
 macro_rules! generate_default_ctor_quickfind {
@@ -32,14 +61,15 @@ macro_rules! generate_default_ctor_quickfind {
                     representative,
                     heuristic: [0; 0],
                     algorithm: Default::default(),
+                    rng: PhantomRng
                 }
             }
         }
         )*
     };
 }
 
-impl<'a, T, const N: usize> UnionFind<'a, QuickFind<true>, T, N>
+impl<'a, T, const N: usize> UnionFind<'a, QuickFind<Borrowed>, T, N>
 where
     T: VertexType,
 {
@@ -48,11 +78,12 @@ where
             representative,
             heuristic: [0; 0],
             algorithm: Default::default(),
+            rng: PhantomRng,
         }
     }
 }
 
-impl<T, const IS_SLICE: bool> Connected<T> for QuickFind<IS_SLICE>
+impl<T, K> Connected<T> for QuickFind<K>
 where
     T: VertexType,
     Self: Find<T>,
@@ -62,7 +93,7 @@ where
     }
 }
 
-impl<T, const IS_SLICE: bool> Union<T> for QuickFind<IS_SLICE>
+impl<T, K> Union<T, NoHeuristic> for QuickFind<K>
 where
     T: VertexType,
     Self: Find<T>,
@@ -72,6 +103,7 @@ where
         _heuristic: &mut [usize],
         a: T::IdentifierType,
         b: T::IdentifierType,
+        _r: &mut PhantomRng,
     ) {
         let root_a = Self::find(representative, a);
         let root_b = Self::find(representative, b);
@@ -83,7 +115,7 @@ where
     }
 }
 
-impl<T, const IS_SLICE: bool> Find<T> for QuickFind<IS_SLICE>
+impl<T, K> Find<T> for QuickFind<K>
 where
     T: VertexType,
 {
@@ -97,7 +129,7 @@ generate_default_ctor_quickfind!(u8, u16, u32, u64, usize);
 
 #[cfg(test)]
 mod tests {
-    use crate::{tests::CityVertex, QuickFind, UnionFind};
+    use crate::{rng::PhantomRng, tests::CityVertex, Borrowed, QuickFind, UnionFind};
     use core::{mem, panic};
 
     #[test]
@@ -113,7 +145,7 @@ mod tests {
     #[test]
     fn test_qf_slice() {
         let mut representative = (0..10).collect::<heapless::Vec<_, 10>>();
-        let mut uf = UnionFind::<QuickFind<true>, u32, 10>::new(representative.as_mut());
+        let mut uf = UnionFind::<QuickFind<Borrowed>, u32, 10>::new(representative.as_mut());
         uf.union_sets(4, 3);
         uf.union_sets(3, 8);
         uf.union_sets(6, 5);
@@ -137,6 +169,7 @@ mod tests {
                 representative: cities,
                 heuristic: [0; 0],
                 algorithm: Default::default(),
+                rng: PhantomRng,
             })
         }
     }
@@ -169,7 +202,7 @@ mod tests {
         );
         assert_eq!(
             mem::size_of::<&'_ [u32]>(),
-            mem::size_of::<UnionFind::<'_, QuickFind<true>, u32, 10>>()
+            mem::size_of::<UnionFind::<'_, QuickFind<Borrowed>, u32, 10>>()
         );
         assert_eq!(
             mem::size_of::<[CityVertex<'_>; 10]>(),