Struct yata::methods::LowestIndex

pub struct LowestIndex { /* fields omitted */ }

Returns lowest value index over the last length values for timeseries of type ValueType

If period has more than one minimum values, then returns the index of the newest value (e.g. the smallest index)

Parameters

Has a single parameter length: PeriodType

length should be > 0

Input type

Input type is ValueType

Output type

Output type is PeriodType

Examples

use yata::core::Method;
use yata::methods::LowestIndex;

let values = [1.0, 2.0, 3.0, 2.0, 1.0, 0.5, 2.0, 3.0];
let r      = [ 0,   1,   2,   0,   0,   0,   1,   2 ];

let mut lowest_index = LowestIndex::new(3, values[0]).unwrap();

(0..values.len()).for_each(|i| {
    let v = lowest_index.next(values[i]);
    assert_eq!(v, r[i]);
});

Performance

O(length)

This method is relatively slow compare to the other methods.

See also

HighestIndex, Highest, Lowest, HighestLowestDelta

Trait Implementations

impl Clone for LowestIndex

fn clone(&self) -> LowestIndex

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LowestIndex

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LowestIndex

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

Deserialize this value from the given Serde deserializer.

impl Method<'_> for LowestIndex

type Params = PeriodType

Method parameters

type Input = ValueType

Input value type

type Output = PeriodType

Output value type

fn new(length: Self::Params, value: Self::Input) -> Result<Self, Error>

Static method for creating an instance of the method with given parameters and initial value (simply first input value)

fn next(&mut self, value: Self::Input) -> Self::Output

Generates next output value based on the given input value

fn name(&self) -> &str

Returns a name of the method

fn memsize(&self) -> (usize, usize) where
    Self: Sized, 

Returns memory size of the method (size, align)

fn over<S>(&'a mut self, inputs: S) -> Vec<Self::Output> where
    S: Sequence<Self::Input>,
    Self: Sized, 

Iterates the Method over the given inputs slice and returns Vec of output values.

fn apply<'b: 'a, T, S>(&'a mut self, sequence: &'b mut S) where
    S: Sequence<T> + AsMut<[T]>,
    Self: Method<'a, Input = T, Output = T> + Sized,
    T: Copy, 

Applies method to the sequence in-place.

fn new_over<S>(
    parameters: Self::Params,
    inputs: S
) -> Result<Vec<Self::Output>, Error> where
    S: Sequence<Self::Input>,
    Self::Input: Clone,
    Self: Sized + 'a, 

Creates new Method instance and iterates it over the given inputs slice and returns Vec of output values.

fn new_apply<T, S>(
    parameters: Self::Params,
    sequence: &'a mut S
) -> Result<(), Error> where
    T: Copy,
    S: Sequence<T> + AsMut<[T]>,
    Self: Method<'a, Input = T, Output = T> + Sized + 'a, 

Creates new Method instance and applies it to the sequence.

fn into_fn(self) -> Box<dyn FnMut(Self::Input) -> Self::Output> where
    Self: Sized + 'static, 

Creates a function from the Method instance

fn new_fn(
    params: Self::Params,
    initial_value: Self::Input
) -> Result<Box<dyn FnMut(Self::Input) -> Self::Output>, Error> where
    Self: Sized + 'static, 

Creates new function based on the method

impl Serialize for LowestIndex

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

Serialize this value into the given Serde serializer.