Struct yata::methods::Past

pub struct Past<T>(_)
 where
    T: Clone + Debug;

Moves timeseries by length items forward

It’s just a simple method-like wrapper for Window<T>

Parameters

Has a single parameter length: PeriodType

length should be > 0

Input type

Input type is any T: Copy + std::fmt::Debug

Output type

Output type is the same as input type

Examples

use yata::prelude::*;
use yata::methods::Past;

// Move of length=3
let mut past = Past::new(3, &1.0).unwrap();

past.next(&1.0);
past.next(&2.0);
past.next(&3.0);

assert_eq!(past.next(&4.0), 1.0);
assert_eq!(past.next(&5.0), 2.0);
assert_eq!(past.next(&6.0), 3.0);

Performance

O(1)

See also

Window<T>

Trait Implementations

impl<T: Clone + Debug> Buffered<<Past<T> as Method>::Output> for Past<T>

fn get(&self, index: usize) -> Option<<Self as Method>::Output>

Picks value at index position, starting from the newest value

impl<T: Clone> Clone for Past<T> where
    T: Clone + Debug, 

fn clone(&self) -> Past<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Past<T> where
    T: Clone + Debug, 

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for Past<T> where
    T: Clone + Debug,
    T: Deserialize<'de>, 

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

Deserialize this value from the given Serde deserializer.

impl<T> Method for Past<T> where
    T: Clone + Debug, 

type Params = PeriodType

Method parameters

type Input = T

Input value type

type Output = T

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) -> T

Generates next output value based on the given input value

fn with_history(
    parameters: Self::Params,
    initial_value: &Self::Input
) -> Result<WithHistory<Self, Self::Output>, Error> where
    Self: Sized,
    Self::Output: Debug + Clone, 

Creates an instance of the method with given parameters and initial value, wrapped by historical data holder

fn with_last_value(
    parameters: Self::Params,
    initial_value: &Self::Input
) -> Result<WithLastValue<Self, Self::Output>, Error> where
    Self: Sized,
    Self::Output: Debug + Clone, 

Creates an instance of the method with given parameters and initial value, wrapped by last produced value holder

fn name(&self) -> &str

Returns a name of the method

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

👎 Deprecated

Returns memory size of the method (size, align)

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

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

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

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: Sized,
    Self: Sized, 

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: &mut S
) -> Result<(), Error> where
    S: Sequence<T> + AsMut<[T]>,
    Self: Method<Input = T, Output = T> + Sized, 

Creates new Method instance and applies it to the sequence.

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

Creates a function from the Method instance

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

Creates new function based on the method

impl<T> Peekable<<Past<T> as Method>::Output> for Past<T> where
    T: Clone + Debug, 

fn peek(&self) -> <Self as Method>::Output

Peeks the very last value, produced by method or indicator

impl<T> Serialize for Past<T> where
    T: Clone + Debug,
    T: Serialize, 

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

Serialize this value into the given Serde serializer.