Refactor multicolor.rs into multiple modules

Author: hombit

src/multicolor.rs

@@ -0,0 +1,120 @@
+use crate::data::MultiColorTimeSeries;
+use crate::error::MultiColorEvaluatorError;
+use crate::evaluator::{
+    EvaluatorInfo, EvaluatorInfoTrait, FeatureEvaluator, FeatureNamesDescriptionsTrait,
+};
+use crate::features::Median;
+use crate::float_trait::Float;
+use crate::multicolor::multicolor_evaluator::*;
+use crate::multicolor::{PassbandSet, PassbandTrait};
+
+pub use lazy_static::lazy_static;
+pub use schemars::JsonSchema;
+pub use serde::{Deserialize, Serialize};
+use std::collections::BTreeSet;
+use std::fmt::Debug;
+
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[serde(bound(deserialize = "P: PassbandTrait + Deserialize<'de>"))]
+pub struct ColorOfMedian<P>
+where
+    P: Ord,
+{
+    passband_set: PassbandSet<P>,
+    passbands: [P; 2],
+    median: Median,
+    name: String,
+    description: String,
+}
+
+impl<P> ColorOfMedian<P>
+where
+    P: PassbandTrait,
+{
+    pub fn new(passbands: [P; 2]) -> Self {
+        let set: BTreeSet<_> = passbands.clone().into();
+        Self {
+            passband_set: set.into(),
+            name: format!(
+                "color_median_{}_{}",
+                passbands[0].name(),
+                passbands[1].name()
+            ),
+            description: format!(
+                "difference of median magnitudes {}-{}",
+                passbands[0].name(),
+                passbands[1].name()
+            ),
+            passbands,
+            median: Median {},
+        }
+    }
+}
+
+lazy_info!(
+    COLOR_MEDIAN_INFO,
+    size: 1,
+    min_ts_length: 1,
+    t_required: false,
+    m_required: true,
+    w_required: false,
+    sorting_required: false,
+    variability_required: false,
+);
+
+impl<P> EvaluatorInfoTrait for ColorOfMedian<P>
+where
+    P: Ord,
+{
+    fn get_info(&self) -> &EvaluatorInfo {
+        &COLOR_MEDIAN_INFO
+    }
+}
+
+impl<P> FeatureNamesDescriptionsTrait for ColorOfMedian<P>
+where
+    P: Ord,
+{
+    fn get_names(&self) -> Vec<&str> {
+        vec![self.name.as_str()]
+    }
+
+    fn get_descriptions(&self) -> Vec<&str> {
+        vec![self.description.as_str()]
+    }
+}
+
+impl<P> MultiColorPassbandSetTrait<P> for ColorOfMedian<P>
+where
+    P: PassbandTrait,
+{
+    fn get_passband_set(&self) -> &PassbandSet<P> {
+        &self.passband_set
+    }
+}
+
+impl<P, T> MultiColorEvaluator<P, T> for ColorOfMedian<P>
+where
+    P: PassbandTrait,
+    T: Float,
+{
+    fn eval_multicolor(
+        &self,
+        mcts: &mut MultiColorTimeSeries<P, T>,
+    ) -> Result<Vec<T>, MultiColorEvaluatorError> {
+        self.check_mcts_passabands(mcts)?;
+        let mut medians = [T::zero(); 2];
+        for (median, passband) in medians.iter_mut().zip(self.passbands.iter()) {
+            *median = self
+                .median
+                .eval(mcts.get_mut(passband).expect(
+                    "we checked all needed passbands are in mcts, but we still cannot find one",
+                ))
+                .map_err(|error| MultiColorEvaluatorError::MonochromeEvaluatorError {
+                    passband: passband.name().into(),
+                    error,
+                })?[0]
+        }
+        Ok(vec![medians[0] - medians[1]])
+    }
+}

src/multicolor/features/color_of_median.rs

@@ -0,0 +1,2 @@
+mod color_of_median;
+pub use color_of_median::ColorOfMedian;

src/multicolor/features/mod.rs

@@ -0,0 +1,16 @@
+mod features;
+
+mod monochrome_feature;
+pub use monochrome_feature::MonochromeFeature;
+
+mod multicolor_evaluator;
+pub use multicolor_evaluator::{MultiColorEvaluator, MultiColorPassbandSetTrait, PassbandSet};
+
+mod multicolor_extractor;
+pub use multicolor_extractor::MultiColorExtractor;
+
+mod multicolor_feature;
+pub use multicolor_feature::MultiColorFeature;
+
+mod passband;
+pub use passband::*;

src/multicolor/mod.rs

@@ -0,0 +1,130 @@
+use crate::data::MultiColorTimeSeries;
+use crate::error::MultiColorEvaluatorError;
+use crate::evaluator::{
+    EvaluatorInfo, EvaluatorInfoTrait, EvaluatorProperties, FeatureEvaluator,
+    FeatureNamesDescriptionsTrait,
+};
+use crate::float_trait::Float;
+use crate::multicolor::multicolor_evaluator::*;
+
+use itertools::Itertools;
+pub use lazy_static::lazy_static;
+pub use schemars::JsonSchema;
+pub use serde::{Deserialize, Serialize};
+use std::collections::BTreeSet;
+use std::fmt::Debug;
+use std::marker::PhantomData;
+
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[serde(bound(
+    deserialize = "P: PassbandTrait + Deserialize<'de>, T: Float, F: FeatureEvaluator<T>"
+))]
+pub struct MonochromeFeature<P, T, F>
+where
+    P: Ord,
+{
+    feature: F,
+    passband_set: PassbandSet<P>,
+    properties: Box<EvaluatorProperties>,
+    phantom: PhantomData<T>,
+}
+
+impl<P, T, F> MonochromeFeature<P, T, F>
+where
+    P: PassbandTrait,
+    T: Float,
+    F: FeatureEvaluator<T>,
+{
+    pub fn new(feature: F, passband_set: BTreeSet<P>) -> Self {
+        let names = passband_set
+            .iter()
+            .cartesian_product(feature.get_names())
+            .map(|(passband, name)| format!("{}_{}", name, passband.name()))
+            .collect();
+        let descriptions = passband_set
+            .iter()
+            .cartesian_product(feature.get_descriptions())
+            .map(|(passband, description)| format!("{}, passband {}", description, passband.name()))
+            .collect();
+        let info = {
+            let mut info = feature.get_info().clone();
+            info.size *= passband_set.len();
+            info
+        };
+        Self {
+            properties: EvaluatorProperties {
+                info,
+                names,
+                descriptions,
+            }
+            .into(),
+            feature,
+            passband_set: passband_set.into(),
+            phantom: PhantomData,
+        }
+    }
+}
+
+impl<P, T, F> FeatureNamesDescriptionsTrait for MonochromeFeature<P, T, F>
+where
+    P: Ord,
+{
+    fn get_names(&self) -> Vec<&str> {
+        self.properties.names.iter().map(String::as_str).collect()
+    }
+
+    fn get_descriptions(&self) -> Vec<&str> {
+        self.properties
+            .descriptions
+            .iter()
+            .map(String::as_str)
+            .collect()
+    }
+}
+
+impl<P, T, F> EvaluatorInfoTrait for MonochromeFeature<P, T, F>
+where
+    P: Ord,
+{
+    fn get_info(&self) -> &EvaluatorInfo {
+        &self.properties.info
+    }
+}
+
+impl<P, T, F> MultiColorPassbandSetTrait<P> for MonochromeFeature<P, T, F>
+where
+    P: PassbandTrait,
+{
+    fn get_passband_set(&self) -> &PassbandSet<P> {
+        &self.passband_set
+    }
+}
+
+impl<P, T, F> MultiColorEvaluator<P, T> for MonochromeFeature<P, T, F>
+where
+    P: PassbandTrait,
+    T: Float,
+    F: FeatureEvaluator<T>,
+{
+    fn eval_multicolor(
+        &self,
+        mcts: &mut MultiColorTimeSeries<P, T>,
+    ) -> Result<Vec<T>, MultiColorEvaluatorError> {
+        self.check_mcts_passabands(mcts)?;
+        match &self.passband_set {
+            PassbandSet::FixedSet(set) => set
+                .iter()
+                .map(|passband| {
+                    self.feature.eval(mcts.get_mut(passband).expect(
+                        "we checked all needed passbands are in mcts, but we still cannot find one",
+                    )).map_err(|error| MultiColorEvaluatorError::MonochromeEvaluatorError {
+                        passband: passband.name().into(),
+                        error,
+                    })
+                })
+                .flatten_ok()
+                .collect(),
+            PassbandSet::AllAvailable => panic!("passband_set must be FixedSet variant here"),
+        }
+    }
+}