floccus 0.3.7

Formulae for air thermodynamic calculations
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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198

use crate::errors::InputError;
use crate::Float;
use float_cmp::assert_approx_eq;
use std::mem::discriminant;

#[derive(Copy, Clone, Debug, Default)]
pub struct Argument {
    pub name: &'static str,
    pub def_val: Float,
    pub range: [Float; 2],
}

//due to a bug [https://github.com/rust-lang/rust/issues/46379]
//cargo flags those functions as a dead code even though
//they are used in tests
#[allow(dead_code)]
//this function should work as a reference for other test functions below
pub fn test_with_2args(
    tested_function: &dyn Fn(Float, Float) -> Result<Float, InputError>,
    arg1: Argument,
    arg2: Argument,
    expected_result: Float,
) -> bool {
    //the first promise of the crate is that returned value
    //is calculated correctly
    let result = tested_function(arg1.def_val, arg2.def_val).unwrap();
    assert_approx_eq!(Float, result, expected_result, epsilon = 0.01);

    //the second promise of the crate is to never return NaN or Inf
    //here we check several edge cases for that
    //the function can only return a finite number or InputError
    //check for error implicit as Result<> ensures that if value
    //is not Ok() then it is Err()
    //here we don't care about error being correct
    let results = vec![
        tested_function(0.0, arg2.def_val),
        tested_function(arg1.def_val, 0.0),
        tested_function(0.0, 0.0),
    ];

    for result in results {
        if result.is_ok() {
            assert!(result.unwrap().is_finite());
        }
    }

    //the third promise of the crate is to always return finite f64
    //if all inputs are within the range
    //the only allowed error is InccorectArgumentsSet as it can occur
    //for values within valid range
    for arg1_itr in 0..=100 {
        for arg2_itr in 0..=100 {
            let arg1_tmp =
                (((arg1.range[1] - arg1.range[0]) / 100.0) * arg1_itr as Float) + arg1.range[0];
            let arg2_tmp =
                (((arg2.range[1] - arg2.range[0]) / 100.0) * arg2_itr as Float) + arg2.range[0];

            let result = tested_function(arg1_tmp, arg2_tmp);

            if result.is_err() {
                assert!(
                    discriminant(&InputError::IncorrectArgumentSet(String::from("")))
                        == discriminant(&result.unwrap_err())
                );
            } else {
                assert!(result.unwrap().is_finite());
            }
        }
    }

    //the fourth promise of the crate is to return an error with
    //erronous variable name when input is out of range
    let expected = InputError::OutOfRange(String::from(arg1.name));
    let result = tested_function(arg1.range[0] - 0.1, arg2.def_val).unwrap_err();
    assert_eq!(result, expected);
    let result = tested_function(arg1.range[1] + 0.1, arg2.def_val).unwrap_err();
    assert_eq!(result, expected);

    let expected = InputError::OutOfRange(String::from(arg2.name));
    let result = tested_function(arg1.def_val, arg2.range[0] - 0.1).unwrap_err();
    assert_eq!(result, expected);
    let result = tested_function(arg1.def_val, arg2.range[1] + 0.1).unwrap_err();
    assert_eq!(result, expected);

    true
}

#[allow(dead_code)]
pub fn test_with_1arg(
    tested_function: &dyn Fn(Float) -> Result<Float, InputError>,
    arg1: Argument,
    expected_result: Float,
) -> bool {
    let result = tested_function(arg1.def_val).unwrap();
    assert_approx_eq!(Float, result, expected_result, epsilon = 0.01);

    let results = vec![tested_function(0.0)];

    for result in results {
        if result.is_ok() {
            assert!(result.unwrap().is_finite());
        }
    }

    for arg1_itr in 0..=100 {
        let arg1_tmp =
            (((arg1.range[1] - arg1.range[0]) / 100.0) * arg1_itr as Float) + arg1.range[0];

        let result = tested_function(arg1_tmp);

        if result.is_err() {
            assert!(
                discriminant(&InputError::IncorrectArgumentSet(String::from("")))
                    == discriminant(&result.unwrap_err())
            );
        } else {
            assert!(result.unwrap().is_finite());
        }
    }

    let expected = InputError::OutOfRange(String::from(arg1.name));
    let result = tested_function(arg1.range[0] - 0.1).unwrap_err();
    assert_eq!(result, expected);
    let result = tested_function(arg1.range[1] + 0.1).unwrap_err();
    assert_eq!(result, expected);

    true
}

#[allow(dead_code)]
pub fn test_with_3args(
    tested_function: &dyn Fn(Float, Float, Float) -> Result<Float, InputError>,
    arg1: Argument,
    arg2: Argument,
    arg3: Argument,
    expected_result: Float,
) -> bool {
    let result = tested_function(arg1.def_val, arg2.def_val, arg3.def_val).unwrap();
    assert_approx_eq!(Float, result, expected_result, epsilon = 0.01);

    let results = vec![
        tested_function(0.0, arg2.def_val, arg3.def_val),
        tested_function(arg1.def_val, 0.0, arg3.def_val),
        tested_function(arg1.def_val, arg2.def_val, 0.0),
        tested_function(0.0, 0.0, 0.0),
    ];

    for result in results {
        if result.is_ok() {
            assert!(result.unwrap().is_finite());
        }
    }

    for arg1_itr in 0..=100 {
        for arg2_itr in 0..=100 {
            for arg3_itr in 0..=100 {
                let arg1_tmp =
                    (((arg1.range[1] - arg1.range[0]) / 100.0) * arg1_itr as Float) + arg1.range[0];
                let arg2_tmp =
                    (((arg2.range[1] - arg2.range[0]) / 100.0) * arg2_itr as Float) + arg2.range[0];
                let arg3_tmp =
                    (((arg3.range[1] - arg3.range[0]) / 100.0) * arg3_itr as Float) + arg3.range[0];

                let result = tested_function(arg1_tmp, arg2_tmp, arg3_tmp);

                if result.is_err() {
                    assert!(
                        discriminant(&InputError::IncorrectArgumentSet(String::from("")))
                            == discriminant(&result.unwrap_err())
                    );
                } else {
                    println!("{} {} {} {:?}", arg1_tmp, arg2_tmp, arg3_tmp, result);
                    assert!(result.unwrap().is_finite());
                }
            }
        }
    }

    let expected = InputError::OutOfRange(String::from(arg1.name));
    let result = tested_function(arg1.range[0] - 0.1, arg2.def_val, arg3.def_val).unwrap_err();
    assert_eq!(result, expected);
    let result = tested_function(arg1.range[1] + 0.1, arg2.def_val, arg3.def_val).unwrap_err();
    assert_eq!(result, expected);

    let expected = InputError::OutOfRange(String::from(arg2.name));
    let result = tested_function(arg1.def_val, arg2.range[0] - 0.1, arg3.def_val).unwrap_err();
    assert_eq!(result, expected);
    let result = tested_function(arg1.def_val, arg2.range[1] + 0.1, arg3.def_val).unwrap_err();
    assert_eq!(result, expected);

    let expected = InputError::OutOfRange(String::from(arg3.name));
    let result = tested_function(arg1.def_val, arg2.def_val, arg3.range[0] - 0.1).unwrap_err();
    assert_eq!(result, expected);
    let result = tested_function(arg1.def_val, arg2.def_val, arg3.range[1] + 0.1).unwrap_err();
    assert_eq!(result, expected);

    true
}