eval_no_ts_check initial implementation

Author: hombit

src/evaluator.rs

@@ -20,6 +20,7 @@ pub struct EvaluatorInfo {
     pub m_required: bool,
     pub w_required: bool,
     pub sorting_required: bool,
+    pub variability_required: bool,
 }
 
 #[derive(Clone, Debug)]
@@ -69,6 +70,11 @@ pub trait EvaluatorInfoTrait {
     fn is_sorting_required(&self) -> bool {
         self.get_info().sorting_required
     }
+
+    /// If feature requires magnitude array elements to be different
+    fn is_variability_required(&self) -> bool {
+        self.get_info().variability_required
+    }
 }
 
 // impl<P> EvaluatorInfoTrait for P
@@ -124,8 +130,14 @@ pub trait FeatureEvaluator<T: Float>:
     + DeserializeOwned
     + JsonSchema
 {
+    /// Version of [FeatureEvaluator::eval] which can panic for incorrect input
+    fn eval_no_ts_check(&self, ts: &mut TimeSeries<T>) -> Result<Vec<T>, EvaluatorError>;
+
     /// Vector of feature values or `EvaluatorError`
-    fn eval(&self, ts: &mut TimeSeries<T>) -> Result<Vec<T>, EvaluatorError>;
+    fn eval(&self, ts: &mut TimeSeries<T>) -> Result<Vec<T>, EvaluatorError> {
+        self.check_ts(ts)?;
+        self.eval_no_ts_check(ts)
+    }
 
     /// Returns vector of feature values and fill invalid components with given value
     fn eval_or_fill(&self, ts: &mut TimeSeries<T>, fill_value: T) -> Vec<T> {
@@ -135,44 +147,31 @@ pub trait FeatureEvaluator<T: Float>:
         }
     }
 
+    fn check_ts(&self, ts: &mut TimeSeries<T>) -> Result<(), EvaluatorError> {
+        self.check_ts_length(ts)?;
+        self.check_ts_variability(ts)
+    }
+
     /// Checks if [TimeSeries] has enough points to evaluate the feature
-    fn check_ts_length(&self, ts: &TimeSeries<T>) -> Result<usize, EvaluatorError> {
+    fn check_ts_length(&self, ts: &TimeSeries<T>) -> Result<(), EvaluatorError> {
         let length = ts.lenu();
         if length < self.min_ts_length() {
             Err(EvaluatorError::ShortTimeSeries {
                 actual: length,
                 minimum: self.min_ts_length(),
             })
         } else {
-            Ok(length)
+            Ok(())
         }
     }
-}
 
-pub fn get_nonzero_m_std<T: Float>(ts: &mut TimeSeries<T>) -> Result<T, EvaluatorError> {
-    let std = ts.m.get_std();
-    if std.is_zero() || ts.is_plateau() {
-        Err(EvaluatorError::FlatTimeSeries)
-    } else {
-        Ok(std)
-    }
-}
-
-pub fn get_nonzero_m_std2<T: Float>(ts: &mut TimeSeries<T>) -> Result<T, EvaluatorError> {
-    let std2 = ts.m.get_std2();
-    if std2.is_zero() || ts.is_plateau() {
-        Err(EvaluatorError::FlatTimeSeries)
-    } else {
-        Ok(std2)
-    }
-}
-
-pub fn get_nonzero_reduced_chi2<T: Float>(ts: &mut TimeSeries<T>) -> Result<T, EvaluatorError> {
-    let reduced_chi2 = ts.get_m_reduced_chi2();
-    if reduced_chi2.is_zero() || ts.is_plateau() {
-        Err(EvaluatorError::FlatTimeSeries)
-    } else {
-        Ok(reduced_chi2)
+    /// Checks if [TimeSeries] meets variability requirement
+    fn check_ts_variability(&self, ts: &mut TimeSeries<T>) -> Result<(), EvaluatorError> {
+        if self.is_variability_required() && ts.is_plateau() {
+            Err(EvaluatorError::FlatTimeSeries)
+        } else {
+            Ok(())
+        }
     }
 }
 

src/extractor.rs

@@ -46,6 +46,7 @@ where
             m_required: features.iter().any(|x| x.is_m_required()),
             w_required: features.iter().any(|x| x.is_w_required()),
             sorting_required: features.iter().any(|x| x.is_sorting_required()),
+            variability_required: features.iter().any(|x| x.is_variability_required()),
         }
         .into();
         Self {
@@ -118,10 +119,10 @@ where
     T: Float,
     F: FeatureEvaluator<T>,
 {
-    fn eval(&self, ts: &mut TimeSeries<T>) -> Result<Vec<T>, EvaluatorError> {
+    fn eval_no_ts_check(&self, ts: &mut TimeSeries<T>) -> Result<Vec<T>, EvaluatorError> {
         let mut vec = Vec::with_capacity(self.size_hint());
         for x in &self.features {
-            vec.extend(x.eval(ts)?);
+            vec.extend(x.eval_no_ts_check(ts)?);
         }
         Ok(vec)
     }

src/features/amplitude.rs

@@ -47,6 +47,7 @@ lazy_info!(
     m_required: true,
     w_required: false,
     sorting_required: false,
+    variability_required: false,
 );
 
 impl FeatureNamesDescriptionsTrait for Amplitude {
@@ -63,8 +64,7 @@ impl<T> FeatureEvaluator<T> for Amplitude
 where
     T: Float,
 {
-    fn eval(&self, ts: &mut TimeSeries<T>) -> Result<Vec<T>, EvaluatorError> {
-        self.check_ts_length(ts)?;
+    fn eval_no_ts_check(&self, ts: &mut TimeSeries<T>) -> Result<Vec<T>, EvaluatorError> {
         Ok(vec![T::half() * (ts.m.get_max() - ts.m.get_min())])
     }
 }

src/features/anderson_darling_normal.rs

@@ -46,6 +46,7 @@ lazy_info!(
     m_required: true,
     w_required: false,
     sorting_required: false,
+    variability_required: true,
 );
 
 impl FeatureNamesDescriptionsTrait for AndersonDarlingNormal {
@@ -62,10 +63,10 @@ impl<T> FeatureEvaluator<T> for AndersonDarlingNormal
 where
     T: Float,
 {
-    fn eval(&self, ts: &mut TimeSeries<T>) -> Result<Vec<T>, EvaluatorError> {
-        let size = self.check_ts_length(ts)?;
-        let m_std = get_nonzero_m_std(ts)?;
+    fn eval_no_ts_check(&self, ts: &mut TimeSeries<T>) -> Result<Vec<T>, EvaluatorError> {
+        let size = ts.lenu();
         let m_mean = ts.m.get_mean();
+        let m_std = ts.m.get_std();
         let sum: f64 =
             ts.m.get_sorted()
                 .as_ref()

src/features/bazin_fit.rs

@@ -108,6 +108,7 @@ lazy_info!(
     m_required: true,
     w_required: true,
     sorting_required: true, // improve reproducibility
+    variability_required: false,
 );
 
 struct Params<'a, T> {

src/features/beyond_n_std.rs

@@ -94,6 +94,7 @@ lazy_info!(
     m_required: true,
     w_required: false,
     sorting_required: false,
+    variability_required: false,
 );
 
 impl<T> Default for BeyondNStd<T>
@@ -122,8 +123,7 @@ impl<T> FeatureEvaluator<T> for BeyondNStd<T>
 where
     T: Float,
 {
-    fn eval(&self, ts: &mut TimeSeries<T>) -> Result<Vec<T>, EvaluatorError> {
-        self.check_ts_length(ts)?;
+    fn eval_no_ts_check(&self, ts: &mut TimeSeries<T>) -> Result<Vec<T>, EvaluatorError> {
         let m_mean = ts.m.get_mean();
         let threshold = ts.m.get_std() * self.nstd;
         let count_beyond = ts.m.sample.fold(0, |count, &m| {

src/features/bins.rs

@@ -62,6 +62,7 @@ where
             m_required: true,
             w_required: true,
             sorting_required: true,
+            variability_required: false,
         };
         Self {
             properties: EvaluatorProperties {
@@ -92,6 +93,9 @@ where
         let window = self.window;
         let offset = self.offset;
         self.properties.info.size += feature.size_hint();
+        self.properties.info.min_ts_length =
+            usize::max(self.properties.info.min_ts_length, feature.min_ts_length());
+        self.properties.info.variability_required |= feature.is_variability_required();
         self.properties.names.extend(
             feature
                 .get_names()
@@ -133,7 +137,12 @@ where
     }
 
     fn transform_ts(&self, ts: &mut TimeSeries<T>) -> Result<TmwArrays<T>, EvaluatorError> {
-        self.check_ts_length(ts)?;
+        if ts.lenu() == 0 {
+            return Err(EvaluatorError::ShortTimeSeries {
+                actual: ts.lenu(),
+                minimum: 1,
+            });
+        }
         let (t, m, w): (Vec<_>, Vec<_>, Vec<_>) =
             ts.t.as_slice()
                 .iter()

src/features/cusum.rs

@@ -46,6 +46,7 @@ lazy_info!(
     m_required: true,
     w_required: false,
     sorting_required: true,
+    variability_required: true,
 );
 
 impl FeatureNamesDescriptionsTrait for Cusum {
@@ -62,10 +63,9 @@ impl<T> FeatureEvaluator<T> for Cusum
 where
     T: Float,
 {
-    fn eval(&self, ts: &mut TimeSeries<T>) -> Result<Vec<T>, EvaluatorError> {
-        self.check_ts_length(ts)?;
-        let m_std = get_nonzero_m_std(ts)?;
+    fn eval_no_ts_check(&self, ts: &mut TimeSeries<T>) -> Result<Vec<T>, EvaluatorError> {
         let m_mean = ts.m.get_mean();
+        let m_std = ts.m.get_std();
         let (_last_cusum, min_cusum, max_cusum) = ts.m.as_slice().iter().fold(
             (T::zero(), T::infinity(), -T::infinity()),
             |(mut cusum, min_cusum, max_cusum), &m| {

src/features/duration.rs

@@ -39,6 +39,7 @@ lazy_info!(
     m_required: false,
     w_required: false,
     sorting_required: true,
+    variability_required: false,
 );
 
 impl FeatureNamesDescriptionsTrait for Duration {
@@ -55,8 +56,7 @@ impl<T> FeatureEvaluator<T> for Duration
 where
     T: Float,
 {
-    fn eval(&self, ts: &mut TimeSeries<T>) -> Result<Vec<T>, EvaluatorError> {
-        self.check_ts_length(ts)?;
+    fn eval_no_ts_check(&self, ts: &mut TimeSeries<T>) -> Result<Vec<T>, EvaluatorError> {
         Ok(vec![ts.t.sample[ts.lenu() - 1] - ts.t.sample[0]])
     }
 }

src/features/eta.rs

@@ -42,6 +42,7 @@ lazy_info!(
     m_required: true,
     w_required: false,
     sorting_required: true,
+    variability_required: true,
 );
 
 impl FeatureNamesDescriptionsTrait for Eta {
@@ -58,9 +59,8 @@ impl<T> FeatureEvaluator<T> for Eta
 where
     T: Float,
 {
-    fn eval(&self, ts: &mut TimeSeries<T>) -> Result<Vec<T>, EvaluatorError> {
-        self.check_ts_length(ts)?;
-        let m_std2 = get_nonzero_m_std2(ts)?;
+    fn eval_no_ts_check(&self, ts: &mut TimeSeries<T>) -> Result<Vec<T>, EvaluatorError> {
+        let m_std2 = ts.m.get_std2();
         let value =
             ts.m.as_slice()
                 .iter()