simplify x_x_than_single checks from 4 to 3

Author: intarga

src/checks/consistency.rs

@@ -1,17 +1,14 @@
 mod greater_than;
 pub use greater_than::greater_than;
 
-mod min_greater_than_single;
-pub use min_greater_than_single::min_greater_than_single;
+mod single_greater_than_min;
+pub use single_greater_than_min::single_greater_than_min;
 
-mod max_greater_than_single;
-pub use max_greater_than_single::max_greater_than_single;
+mod single_less_than_max;
+pub use single_less_than_max::single_less_than_max;
 
-mod min_less_than_single;
-pub use min_less_than_single::min_less_than_single;
-
-mod max_less_than_single;
-pub use max_less_than_single::max_less_than_single;
+mod single_outside_sequence;
+pub use single_outside_sequence::single_outside_sequence;
 
 mod not_equal;
 pub use not_equal::not_equal;

src/checks/consistency/max_greater_than_single.rs

@@ -1,16 +1,16 @@
 use crate::Flag;
 
-/// Compares a single value to a higher resolution sequence, where the minimum value in the
-/// sequence (including an adjustment) should never be greater than the single value
+/// Compares a single value to a higher resolution sequence, where the single value should never
+/// be greater than the minimum value in the sequence (including an adjustment)
 ///
 /// Returns:
 /// - [`Flag::DataMissing`] if the single value is missing,
-/// - [`Flag::Fail`] if this invariant is broken (i.e the minimum of the sequence, plus the
-///   adjustment, is greater than the single value),
+/// - [`Flag::Fail`] if this invariant is broken (i.e the single value is greater than the minimum
+///   of the sequence plus the adjustment),
 /// - [`Flag::DataMissing`] if any of the elements is missing, as we cannot be sure a missing data
 ///   point did not violate the invariant.
 /// - [`Flag::Pass`] otherwise.
-pub fn min_greater_than_single(
+pub fn single_greater_than_min(
     single: Option<f32>,
     sequence: &[Option<f32>],
     adjustment: f32,
@@ -46,12 +46,12 @@ pub fn min_greater_than_single(
         }
     };
 
-    if min + adjustment > single {
+    if single > min + adjustment {
         // if this condition evaluates to true, the invariant was invalidated
         Flag::Fail
     } else if missing {
         // if the condition was not met, but there was missing data in the sequence, we cannot say
-        // for sure that the invariant wasn't validated
+        // for sure that the invariant wasn't invalidated
         Flag::DataMissing
     } else {
         Flag::Pass
@@ -63,22 +63,22 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_min_greater_than_single() {
+    fn test_single_greater_than_min() {
         assert_eq!(
-            min_greater_than_single(Some(1.), &[Some(1.), Some(2.), Some(2.)], 0.2),
-            Flag::Fail
-        );
-        assert_eq!(
-            min_greater_than_single(Some(1.), &[Some(1.), Some(2.), Some(2.)], -0.2),
+            single_greater_than_min(Some(1.), &[Some(1.), Some(2.), Some(2.)], 0.2),
             Flag::Pass
         );
         assert_eq!(
-            min_greater_than_single(Some(1.), &[Some(1.), None, Some(2.)], -0.2),
-            Flag::DataMissing
+            single_greater_than_min(Some(1.), &[Some(1.), Some(2.), Some(2.)], -0.2),
+            Flag::Fail
         );
         assert_eq!(
-            min_greater_than_single(Some(1.), &[Some(1.), None, Some(2.)], 0.2),
+            single_greater_than_min(Some(1.), &[Some(1.), None, Some(2.)], -0.2),
             Flag::Fail
         );
+        assert_eq!(
+            single_greater_than_min(Some(1.), &[Some(1.), None, Some(2.)], 0.2),
+            Flag::DataMissing
+        );
     }
 }

src/checks/consistency/min_less_than_single.rs

@@ -1,16 +1,16 @@
 use crate::Flag;
 
-/// Compares a single value to a higher resolution sequence, where the maximum value in the
-/// sequence (including an adjustment) should never be less than the single value
+/// Compares a single value to a higher resolution sequence, where the single value should never
+/// be less than the maximum value in the sequence (including an adjustment)
 ///
 /// Returns:
 /// - [`Flag::DataMissing`] if the single value is missing,
-/// - [`Flag::Fail`] if this invariant is broken (i.e the maximum of the sequence, plus the
-///   adjustment, is less than the single value),
+/// - [`Flag::Fail`] if this invariant is broken (i.e the single value is less than the maximum
+///   of the sequence plus the adjustment),
 /// - [`Flag::DataMissing`] if any of the elements is missing, as we cannot be sure a missing data
 ///   point did not violate the invariant.
 /// - [`Flag::Pass`] otherwise.
-pub fn max_less_than_single(
+pub fn single_less_than_max(
     single: Option<f32>,
     sequence: &[Option<f32>],
     adjustment: f32,
@@ -46,12 +46,12 @@ pub fn max_less_than_single(
         }
     };
 
-    if max + adjustment < single {
+    if single < max + adjustment {
         // if this condition evaluates to true, the invariant was invalidated
         Flag::Fail
     } else if missing {
         // if the condition was not met, but there was missing data in the sequence, we cannot say
-        // for sure that the invariant wasn't validated
+        // for sure that the invariant wasn't invalidated
         Flag::DataMissing
     } else {
         Flag::Pass
@@ -63,22 +63,22 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_max_less_than_single() {
+    fn test_single_less_than_max() {
         assert_eq!(
-            max_less_than_single(Some(1.), &[Some(1.), Some(0.), Some(0.)], 0.2),
-            Flag::Pass
-        );
-        assert_eq!(
-            max_less_than_single(Some(1.), &[Some(1.), Some(0.), Some(0.)], -0.2),
+            single_less_than_max(Some(1.), &[Some(1.), Some(0.), Some(0.)], 0.2),
             Flag::Fail
         );
         assert_eq!(
-            max_less_than_single(Some(1.), &[Some(1.), None, Some(0.)], -0.2),
-            Flag::Fail
+            single_less_than_max(Some(1.), &[Some(1.), Some(0.), Some(0.)], -0.2),
+            Flag::Pass
         );
         assert_eq!(
-            max_less_than_single(Some(1.), &[Some(1.), None, Some(0.)], 0.2),
+            single_less_than_max(Some(1.), &[Some(1.), None, Some(0.)], -0.2),
             Flag::DataMissing
         );
+        assert_eq!(
+            single_less_than_max(Some(1.), &[Some(1.), None, Some(0.)], 0.2),
+            Flag::Fail
+        );
     }
 }