Struct yata::methods::Momentum

pub struct Momentum { /* fields omitted */ }

Momentum calculates difference between current value and n-th value back, where n = length

Parameters

Has a single parameter length: PeriodType

length should be > 0

Input type

Input type is ValueType

Output type

Output type is ValueType

Examples

use yata::prelude::*;
use yata::methods::Momentum;

let mut change = Momentum::new(3, 1.0); // a.k.a. Change => let mut change = Change::new(3);
change.next(1.0);
change.next(2.0);
assert_eq!(change.next(3.0), 2.0);
assert_eq!(change.next(4.0), 3.0);
assert_eq!(change.next(2.0), 0.0);

At length=1 Momentum is the same as Derivative with length=1

use yata::prelude::*;
use yata::methods::Momentum;
use yata::methods::Derivative;

let mut change = Momentum::new(1, 1.0);
let mut derivative = Derivative::new(1, 1.0);
change.next(1.0); derivative.next(1.0);
change.next(2.0); derivative.next(2.0);
assert_eq!(change.next(3.0), derivative.next(3.0));
assert_eq!(change.next(4.0), derivative.next(4.0));
assert_eq!(change.next(2.0), derivative.next(2.0));

Perfomance

O(1)

See Also

Rate of Change, Derivative

Trait Implementations

impl Clone for Momentum

fn clone(&self) -> Momentum

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Momentum

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Momentum

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

Deserialize this value from the given Serde deserializer.

impl Method for Momentum

type Params = PeriodType

Method parameters

type Input = ValueType

Input value type

type Output = Self::Input

Output value type

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

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 iter_data<I>(&mut self, input: I) -> MethodOverIterator<'_, Self, I> where
    I: Iterator<Item = Self::Input>,
    Self: Sized, 

Creates an iterator which produces values by the Method over given input data iterator

fn over<I>(&mut self, sequence: I) -> Sequence<Self::Output> where
    I: Iterator<Item = Self::Input>,
    Self: Sized, 

Iterates the Method over the given Sequence and returns timeserie of output values

impl Serialize for Momentum

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

Serialize this value into the given Serde serializer.