twisterl 0.5.1

Reinforcement learning primitives and a Python extension for high performance training and inference.
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

// -*- coding: utf-8 -*-
/* 
(C) Copyright 2025 IBM. All Rights Reserved.

This code is licensed under the Apache License, Version 2.0. You may
obtain a copy of this license in the LICENSE.txt file in the root directory
of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this code must retain this
copyright notice, and modified files need to carry a notice indicating
that they have been altered from the originals.
*/

pub struct Tree<T> {
    pub nodes: Vec<Node<T>>,
}

pub struct Node<T> {
    idx: usize,
    pub val: T,
    pub parent: Option<usize>,
    pub children: Vec<usize>,
}

impl<T> Node<T> {
    pub fn new(idx: usize, val: T) -> Self {
        Self {
            idx,
            val,
            parent: None,
            children: vec![],
        }
    }
}


impl<T> Tree<T> {
    pub fn new() -> Self {
        Self {nodes: vec![]}
    }

    pub fn new_node(&mut self, val: T) -> usize {
        let idx = self.nodes.len();
        self.nodes.push(Node::new(idx, val));
        idx
    }

    pub fn add_child_to_node(&mut self, val: T, idx: usize) -> usize {
        let child_idx = self.new_node(val);
        self.nodes[idx].children.push(child_idx);
        self.nodes[child_idx].parent = Some(idx);
        child_idx
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_tree_add_child() {
        let mut tree: Tree<i32> = Tree::new();
        let root = tree.new_node(1);
        let child = tree.add_child_to_node(2, root);

        assert_eq!(root, 0);
        assert_eq!(child, 1);
        assert_eq!(tree.nodes.len(), 2);
        assert_eq!(tree.nodes[root].children, vec![child]);
        assert_eq!(tree.nodes[child].parent, Some(root));
    }
}