Struct light_curve_feature::features::Bins

pub struct Bins<T, F> where
    T: Float,
    F: FeatureEvaluator<T>,  { /* fields omitted */ }

Bins — sampled time series

Binning time series to bins with width $\mathrm{window}$ with respect to some $\mathrm{offset}$. $j-th$ bin interval is $[j \cdot \mathrm{window} + \mathrm{offset}; (j + 1) \cdot \mathrm{window} + \mathrm{offset})$. Binned time series is defined by $$ t_j^* = (j + \frac12) \cdot \mathrm{window} + \mathrm{offset}, $$ $$ m_j^* = \frac{\sum{m_i / \delta_i^2}}{\sum{\delta_i^{-2}}}, $$ $$ \delta_j^* = \frac{N_j}{\sum{\delta_i^{-2}}}, $$ where $N_j$ is a number of sampling observations and all sums are over observations inside considering bin

• Depends on: time, magnitude, magnitude error
• Minimum number of observations: 1 (or as required by sub-features)
• Number of features: $…$

Implementations

impl<T, F> Bins<T, F> where
    T: Float,
    F: FeatureEvaluator<T>, 

pub fn new(window: T, offset: T) -> Self

pub fn set_window(&mut self, window: T) -> &mut Self

pub fn set_offset(&mut self, offset: T) -> &mut Self

pub fn add_feature(&mut self, feature: F) -> &mut Self

Extend a feature to extract from binned time series

pub fn default_window() -> T

pub fn default_offset() -> T

impl<T, F> Bins<T, F> where
    T: Float,
    F: FeatureEvaluator<T>, 

pub fn doc() -> &'static str

Trait Implementations

impl<T: Clone, F: Clone> Clone for Bins<T, F> where
    T: Float,
    F: FeatureEvaluator<T>, 

fn clone(&self) -> Bins<T, F>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug, F: Debug> Debug for Bins<T, F> where
    T: Float,
    F: FeatureEvaluator<T>, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T, F> Default for Bins<T, F> where
    T: Float,
    F: FeatureEvaluator<T>, 

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T, F> Deserialize<'de> for Bins<T, F> where
    T: Float,
    F: FeatureEvaluator<T>,
    T: Float,
    F: FeatureEvaluator<T>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T, F> FeatureEvaluator<T> for Bins<T, F> where
    T: Float,
    F: FeatureEvaluator<T>, 

fn eval(&self, ts: &mut TimeSeries<'_, T>) -> Result<Vec<T>, EvaluatorError>

Should return the vector of feature values or EvaluatorError

fn eval_or_fill(&self, ts: &mut TimeSeries<'_, T>, fill_value: T) -> Vec<T>

Should return the vector of feature values and fill invalid components with given value

fn get_info(&self) -> &EvaluatorInfo

Get feature evaluator meta-information

fn get_names(&self) -> Vec<&str>

Should return the vector of feature names. The length and feature order should correspond to eval() output

fn get_descriptions(&self) -> Vec<&str>

Should return the vector of feature descriptions. The length and feature order should correspond to eval() output

fn size_hint(&self) -> usize

Should return the size of vectors returned by eval() and get_names()

fn min_ts_length(&self) -> usize

Should return minimum time series length to successfully find feature value

fn is_t_required(&self) -> bool

fn is_m_required(&self) -> bool

fn is_w_required(&self) -> bool

fn is_sorting_required(&self) -> bool

fn check_ts_length(
    &self,
    ts: &TimeSeries<'_, T>
) -> Result<usize, EvaluatorError>

impl<T> From<Bins<T, Feature<T>>> for Feature<T> where
    T: Float, 

fn from(v: Bins<T, Self>) -> Feature<T>

Performs the conversion.

impl<T, F> JsonSchema for Bins<T, F> where
    T: Float,
    F: FeatureEvaluator<T>, 

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

fn schema_name() -> String

The name of the generated JSON Schema.

fn json_schema(gen: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

impl<T, F> Serialize for Bins<T, F> where
    T: Float,
    F: FeatureEvaluator<T>,
    T: Float,
    F: FeatureEvaluator<T>, 

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl<T> TryInto<Bins<T, Feature<T>>> for Feature<T> where
    T: Float, 

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(
    self
) -> Result<Bins<T, Self>, <Self as TryInto<Bins<T, Self>>>::Error>

Performs the conversion.