rustimizer 0.1.1

PoC for decision making in Rust. Disclaimer: The project's name was chosen with the help of an LLM.
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

//! This module implements the basic autoscaled vectorized variables.
use super::Name;
use super::Values;
use super::VariableProperties;
use super::scaling::autorescale_vector;

#[derive(Debug)]
pub struct VariableInvertedAutoscale {
    name: Name,
    values: Values,
}

impl VariableInvertedAutoscale {
    pub fn new(name: Name, values: Values) -> Self {
        Self { name, values }
    }
}

impl VariableProperties for VariableInvertedAutoscale {
    fn name(&self) -> &Name {
        &self.name
    }

    fn values(&self) -> &Values {
        &self.values
    }

    fn rescale(&self) -> Values {
        autorescale_vector(self.values(), true)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use approx::assert_ulps_eq;
    use ndarray::array;
    use std::convert::TryFrom;

    #[test]
    fn create_variable_with_single_value_and_rescale() {
        let var = VariableInvertedAutoscale::new(
            Name::try_from("x").unwrap(),
            Values::try_from(array![0.]).unwrap(),
        );
        assert_eq!(var.name(), "x");
        assert_eq!(var.rescale().values(), array![0.]);
    }

    #[test]
    fn create_variable_with_values_and_rescale() {
        let var = VariableInvertedAutoscale::new(
            Name::try_from("x").unwrap(),
            Values::try_from(array![0., 0.5, 1., 1.5]).unwrap(),
        );
        assert_eq!(var.name(), "x");
        assert_ulps_eq!(
            var.rescale().values(),
            array![1., 0.6666666666666667, 0.33333333333333337, 0.]
        );
    }
}