icentral_distances/
distances.rs

1crate::ix!();
2
3pub const INFINITE_DISTANCE: f64 = f64::MAX;
4
5#[derive(Clone,Debug)]
6pub struct DistanceMap {
7    name: String,
8    data: MaybeIndexedMap<f64>,
9}
10
11impl Default for DistanceMap {
12    fn default() -> Self {
13        Self::empty("default_distance_map")
14    }
15}
16
17impl CreateNamedEmpty for DistanceMap {
18
19    fn empty(name: &str) -> Self 
20    {
21        Self::empty_mapped(name)
22    }
23}
24
25impl DistanceMap {
26
27    pub fn new_from_nodes(nodes: Vec<NodeId>, name: &str) -> Self 
28    {
29        debug!("creating new DistanceMap named {} from {} nodes", name, nodes.len());
30
31        let mut builder = Self::empty_mapped(name);
32
33        for node in nodes {
34
35            builder.set_distance_for_node(
36                node,
37                INFINITE_DISTANCE
38            );
39        }
40
41        builder
42    }
43
44    pub fn empty_indexed(name: &str) -> Self 
45    {
46        debug!("creating new empty_indexed DistanceMap named {}", name);
47
48        Self {
49            name: name.to_owned(),
50            data: MaybeIndexedMap::empty_indexed()
51        }
52    }
53
54    pub fn empty_mapped(name: &str) -> Self 
55    {
56        debug!("creating new empty_mapped DistanceMap named {}", name);
57
58        Self {
59            name: name.to_owned(),
60            data: MaybeIndexedMap::empty_mapped()
61        }
62    }
63
64    pub fn new(len: usize, name: &str) -> Self 
65    {
66        debug!("creating new DistanceMap named {} of len: {}", name, len);
67
68        Self {
69            name: name.to_owned(),
70            data: MaybeIndexedMap::new(len,INFINITE_DISTANCE),
71        }
72    }
73
74    pub fn v_closer_than_u(
75        &self, 
76        v: NodeId, 
77        u: NodeId) -> bool 
78    {
79        debug!("in {}, checking if v={} is closer than u={}", self.name, v, u);
80
81        self.distance(v) < self.distance(u)
82    }
83
84    pub fn len(&self) -> usize 
85    {
86        self.data.len()
87    }
88
89    pub fn is_farther_away(&self, v: NodeId, u: NodeId) -> bool 
90    {
91        debug!("in {}, checking if v={} is farther away than u={}", self.name, v, u);
92
93        self.data[v] > self.data[u]
94    }
95
96    pub fn is_farther_than_one_away(&self, v: NodeId, u: NodeId) -> bool 
97    {
98        debug!("in {}, checking if v={} is farther than one away than u={}", self.name, v, u);
99
100        self.data[v] > (self.data[u] + 1.0)
101    }
102
103    pub fn is_one_step_away(&self, v: NodeId, u: NodeId) -> bool 
104    {
105        debug!("in {}, checking if v={} is one step away from u={}", self.name, v, u);
106
107        self.data[v] == (self.data[u] + 1.0)
108    }
109
110    pub fn is_infinite(&self, node: NodeId) -> bool 
111    {
112        let result = self.distance(node) == INFINITE_DISTANCE;
113
114        debug!("in {}, checking if the distance to node {} is INFINITE (or possibly unmapped) -- found {}", self.name, node, result);
115
116        result
117    }
118
119    pub fn distance(&self, node: NodeId) -> f64 
120    {
121        self.data[node]
122    }
123
124    pub fn distance_ref(&self, node: NodeId)
125    -> &f64 
126    {
127        &self.data[node]
128    }
129
130    pub fn distance_mut(&mut self, node: NodeId)
131    -> &mut f64 
132    {
133        &mut self.data[node]
134    }
135
136    pub fn set_distance_for_node(&mut self, node: NodeId, val: f64) 
137    {
138        debug!("in {}, setting distance for node {} to {}", self.name, node, val);
139
140        self.data.set(node, val);
141    }
142
143    pub fn insert_node_at_infinite_distance(&mut self, node: NodeId) 
144    {
145        self.set_distance_for_node(node,INFINITE_DISTANCE);
146    }
147
148    pub fn set_one_step_away(
149        &mut self, 
150        dst: NodeId,
151        src: NodeId) 
152    {
153        self.set_distance_for_node(dst, self.data[src] + 1.0);
154    }
155
156    pub fn set_zero_distance(&mut self, source: NodeId) 
157    {
158        self.set_distance_for_node(source, 0.0);
159    }
160
161    pub fn reinit(&mut self, len: usize) 
162    {
163        debug!("reinitializing DistanceMap {} to len {}", self.name, len);
164
165        self.data.refill(len,INFINITE_DISTANCE);
166    }
167}
icentral_distances/distances.rs

icentral_distances/
distances.rs
