ommx 2.5.1

Open Mathematical prograMming eXchange (OMMX)
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

use super::*;
use crate::{v1, Message, Parse};
use anyhow::Result;

impl NamedFunction {
    pub fn to_bytes(&self) -> Vec<u8> {
        let v1_named_function = v1::NamedFunction::from(self.clone());
        v1_named_function.encode_to_vec()
    }

    pub fn from_bytes(bytes: &[u8]) -> Result<Self> {
        let inner = v1::NamedFunction::decode(bytes)?;
        Ok(Parse::parse(inner, &())?)
    }
}

impl EvaluatedNamedFunction {
    pub fn to_bytes(&self) -> Vec<u8> {
        let v1_evaluated_named_function = v1::EvaluatedNamedFunction::from(self.clone());
        v1_evaluated_named_function.encode_to_vec()
    }

    pub fn from_bytes(bytes: &[u8]) -> Result<Self> {
        let inner = v1::EvaluatedNamedFunction::decode(bytes)?;
        Ok(Parse::parse(inner, &())?)
    }
}

impl SampledNamedFunction {
    pub fn to_bytes(&self) -> Vec<u8> {
        let v1_sampled_named_function = v1::SampledNamedFunction::from(self.clone());
        v1_sampled_named_function.encode_to_vec()
    }

    pub fn from_bytes(bytes: &[u8]) -> Result<Self> {
        let inner = v1::SampledNamedFunction::decode(bytes)?;
        Ok(Parse::parse(inner, &())?)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{Coefficient, Function};

    #[test]
    fn test_named_function_bytes_roundtrip() {
        let nf = NamedFunction {
            id: NamedFunctionID::from(5),
            function: Function::Constant(Coefficient::try_from(3.14).unwrap()),
            name: Some("test_func".to_string()),
            subscripts: vec![1, 2, 3],
            parameters: {
                let mut params = fnv::FnvHashMap::default();
                params.insert("key".to_string(), "value".to_string());
                params
            },
            description: Some("roundtrip test".to_string()),
        };

        let bytes = nf.to_bytes();
        let restored = NamedFunction::from_bytes(&bytes).unwrap();

        assert_eq!(nf, restored);
    }

    #[test]
    fn test_evaluated_named_function_bytes_roundtrip() {
        let enf = EvaluatedNamedFunction {
            id: NamedFunctionID::from(10),
            evaluated_value: 99.5,
            name: Some("eval_func".to_string()),
            subscripts: vec![4, 5],
            parameters: Default::default(),
            description: Some("evaluated roundtrip".to_string()),
            used_decision_variable_ids: [crate::VariableID::from(1), crate::VariableID::from(2)]
                .into_iter()
                .collect(),
        };

        let bytes = enf.to_bytes();
        let restored = EvaluatedNamedFunction::from_bytes(&bytes).unwrap();

        assert_eq!(enf, restored);
    }

    #[test]
    fn test_sampled_named_function_bytes_roundtrip() {
        let mut evaluated_values = crate::Sampled::default();
        evaluated_values
            .append([crate::SampleID::from(0)], 1.0)
            .unwrap();
        evaluated_values
            .append([crate::SampleID::from(1)], 2.0)
            .unwrap();

        let snf = SampledNamedFunction {
            id: NamedFunctionID::from(15),
            evaluated_values,
            name: Some("sampled_func".to_string()),
            subscripts: vec![7, 8, 9],
            parameters: {
                let mut params = fnv::FnvHashMap::default();
                params.insert("sample_key".to_string(), "sample_value".to_string());
                params
            },
            description: Some("sampled roundtrip".to_string()),
            used_decision_variable_ids: [crate::VariableID::from(3), crate::VariableID::from(4)]
                .into_iter()
                .collect(),
        };

        let bytes = snf.to_bytes();
        let restored = SampledNamedFunction::from_bytes(&bytes).unwrap();

        assert_eq!(snf, restored);
    }
}