routee-compass-core 0.6.0

The core routing algorithms and data structures of the RouteE-Compass energy-aware routing engine
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

use super::{
    network::network_cost_rate::NetworkCostRate, vehicle::vehicle_cost_rate::VehicleCostRate,
};
use crate::model::{
    cost::cost_error::CostError, property::edge::Edge, traversal::state::state_variable::StateVar,
    unit::Cost,
};
use std::{collections::HashMap, sync::Arc};

pub fn calculate_vehicle_costs<'a>(
    prev_state: &'a [StateVar],
    next_state: &'a [StateVar],
    state_variable_indices: &'a [(String, usize)],
    state_variable_coefficients: Arc<HashMap<String, f64>>,
    rates: Arc<HashMap<String, VehicleCostRate>>,
) -> Result<Vec<(&'a String, Cost)>, CostError> {
    let costs = state_variable_indices
        .iter()
        .map(|(name, idx)| {
            let prev_state_var = prev_state
                .get(*idx)
                .ok_or_else(|| CostError::StateIndexOutOfBounds(*idx, name.clone()))?;
            let next_state_var = next_state
                .get(*idx)
                .ok_or_else(|| CostError::StateIndexOutOfBounds(*idx, name.clone()))?;
            let delta: StateVar = *next_state_var - *prev_state_var;
            let mapping = rates
                .get(name)
                .ok_or_else(|| CostError::StateVariableNotFound(name.clone()))?;
            let coefficient = state_variable_coefficients.get(name).unwrap_or(&1.0);
            let delta_cost = mapping.map_value(delta);
            let cost = delta_cost * coefficient;
            Ok((name, cost))
        })
        .collect::<Result<Vec<_>, CostError>>()?;
    Ok(costs)
}

pub fn calculate_network_traversal_costs<'a>(
    prev_state: &'a [StateVar],
    next_state: &'a [StateVar],
    edge: &'a Edge,
    state_variable_indices: &'a [(String, usize)],
    state_variable_coefficients: Arc<HashMap<String, f64>>,
    rates: Arc<HashMap<String, NetworkCostRate>>,
) -> Result<Vec<(&'a String, Cost)>, CostError> {
    let costs = state_variable_indices
        .iter()
        .map(|(name, idx)| match rates.get(name) {
            None => Ok((name, Cost::ZERO)),
            Some(m) => {
                let prev_state_var = prev_state
                    .get(*idx)
                    .ok_or_else(|| CostError::StateIndexOutOfBounds(*idx, name.clone()))?;
                let next_state_var = next_state
                    .get(*idx)
                    .ok_or_else(|| CostError::StateIndexOutOfBounds(*idx, name.clone()))?;
                let coefficient = state_variable_coefficients.get(name).unwrap_or(&1.0);
                let traversal_cost = m.traversal_cost(*prev_state_var, *next_state_var, edge)?;
                let cost = traversal_cost * coefficient;
                Ok((name, cost))
            }
        })
        .collect::<Result<Vec<_>, CostError>>()?;
    Ok(costs)
}

pub fn calculate_network_access_costs<'a>(
    prev_state: &'a [StateVar],
    next_state: &'a [StateVar],
    prev_edge: &'a Edge,
    next_edge: &'a Edge,
    state_variable_indices: &'a [(String, usize)],
    state_variable_coefficients: Arc<HashMap<String, f64>>,
    rates: Arc<HashMap<String, NetworkCostRate>>,
) -> Result<Vec<(&'a String, Cost)>, CostError> {
    let costs = state_variable_indices
        .iter()
        .map(|(name, idx)| match rates.get(name) {
            None => Ok((name, Cost::ZERO)),
            Some(m) => {
                let prev_state_var = prev_state
                    .get(*idx)
                    .ok_or_else(|| CostError::StateIndexOutOfBounds(*idx, name.clone()))?;
                let next_state_var = next_state
                    .get(*idx)
                    .ok_or_else(|| CostError::StateIndexOutOfBounds(*idx, name.clone()))?;
                let access_cost =
                    m.access_cost(*prev_state_var, *next_state_var, prev_edge, next_edge)?;
                let coefficient = state_variable_coefficients.get(name).unwrap_or(&1.0);
                let cost = access_cost * coefficient;
                Ok((name, cost))
            }
        })
        .collect::<Result<Vec<_>, CostError>>()?;
    Ok(costs)
}