routee-compass-core 0.19.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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use self::internal_float::InternalFloat;
use crate::model::unit::{AsF64, *};
use allocative::Allocative;
use derive_more::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign, Sum};
use serde::{Deserialize, Serialize};
use std::{
    fmt::Display,
    ops::{Deref, DerefMut},
};

/// Represents the cost for traversing a graph edge.
/// A cost does not carry any units but can be built from a unit type like [`Time`] or [`Energy`]  

#[derive(
    Copy,
    Clone,
    Debug,
    Eq,
    PartialEq,
    PartialOrd,
    Ord,
    Add,
    AddAssign,
    Sub,
    SubAssign,
    Mul,
    MulAssign,
    Div,
    DivAssign,
    Sum,
    Neg,
    Serialize,
    Deserialize,
    Allocative,
)]
pub struct Cost(InternalFloat);

impl Cost {
    /// represents zero cost, unit of addition operation
    pub const ZERO: Cost = Cost(InternalFloat::ZERO);

    /// represents one cost, unit of multiplication operation
    pub const ONE: Cost = Cost(InternalFloat::ONE);

    /// represents the maximum possible cost
    pub const INFINITY: Cost = Cost(InternalFloat::INFINITY);

    /// when path search costs must be strictly positive, this value
    /// is used as a sentinel in place of non-positive costs
    pub const MIN_COST: Cost = Cost(InternalFloat::MIN);

    /// helper to construct a Cost from an f64
    pub fn new(value: f64) -> Cost {
        Cost(InternalFloat::new(value))
    }

    /// helper to enforce costs that are strictly positive
    pub fn enforce_strictly_positive(cost: Cost) -> Cost {
        if cost <= Cost::ZERO {
            Cost::MIN_COST
        } else {
            cost
        }
    }

    /// helper to enforce costs that are zero or greater
    pub fn enforce_non_negative(cost: Cost) -> Cost {
        if cost < Cost::ZERO {
            Cost::ZERO
        } else {
            cost
        }
    }
}

impl Default for Cost {
    fn default() -> Self {
        Cost::ZERO
    }
}

impl From<f64> for Cost {
    fn from(f: f64) -> Self {
        Cost(InternalFloat::new(f))
    }
}

impl AsF64 for Cost {
    fn as_f64(&self) -> f64 {
        self.0 .0
    }
}

impl From<Cost> for f64 {
    fn from(val: Cost) -> Self {
        val.0.into_inner()
    }
}

impl Display for Cost {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{:?}", self.0)
    }
}

#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Serialize, Deserialize)]
pub struct ReverseCost(std::cmp::Reverse<Cost>);

impl From<Cost> for ReverseCost {
    fn from(cost: Cost) -> Self {
        ReverseCost(std::cmp::Reverse(cost))
    }
}

impl Allocative for ReverseCost {
    fn visit<'a, 'b: 'a>(&self, visitor: &'a mut allocative::Visitor<'b>) {
        let _visitor = visitor.enter_self_sized::<Self>();
    }
}

impl Deref for ReverseCost {
    type Target = std::cmp::Reverse<Cost>;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl DerefMut for ReverseCost {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}