icentral-sigmas 0.1.0

A Rust library providing efficient management of sigma values for nodes in graph-based data structures. Includes traits for accessing and modifying sigma values, with a focus on performance and precision.
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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

crate::ix!();


#[macro_export] macro_rules! delegate_to_sigmas {
    ($ty:ty; $tag:ident) => {

        paste::item!{
            impl $ty {
                delegate! {
                    to self.$tag {

                        #[call(update)]
                        pub fn [<$tag _sigma_update>](&mut self, 
                            v_p:   NodeId, 
                            v_n:   NodeId, 
                            sp_sn: f64);

                        #[call(set_node_to_zero)]
                        pub fn [<$tag _sigma_set_node_to_zero>](&mut self, node: NodeId);

                        #[call(set_node_to_one)]
                        pub fn [<$tag _sigma_set_node_to_one>](&mut self, node: NodeId);

                        #[call(sigma_value_for_node)]
                        pub fn [<$tag _sigma_value_for_node>](&self, node: NodeId) -> f64;

                        #[call(set_sigma_value_for_node)]
                        pub fn [<$tag _set_sigma_value_for_node>](&mut self, node: NodeId, val: f64);

                        #[call(increment_sigma_value_for_node)]
                        pub fn [<$tag _increment_sigma_value_for_node>](&mut self, v_n: NodeId, c_t: f64);

                        #[call(reinit)]
                        pub fn [<reinit_ $tag>](&mut self, len: usize);

                        #[call(ratio)]
                        pub fn [< $tag _sigma_ratio >](&self, 
                            v_p: NodeId, 
                            v_n: NodeId) -> f64;

                        #[call(fill)]
                        pub fn [< $tag _fill_sigmas >](&mut self, val: f64);
                    }
                }
            }
        }
    };

    ($ty:ty) => {

        impl SetSigmaValueForNode for $ty {

            delegate! {
                to self.sigmas {
                    fn set_sigma_value_for_node(&mut self, node: NodeId, val: f64);
                }
            }
        }

        impl GetSigmaValueForNode for $ty {

            delegate! {
                to self.sigmas {
                    fn sigma_value_for_node(&self, node: NodeId) -> f64;
                }
            }
        }

        impl $ty {
            delegate! {
                to self.sigmas {

                    #[call(update)]
                    pub fn sigma_update(&mut self, 
                        v_p:   NodeId, 
                        v_n:   NodeId, 
                        sp_sn: f64);

                    #[call(set_node_to_zero)]
                    pub fn sigma_set_node_to_zero(&mut self, node: NodeId);

                    #[call(set_node_to_one)]
                    pub fn sigma_set_node_to_one(&mut self, node: NodeId);

                    pub fn increment_sigma_value_for_node(
                        &mut self, 
                        v_n: NodeId, 
                        c_t: f64
                    );

                    #[call(reinit)]
                    pub fn reinit_sigmas(&mut self, len: usize);

                    #[call(ratio)]
                    pub fn sigma_ratio(&self, 
                        v_p: NodeId, 
                        v_n: NodeId) -> f64;

                    #[call(fill)]
                    pub fn fill_sigmas(&mut self, val: f64);
                }
            }
        }
    };
}