routee-compass-core 0.11.3

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
98
99
100
101
102
103
104
105
106
107
108
109

use super::{network::NetworkCostRate, CostAggregation, CostModelError, VehicleCostRate};
use crate::model::{network::Edge, state::StateVariable, unit::Cost};

/// steps through each state variable and assigns vehicle costs related to that variable
/// due to an edge access + traversal event.
///
/// # Arguments
/// * `prev_state` - the state before beginning the traversal
/// * `next_state` - the state after traversal
/// * `indices`    - feature names and corresponding state indices
pub fn calculate_vehicle_costs(
    state_sequence: (&[StateVariable], &[StateVariable]),
    indices: &[(String, usize)],
    weights: &[f64],
    rates: &[VehicleCostRate],
    cost_aggregation: &CostAggregation,
) -> Result<Cost, CostModelError> {
    let (prev_state, next_state) = state_sequence;
    let mut costs: Vec<(&String, Cost)> = vec![];
    for (name, state_idx) in indices.iter() {
        // compute delta
        let prev_state_var = prev_state
            .get(*state_idx)
            .ok_or_else(|| CostModelError::StateIndexOutOfBounds(*state_idx, name.clone()))?;
        let next_state_var = next_state
            .get(*state_idx)
            .ok_or_else(|| CostModelError::StateIndexOutOfBounds(*state_idx, name.clone()))?;
        let delta: StateVariable = *next_state_var - *prev_state_var;

        // collect weight and vehicle cost rate
        let mapping = rates.get(*state_idx).ok_or_else(|| {
            CostModelError::CostVectorOutOfBounds(*state_idx, String::from("vehicle_rates"))
        })?;
        let weight = weights.get(*state_idx).ok_or_else(|| {
            CostModelError::CostVectorOutOfBounds(*state_idx, String::from("weights"))
        })?;

        // compute cost

        if let Some(delta_cost) = mapping.map_value(delta) {
            costs.push((name, delta_cost * weight));
        }
    }

    cost_aggregation.aggregate(&costs)
}

pub fn calculate_network_traversal_costs(
    state_sequence: (&[StateVariable], &[StateVariable]),
    edge: &Edge,
    indices: &[(String, usize)],
    weights: &[f64],
    rates: &[NetworkCostRate],
    cost_aggregation: &CostAggregation,
) -> Result<Cost, CostModelError> {
    let (prev_state, next_state) = state_sequence;
    let mut costs: Vec<(&String, Cost)> = vec![];
    for (name, state_idx) in indices.iter() {
        let prev_state_var = prev_state
            .get(*state_idx)
            .ok_or_else(|| CostModelError::StateIndexOutOfBounds(*state_idx, name.clone()))?;
        let next_state_var = next_state
            .get(*state_idx)
            .ok_or_else(|| CostModelError::StateIndexOutOfBounds(*state_idx, name.clone()))?;

        // determine weight and access cost for this state feature
        let weight = weights.get(*state_idx).ok_or_else(|| {
            CostModelError::CostVectorOutOfBounds(*state_idx, String::from("weights"))
        })?;
        let rate = rates.get(*state_idx).ok_or_else(|| {
            CostModelError::CostVectorOutOfBounds(*state_idx, String::from("network_cost_rate"))
        })?;
        let access_cost = rate.traversal_cost(*prev_state_var, *next_state_var, edge)?;
        let cost = access_cost * weight;
        costs.push((name, cost));
    }

    cost_aggregation.aggregate(&costs)
}

pub fn calculate_network_access_costs(
    state_sequence: (&[StateVariable], &[StateVariable]),
    edge_sequence: (&Edge, &Edge),
    indices: &[(String, usize)],
    weights: &[f64],
    rates: &[NetworkCostRate],
    cost_aggregation: &CostAggregation,
) -> Result<Cost, CostModelError> {
    let (prev_state, next_state) = state_sequence;
    let (prev_edge, next_edge) = edge_sequence;
    let mut costs: Vec<(&String, Cost)> = vec![];
    for (name, idx) in indices.iter() {
        if let Some(m) = rates.get(*idx) {
            let prev_state_var = prev_state
                .get(*idx)
                .ok_or_else(|| CostModelError::StateIndexOutOfBounds(*idx, name.clone()))?;
            let next_state_var = next_state
                .get(*idx)
                .ok_or_else(|| CostModelError::StateIndexOutOfBounds(*idx, name.clone()))?;
            let access_cost =
                m.access_cost(*prev_state_var, *next_state_var, prev_edge, next_edge)?;
            let coefficient = weights.get(*idx).unwrap_or(&1.0);
            let cost = access_cost * coefficient;
            costs.push((name, cost));
        }
    }

    cost_aggregation.aggregate(&costs)
}