blob: 8b2fb3966812dd81565a1d79f3d715d80f94fd05 [file] [log] [blame] [edit]
extern crate petgraph;
extern crate rand;
use petgraph::unionfind::UnionFind;
use rand::{thread_rng, ChaChaRng, Rng, SeedableRng};
use std::collections::HashSet;
#[test]
fn uf_test() {
let n = 8;
let mut u = UnionFind::new(n);
for i in 0..n {
assert_eq!(u.find(i), i);
assert_eq!(u.find_mut(i), i);
assert!(!u.union(i, i));
}
u.union(0, 1);
assert_eq!(u.find(0), u.find(1));
u.union(1, 3);
u.union(1, 4);
u.union(4, 7);
assert_eq!(u.find(0), u.find(3));
assert_eq!(u.find(1), u.find(3));
assert!(u.find(0) != u.find(2));
assert_eq!(u.find(7), u.find(0));
u.union(5, 6);
assert_eq!(u.find(6), u.find(5));
assert!(u.find(6) != u.find(7));
// check that there are now 3 disjoint sets
let set = (0..n).map(|i| u.find(i)).collect::<HashSet<_>>();
assert_eq!(set.len(), 3);
}
#[test]
fn uf_test_checked() {
let n = 8;
let mut u = UnionFind::new(n);
for i in 0..n {
assert_eq!(u.try_find(i), Some(i));
assert_eq!(u.try_find_mut(i), Some(i));
assert_eq!(u.try_union(i, i), Ok(false));
}
assert!(u.try_union(0, 1).is_ok());
assert_eq!(u.try_find(0), u.try_find(1));
assert!(u.try_find(0).is_some());
assert!(u.try_union(1, 3).is_ok());
assert!(u.try_union(1, 4).is_ok());
assert!(u.try_union(4, 7).is_ok());
assert_eq!(u.try_find(0), u.try_find(3));
assert_eq!(u.try_find(1), u.try_find(3));
assert!(u.try_find(0).is_some());
assert!(u.try_find(1).is_some());
assert!(u.try_find(0) != u.try_find(2));
assert_eq!(u.try_find(7), u.try_find(0));
assert!(u.try_union(5, 6).is_ok());
assert_eq!(u.try_find(6), u.try_find(5));
assert!(u.try_find(6) != u.try_find(7));
// check that there are now 3 disjoint sets
let set = (0..n).map(|i| u.find(i)).collect::<HashSet<_>>();
assert_eq!(set.len(), 3);
}
#[test]
fn uf_test_with_equiv() {
let n = 8;
let mut u = UnionFind::new(n);
for i in 0..n {
assert_eq!(u.find(i), i);
assert_eq!(u.find_mut(i), i);
assert!(u.equiv(i, i));
}
u.union(0, 1);
assert!(u.equiv(0, 1));
u.union(1, 3);
u.union(1, 4);
u.union(4, 7);
assert!(u.equiv(0, 7));
assert!(u.equiv(1, 3));
assert!(!u.equiv(0, 2));
assert!(u.equiv(7, 0));
u.union(5, 6);
assert!(u.equiv(6, 5));
assert!(!u.equiv(6, 7));
// check that there are now 3 disjoint sets
let set = (0..n).map(|i| u.find(i)).collect::<HashSet<_>>();
assert_eq!(set.len(), 3);
}
#[test]
fn uf_test_with_checked_equiv() {
let n = 8;
let mut u = UnionFind::new(n);
for i in 0..n {
assert_eq!(u.find(i), i);
assert_eq!(u.find_mut(i), i);
assert_eq!(u.try_equiv(i, i), Ok(true));
}
u.union(0, 1);
assert_eq!(u.try_equiv(0, 1), Ok(true));
u.union(1, 3);
u.union(1, 4);
u.union(4, 7);
assert_eq!(u.try_equiv(0, 7), Ok(true));
assert_eq!(u.try_equiv(1, 3), Ok(true));
assert_eq!(u.try_equiv(0, 2), Ok(false));
assert_eq!(u.try_equiv(7, 0), Ok(true));
u.union(5, 6);
assert_eq!(u.try_equiv(6, 5), Ok(true));
assert_eq!(u.try_equiv(6, 7), Ok(false));
// check that there are now 3 disjoint sets
let set = (0..n).map(|i| u.find(i)).collect::<HashSet<_>>();
assert_eq!(set.len(), 3);
}
#[test]
fn uf_rand() {
let n = 1 << 14;
let mut rng = ChaChaRng::from_rng(thread_rng()).unwrap();
let mut u = UnionFind::new(n);
for _ in 0..100 {
let a = rng.gen_range(0, n);
let b = rng.gen_range(0, n);
let ar = u.find(a);
let br = u.find(b);
assert_eq!(ar != br, u.union(a, b));
}
}
#[test]
fn uf_u8() {
let n = 256;
let mut rng = ChaChaRng::from_rng(thread_rng()).unwrap();
let mut u = UnionFind::<u8>::new(n);
for _ in 0..(n * 8) {
let a = rng.gen();
let b = rng.gen();
let ar = u.find(a);
let br = u.find(b);
assert_eq!(ar != br, u.union(a, b));
}
}
#[test]
fn uf_u8_checked() {
let n = 256;
let mut rng = ChaChaRng::from_rng(thread_rng()).unwrap();
let mut u = UnionFind::<u8>::new(n);
for _ in 0..(n * 8) {
let a = rng.gen();
let b = rng.gen();
let ar = u.try_find(a).unwrap();
let br = u.try_find(b).unwrap();
assert_eq!(ar != br, u.try_union(a, b).unwrap());
}
}
#[test]
fn labeling() {
let mut u = UnionFind::<u32>::new(48);
for i in 0..24 {
u.union(i + 1, i);
}
for i in 25..47 {
u.union(i, i + 1);
}
u.union(23, 25);
u.union(24, 23);
let v = u.into_labeling();
assert!(v.iter().all(|x| *x == v[0]));
}
#[test]
fn uf_incremental() {
let mut u = UnionFind::<u32>::new_empty();
assert_eq!(u.new_set(), 0);
assert_eq!(u.new_set(), 1);
assert_eq!(u.len(), 2);
u.union(0, 1);
assert_eq!(u.find(0), u.find(1));
assert_eq!(u.new_set(), 2);
assert_eq!(u.new_set(), 3);
u.union(1, 3);
assert_eq!(u.new_set(), 4);
u.union(1, 4);
assert_eq!(u.new_set(), 5);
assert_eq!(u.new_set(), 6);
assert_eq!(u.new_set(), 7);
assert_eq!(u.len(), 8);
u.union(4, 7);
assert_eq!(u.find(0), u.find(3));
assert_eq!(u.find(1), u.find(3));
assert!(u.find(0) != u.find(2));
assert_eq!(u.find(7), u.find(0));
u.union(5, 6);
assert_eq!(u.find(6), u.find(5));
assert!(u.find(6) != u.find(7));
// check that there are now 3 disjoint sets
let set = (0..u.len() as u32)
.map(|i| u.find(i))
.collect::<HashSet<_>>();
assert_eq!(set.len(), 3);
}
#[test]
fn uf_test_out_of_bounds() {
let n = 8;
let mut u = UnionFind::new(n);
for i in 0..n {
u.find(i);
u.find_mut(i);
u.union(i, i);
}
assert!(u.try_find(50).is_none());
assert!(u.try_find_mut(50).is_none());
assert_eq!(u.try_union(1, 50), Err(50));
assert_eq!(u.try_union(50, 1), Err(50));
assert_eq!(u.try_union(30, 50), Err(30));
assert_eq!(u.try_union(50, 30), Err(50));
assert_eq!(u.try_equiv(1, 50), Err(50));
assert_eq!(u.try_equiv(50, 1), Err(50));
assert_eq!(u.try_equiv(30, 50), Err(30));
assert_eq!(u.try_equiv(50, 30), Err(50));
}