orx-tree 2.2.0

A beautiful tree 🌳 with convenient, efficient, parallelizable growth, mutation and traversal features.
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

// cargo run --release --features parallel --example demo_parallelization

use orx_tree::*;

fn build_tree(total_depth: usize, num_children: usize) -> DynTree<String> {
    let mut tree = DynTree::new(0.to_string());
    let mut dfs = Traversal.dfs().over_nodes();

    for _ in 0..total_depth {
        let root = tree.root();
        let leaves: Vec<_> = root.leaves_with(&mut dfs).map(|x| x.idx()).collect();
        for idx in leaves {
            let count = tree.len();
            let mut node = tree.node_mut(idx);
            for j in 0..num_children {
                node.push_child((count + j).to_string());
            }
        }
    }

    tree
}

fn main() {
    let input = build_tree(10, 4);
    let expected_num_characters = 5234569;

    // computation using iterators

    let total_num_characters: usize = input
        .iter()
        .filter(|x| !x.starts_with('1'))
        .map(|x| x.len())
        .sum();
    assert_eq!(total_num_characters, expected_num_characters);

    #[cfg(feature = "parallel")]
    {
        // computation using parallel iterator: replace `iter()` with `par()`

        let total_num_characters: usize = input
            .par()
            .filter(|x| !x.starts_with('1'))
            .map(|x| x.len())
            .sum();
        assert_eq!(total_num_characters, expected_num_characters);

        // configure parallel computation
        let total_num_characters: usize = input
            .par()
            .filter(|x| !x.starts_with('1'))
            .num_threads(2)
            .chunk_size(64)
            .map(|x| x.len())
            .sum();
        assert_eq!(total_num_characters, expected_num_characters);

        // consuming parallel iterator: replace `into_iter` with `into_par`
        let total_num_characters: usize = input
            .into_par()
            .filter(|x| !x.starts_with('1'))
            .map(|x| x.len())
            .sum();
        assert_eq!(total_num_characters, expected_num_characters);
    }
}