Change f32 to f64

Author: Lun4m

src/checks/consistency/greater_than.rs

@@ -7,7 +7,7 @@ use crate::{ConsistencyCache, Error, Flag, Timeseries, TimeseriesPair};
 /// - [`Flag::DataMissing`] if either datum is missing,
 /// - [`Flag::Fail`] if datum1 + datum1_correction > datum2,
 /// - [`Flag::Pass`] otherwise.
-pub fn greater_than(datum1: Option<f32>, datum2: Option<f32>, datum1_correction: f32) -> Flag {
+pub fn greater_than(datum1: Option<f64>, datum2: Option<f64>, datum1_correction: f64) -> Flag {
     if datum1.is_none() || datum2.is_none() {
         return Flag::DataMissing;
     }
@@ -29,7 +29,7 @@ pub fn greater_than(datum1: Option<f32>, datum2: Option<f32>, datum1_correction:
 /// - `cache.ratio` is not 1
 pub fn greater_than_cache(
     cache: &ConsistencyCache,
-    correction: f32,
+    correction: f64,
 ) -> Result<Vec<TimeseriesPair<Flag>>, Error> {
     if cache.ratio != 1 {
         return Err(Error::InvalidInputShape(String::from(

src/checks/consistency/not_equal.rs

@@ -10,7 +10,7 @@ use crate::{ConsistencyCache, Error, Flag, Timeseries, TimeseriesPair};
 /// - [`Flag::DataMissing`] if either datum is missing,
 /// - [`Flag::Fail`] if the difference between datum1 and datum2 is greater than threshold,
 /// - [`Flag::Pass`] otherwise.
-pub fn not_equal(datum1: Option<f32>, datum2: Option<f32>, threshold: f32) -> Flag {
+pub fn not_equal(datum1: Option<f64>, datum2: Option<f64>, threshold: f64) -> Flag {
     if datum1.is_none() || datum2.is_none() {
         return Flag::DataMissing;
     }
@@ -31,7 +31,7 @@ pub fn not_equal(datum1: Option<f32>, datum2: Option<f32>, threshold: f32) -> Fl
 /// - `cache.ratio` is not 1
 pub fn not_equal_cache(
     cache: &ConsistencyCache,
-    threshold: f32,
+    threshold: f64,
 ) -> Result<Vec<TimeseriesPair<Flag>>, Error> {
     if cache.ratio != 1 {
         return Err(Error::InvalidInputShape(String::from(

src/checks/consistency/single_greater_than_any.rs

@@ -18,9 +18,9 @@ use crate::{ConsistencyCache, Flag, Timeseries, TimeseriesPair};
 ///   plus the adjustment),
 /// - [`Flag::Pass`] otherwise.
 pub fn single_greater_than_any(
-    single: Option<f32>,
-    sequence: &[Option<f32>],
-    adjustment: f32,
+    single: Option<f64>,
+    sequence: &[Option<f64>],
+    adjustment: f64,
 ) -> (Flag, Vec<Flag>) {
     let single = match single {
         Some(value) => value,
@@ -67,7 +67,7 @@ pub fn single_greater_than_any(
 /// - `cache.ratio` is 0
 pub fn single_greater_than_any_cache(
     cache: &ConsistencyCache,
-    adjustment: f32,
+    adjustment: f64,
 ) -> Vec<TimeseriesPair<Flag>> {
     let num_series = cache.data.len();
     let mut result_vec = Vec::with_capacity(num_series);

src/checks/consistency/single_less_than_any.rs

@@ -18,9 +18,9 @@ use crate::{ConsistencyCache, Flag, Timeseries, TimeseriesPair};
 ///   plus the adjustment),
 /// - [`Flag::Pass`] otherwise.
 pub fn single_less_than_any(
-    single: Option<f32>,
-    sequence: &[Option<f32>],
-    adjustment: f32,
+    single: Option<f64>,
+    sequence: &[Option<f64>],
+    adjustment: f64,
 ) -> (Flag, Vec<Flag>) {
     let single = match single {
         Some(value) => value,
@@ -67,7 +67,7 @@ pub fn single_less_than_any(
 /// - `cache.ratio` is 0
 pub fn single_less_than_any_cache(
     cache: &ConsistencyCache,
-    adjustment: f32,
+    adjustment: f64,
 ) -> Vec<TimeseriesPair<Flag>> {
     let num_series = cache.data.len();
     let mut result_vec = Vec::with_capacity(num_series);

src/checks/consistency/single_outside_sequence.rs

@@ -11,9 +11,9 @@ use crate::{ConsistencyCache, Flag, Timeseries, TimeseriesPair};
 ///   point did not satisfy the invariant.
 /// - [`Flag::Fail`] otherwise.
 pub fn single_outside_sequence(
-    single: Option<f32>,
-    sequence: &[Option<f32>],
-    adjustment: f32,
+    single: Option<f64>,
+    sequence: &[Option<f64>],
+    adjustment: f64,
 ) -> Flag {
     let single = match single {
         Some(value) => value,
@@ -25,7 +25,7 @@ pub fn single_outside_sequence(
     // indicating if any value was missing
     let (minmax, missing) = sequence.iter().fold(
         (None, false),
-        |acc: (Option<(f32, f32)>, bool), elem| match elem {
+        |acc: (Option<(f64, f64)>, bool), elem| match elem {
             // if the element wasn't missing...
             Some(value) => match acc.0 {
                 // set the minmax if there isn't already a minmax, or the element is lower
@@ -63,7 +63,7 @@ pub fn single_outside_sequence(
 /// - `cache.ratio` is 0
 pub fn single_outside_sequence_cache(
     cache: &ConsistencyCache,
-    adjustment: f32,
+    adjustment: f64,
 ) -> Vec<TimeseriesPair<Flag>> {
     let num_series = cache.data.len();
     let mut result_vec = Vec::with_capacity(num_series);

src/checks/series/flatline_check.rs

@@ -12,7 +12,7 @@ use crate::{util::Timeseries, DataCache, Error, Flag};
 /// - [`Flag::Invalid`] if `data` is empty,
 /// - [`Flag::Fail`] if all observations passed in are identical,
 /// - [`Flag::Pass`] otherwise.
-pub fn flatline_check(data: &[Option<f32>], threshold: f32) -> Flag {
+pub fn flatline_check(data: &[Option<f64>], threshold: f64) -> Flag {
     if data.contains(&None) {
         return Flag::DataMissing;
     }
@@ -45,7 +45,7 @@ pub fn flatline_check(data: &[Option<f32>], threshold: f32) -> Flag {
 pub fn flatline_check_cache(
     cache: &DataCache,
     num_points: u8,
-    threshold: f32,
+    threshold: f64,
 ) -> Result<Vec<Timeseries<Flag>>, Error> {
     let num_series = cache.data.len();
     let mut result_vec = Vec::with_capacity(cache.data.len());

src/checks/series/monotonic_decrease_check.rs

@@ -18,7 +18,7 @@ use crate::{DataCache, Error, Flag, Timeseries};
 /// - [`Flag::Fail`] if there are no increases between consecutive data points in the series
 ///   AND the total decrease over the series is within the given range
 /// - [`Flag::Pass`] otherwise.
-pub fn monotonic_decrease_check(data: &[Option<f32>], lower_limit: f32, upper_limit: f32) -> Flag {
+pub fn monotonic_decrease_check(data: &[Option<f64>], lower_limit: f64, upper_limit: f64) -> Flag {
     if data.is_empty() || data.iter().any(Option::is_none) {
         return Flag::DataMissing;
     }
@@ -65,8 +65,8 @@ pub fn monotonic_decrease_check(data: &[Option<f32>], lower_limit: f32, upper_li
 /// - data has `num_leading_points` or `num_trailing_points` < `window_size`
 pub fn monotonic_decrease_check_cache(
     cache: &DataCache,
-    lower_limit: f32,
-    upper_limit: f32,
+    lower_limit: f64,
+    upper_limit: f64,
     // TODO: should this maybe be a usize? would require changing the type of num_leading_points
     // in DataCache
     window_size: u8,
@@ -138,10 +138,10 @@ mod tests {
 
     #[test]
     fn test_monotonic_decrease_check() {
-        let decreasing_sequence: Vec<Option<f32>> = repeat(200.)
+        let decreasing_sequence: Vec<Option<f64>> = repeat(200.)
             .take(25)
             .enumerate()
-            .map(|(i, val)| Some(val - (i as f32 * 0.1)))
+            .map(|(i, val)| Some(val - (i as f64 * 0.1)))
             .collect();
         assert_eq!(
             monotonic_decrease_check(&decreasing_sequence.clone(), 0.7, 100.),

src/checks/series/spike_check.rs

@@ -21,7 +21,7 @@ pub const SPIKE_TRAILING_PER_RUN: u8 = 1;
 /// - [`Flag::Fail`] if the difference (explained above) is less than 35% of the sum AND the sum
 ///   (explained above) is greater than `max`,
 /// - [`Flag::Pass`] otherwise.
-pub fn spike_check(data: &[Option<f32>; 3], max: f32) -> Flag {
+pub fn spike_check(data: &[Option<f64>; 3], max: f64) -> Flag {
     if data.contains(&None) {
         return Flag::DataMissing;
     }
@@ -49,7 +49,7 @@ pub fn spike_check(data: &[Option<f32>; 3], max: f32) -> Flag {
 /// - data is invalid
 /// - data has `num_leading_points` <= 1
 /// - data has `num_trailing_points` <= 1
-pub fn spike_check_cache(cache: &DataCache, max: f32) -> Result<Vec<Timeseries<Flag>>, Error> {
+pub fn spike_check_cache(cache: &DataCache, max: f64) -> Result<Vec<Timeseries<Flag>>, Error> {
     let num_series = cache.data.len();
     let mut result_vec = Vec::with_capacity(num_series);
     let series_len = match cache.data.first() {

src/checks/series/step_check.rs

@@ -13,7 +13,7 @@ pub const STEP_LEADING_PER_RUN: u8 = 1;
 /// - [`Flag::Fail`] If the absolute value of the difference between the observed value and it's
 ///   predecessor is greater than max
 /// - [`Flag::Pass`] otherwise.
-pub fn step_check(data: &[Option<f32>; 2], max: f32) -> Flag {
+pub fn step_check(data: &[Option<f64>; 2], max: f64) -> Flag {
     if data.contains(&None) {
         return Flag::DataMissing;
     }
@@ -33,7 +33,7 @@ pub fn step_check(data: &[Option<f32>; 2], max: f32) -> Flag {
 ///
 /// - data is invalid
 /// - data has `num_leading_points` < 1
-pub fn step_check_cache(cache: &DataCache, max: f32) -> Result<Vec<Timeseries<Flag>>, Error> {
+pub fn step_check_cache(cache: &DataCache, max: f64) -> Result<Vec<Timeseries<Flag>>, Error> {
     let num_series = cache.data.len();
     let mut result_vec = Vec::with_capacity(num_series);
     let series_len = match cache.data.first() {

src/checks/single/range_check.rs

@@ -6,7 +6,7 @@ use crate::{util::Timeseries, DataCache, Flag};
 /// - [`Flag::DataMissing`] if the observation is missing,
 /// - [`Flag::Fail`] if it is outside the upper or lower limits,
 /// - [`Flag::Pass`] otherwise.
-pub fn range_check(datum: Option<f32>, lower_limit: f32, upper_limit: f32) -> Flag {
+pub fn range_check(datum: Option<f64>, lower_limit: f64, upper_limit: f64) -> Flag {
     match datum {
         None => Flag::DataMissing,
         Some(datum) => {
@@ -21,8 +21,8 @@ pub fn range_check(datum: Option<f32>, lower_limit: f32, upper_limit: f32) -> Fl
 /// Apply [`range_check`] to a whole [`DataCache`]
 pub fn range_check_cache(
     cache: &DataCache,
-    lower_limit: f32,
-    upper_limit: f32,
+    lower_limit: f64,
+    upper_limit: f64,
 ) -> Vec<Timeseries<Flag>> {
     let num_series = cache.data.len();
     let mut result_vec = Vec::with_capacity(num_series);

src/checks/single/range_check_humidity.rs

@@ -7,7 +7,7 @@ use crate::{util::Timeseries, DataCache, Flag};
 /// - ([`Flag::Fail`], None) if humidity less than 5% or greater than 105%,
 /// - ([`Flag::Warn`], Some(100.)) between 100% and 105%,
 /// - ([`Flag::Pass`], None) otherwise.
-pub fn range_check_humidity(datum: Option<f32>) -> (Flag, Option<f32>) {
+pub fn range_check_humidity(datum: Option<f64>) -> (Flag, Option<f64>) {
     match datum {
         None => (Flag::DataMissing, None),
         Some(datum) => {
@@ -25,7 +25,7 @@ pub fn range_check_humidity(datum: Option<f32>) -> (Flag, Option<f32>) {
 //TODO: is this the optimal return signature for corrections?
 /// Apply [`range_check_humidity`] to a whole [`DataCache`]
 #[allow(clippy::type_complexity)]
-pub fn range_check_humidity_cache(cache: &DataCache) -> Vec<Timeseries<(Flag, Option<f32>)>> {
+pub fn range_check_humidity_cache(cache: &DataCache) -> Vec<Timeseries<(Flag, Option<f64>)>> {
     let num_series = cache.data.len();
     let mut result_vec = Vec::with_capacity(num_series);
     let series_len = match cache.data.first() {

src/checks/single/range_check_wind_direction.rs

@@ -8,7 +8,7 @@ use crate::{util::Timeseries, DataCache, Flag};
 /// - ([`Flag::Warn`], Some(value + 360)) if the value is between -20 and 0,
 /// - ([`Flag::Warn`], Some(value - 360)) if the value is between 360 and 380,
 /// - ([`Flag::Pass`], None) otherwise.
-pub fn range_check_wind_direction(datum: Option<f32>) -> (Flag, Option<f32>) {
+pub fn range_check_wind_direction(datum: Option<f64>) -> (Flag, Option<f64>) {
     // TODO: get to the bottom of weird -3.0 handling: kvalobs code looks for a value -3.0, and
     // avoids flagging that if X_5 (lowest?) is also -3.0. From comments in the code, it looks like
     // this has to do with a special param_id?
@@ -36,7 +36,7 @@ pub fn range_check_wind_direction(datum: Option<f32>) -> (Flag, Option<f32>) {
 //TODO: is this the optimal return signature for corrections?
 /// Apply [`range_check_wind_direction`] to a whole [`DataCache`]
 #[allow(clippy::type_complexity)]
-pub fn range_check_wind_direction_cache(cache: &DataCache) -> Vec<Timeseries<(Flag, Option<f32>)>> {
+pub fn range_check_wind_direction_cache(cache: &DataCache) -> Vec<Timeseries<(Flag, Option<f64>)>> {
     let num_series = cache.data.len();
     let mut result_vec = Vec::with_capacity(num_series);
     let series_len = match cache.data.first() {

src/checks/single/special_values_check.rs

@@ -6,7 +6,7 @@ use crate::{util::Timeseries, DataCache, Flag};
 /// - [`Flag::DataMissing`] if the observation is missing,
 /// - [`Flag::Fail`] if it matches any of the special values
 /// - [`Flag::Pass`] otherwise.
-pub fn special_values_check(datum: Option<f32>, special_values: &[f32]) -> Flag {
+pub fn special_values_check(datum: Option<f64>, special_values: &[f64]) -> Flag {
     match datum {
         None => Flag::DataMissing,
         Some(datum) => {
@@ -21,7 +21,7 @@ pub fn special_values_check(datum: Option<f32>, special_values: &[f32]) -> Flag
 /// Apply [`special_values_check`] to a whole [`DataCache`]
 pub fn special_values_check_cache(
     cache: &DataCache,
-    special_values: &[f32],
+    special_values: &[f64],
 ) -> Vec<Timeseries<Flag>> {
     let num_series = cache.data.len();
     let mut result_vec = Vec::with_capacity(num_series);

src/checks/spatial/buddy_check.rs

@@ -8,19 +8,19 @@ use crate::{
 #[derive(Debug, Clone)]
 pub struct BuddyCheckArgs {
     /// Search radius in which buddies of an observation will be found. Unit: m
-    pub radii: SingleOrVec<f32>,
+    pub radii: SingleOrVec<f64>,
     /// The minimum buddies an observation can have (lest it be flagged [`Flag::Isolated`])
     pub min_buddies: SingleOrVec<u32>,
     /// The variance threshold for flagging a station. Unit: σ (standard deviations)
-    pub threshold: f32,
+    pub threshold: f64,
     /// The maximum difference in elevation for a buddy (if negative will not check for height
     /// difference). Unit: m
-    pub max_elev_diff: f32,
+    pub max_elev_diff: f64,
     /// Linear elevation gradient with height. Unit: ou/m (ou = unit of observation)
-    pub elev_gradient: f32,
+    pub elev_gradient: f64,
     /// If the standard deviation of values in a neighborhood are less than min_std, min_std will
     /// be used instead
-    pub min_std: f32,
+    pub min_std: f64,
     /// The number of iterations of buddy_check to perform before returning
     pub num_iterations: u32,
 }
@@ -54,7 +54,7 @@ pub struct BuddyCheckArgs {
 /// element is set to true, while all values are always used as buddies for checking the data
 /// quality.
 pub fn buddy_check(
-    data: &[Option<f32>],
+    data: &[Option<f64>],
     rtree: &SpatialTree,
     args: &BuddyCheckArgs,
     obs_to_check: Option<&[bool]>,
@@ -87,7 +87,7 @@ pub fn buddy_check(
                 let (lat, lon, elev) = rtree.get_coords_at_index(i);
                 let neighbours = rtree.get_neighbours(lat, lon, *args.radii.index(i), false);
 
-                let mut list_buddies: Vec<f32> = Vec::new();
+                let mut list_buddies: Vec<f64> = Vec::new();
 
                 if neighbours.len() >= *args.min_buddies.index(i) as usize {
                     for neighbour in neighbours {
@@ -116,17 +116,17 @@ pub fn buddy_check(
                 }
 
                 if list_buddies.len() >= *args.min_buddies.index(i) as usize {
-                    let mean: f32 = list_buddies.iter().sum::<f32>() / list_buddies.len() as f32;
-                    let variance: f32 = (list_buddies.iter().map(|x| x.powi(2)).sum::<f32>()
-                        / list_buddies.len() as f32)
+                    let mean: f64 = list_buddies.iter().sum::<f64>() / list_buddies.len() as f64;
+                    let variance: f64 = (list_buddies.iter().map(|x| x.powi(2)).sum::<f64>()
+                        / list_buddies.len() as f64)
                         - mean.powi(2); // TODO: use a better variance algorithm?
                                         // let std = variance.sqrt();
-                                        // let std_adjusted = (variance + variance / list_buddies.len() as f32).sqrt();
+                                        // let std_adjusted = (variance + variance / list_buddies.len() as f64).sqrt();
                                         // if std_adjusted < min_std {
                                         //     std_adjusted = min_std
                                         // }
                     let std_adjusted = std::cmp::max_by(
-                        (variance + variance / list_buddies.len() as f32).sqrt(),
+                        (variance + variance / list_buddies.len() as f64).sqrt(),
                         args.min_std,
                         |x, y| x.partial_cmp(y).unwrap_or(std::cmp::Ordering::Equal),
                     );
@@ -174,7 +174,7 @@ pub fn buddy_check_cache(
 
     for i in (cache.num_leading_points as usize)..(series_len - cache.num_trailing_points as usize)
     {
-        let timeslice: Vec<Option<f32>> = cache.data.iter().map(|fs| fs.values[i]).collect();
+        let timeslice: Vec<Option<f64>> = cache.data.iter().map(|fs| fs.values[i]).collect();
         let spatial_result = buddy_check(&timeslice, &cache.rtree, args, obs_to_check)?;
 
         for i in 0..spatial_result.len() {