hibit_tree 0.1.0-beta.1

Hierarchical bitmap tree. Integer-key map that can intersect FAST.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

//#![feature(closure_lifetime_binder)]

use itertools::assert_equal;
use rand::{Rng, SeedableRng};
use hibit_tree::{FromHibitTree, intersection, LazyHibitTree, map, union, Tree};
use hibit_tree::config::_64bit;
use hibit_tree::HibitTree;
use hibit_tree::RegularHibitTree;
use hibit_tree::utils::Borrowable;

mod common;

#[derive(Default, Clone, Ord, PartialOrd, Eq, PartialEq, Debug)]
struct Data(usize);

// TODO: common::Array<Data>
type Array = Tree<Data, _64bit<4>>;

#[test]
fn materialize_test(){
    const RANGE: usize = common::RANGE;
    const COUNT: usize = if cfg!(miri) {400} else {10000};

    let mut rng = rand::rngs::StdRng::seed_from_u64(0xe15bb9db3dee3a0f);
    
    let mut a1 = Array::default();
    let mut a2 = Array::default();
    for _ in 0..COUNT{
        let v = rng.gen_range(0..RANGE);
        a1.insert(v, Data(v));
        a2.insert(v, Data(v));
    }

    {
        let mut a1: Tree<usize, _64bit<4>> = Default::default();
        let i0 = 0;
        a1.insert(0, i0);
        
        let m1 = map(a1, |d: &usize| -> usize { d.clone() } );
        let m2 = map(m1, |d: usize| d.clone() );
        // let mut a2: CompactSparseArray<_, 4> = m2.materialize();
        
        /*fn test2<
            T: SparseHierarchy<LevelCount=ConstUsize<4>> 
        >(a: T)
            //-> CompactSparseArray<usize, 4>
        {
            let t = a.get(12);
            //a.materialize()
        }
        test2(a1);*/
        
        /*
        // This not work
        fn test<'a, T: Borrowable<Borrowed: SparseHierarchy<'a, LevelMaskType=u64, LevelCount=ConstUsize<4>, DataType=usize>>>(a: T)
            //-> CompactSparseArray<usize, 4>
        {
            a.borrow().get(12);
        }
        test(a1);
        */
        
        //let a1c: CompactSparseArray<_, 4> = m1.materialize();
        //v.push(&i0);
        
        //let u = intersection(&a1, &a1, |_, _| 1 );
        /*let m1 = map(a1, |v|v.clone());
        let m2 = map(&m1, |v|v.clone());
        let m3 = map(&m2, |v|v.clone());*/
        //intersection(u, &a2, |_, _|2);    
    }
    
    
    let ao: Array = map(&a1, |d: &Data| d.clone()).materialize();
    assert_equal(ao.iter(), a1.iter());
    
    let ao: Array = map(intersection(&a1, &a2), |(l, _r) : (&Data, &Data)| l.clone()).materialize();
    assert_equal(ao.iter(), a1.iter());
    
    let ao: Array = union(&a1, &a2)
        .map(|(l, _r) : (Option<&Data>, Option<&Data>)| l.unwrap().clone())
        .materialize();
    assert_equal(ao.iter(), a1.iter());
}