Struct yata::methods::Integral

pub struct Integral { /* private fields */ }

Integrates (summarizes) ValueType values for the given window size length

Parameters

Has a single parameter length: PeriodType

If length == 0, then integrates since the beginning of timeseries

Input type

Input type is ValueType

Output type

Output type is ValueType

Examples

use yata::prelude::*;
use yata::methods::Integral;

// Integrates over last 3 values
let mut integral = Integral::new(3, &1.0).unwrap();

integral.next(&1.0);
integral.next(&2.0);
assert_eq!(integral.next(&3.0), 6.0); // 1 + 2 + 3
assert_eq!(integral.next(&4.0), 9.0); // 2 + 3 + 4
assert_eq!(integral.next(&5.0), 12.0); // 3 + 4 + 5

use yata::prelude::*;
use yata::methods::Integral;

// Integrates since the beginning
let mut integral = Integral::new(0, &1.0).unwrap(); // same as Integral::default()

integral.next(&1.0);
integral.next(&2.0);
assert_eq!(integral.next(&3.0), 6.0); // 1 + 2 + 3
assert_eq!(integral.next(&4.0), 10.0); // 1 + 2 + 3 + 4
assert_eq!(integral.next(&5.0), 15.0); // 1 + 2 + 3 + 4 + 5

Integral is opposite method for Derivative

use yata::prelude::*;
use yata::methods::{Integral, Derivative};

let s = [1.0, 2.0, 3.0, 3.0, 2.5, 3.5, 5.0];
let mut integral = Integral::default();
let mut derivative = Derivative::new(1, &s[0]).unwrap();

(&s).iter().for_each(|v| {
    let integration_constant = s[0];
    let der = derivative.next(v);
    let integr = integral.next(&der) + integration_constant;

    assert_eq!(integr, *v);
});

Performance

O(1)

See also

Derivative

Trait Implementations

impl Clone for Integral

fn clone(&self) -> Integral

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Integral

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

Formats the value using the given formatter.

impl Default for Integral

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Integral

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Method for Integral

type Params = u8

Method parameters

type Input = f64

Input value type

type Output = <Integral as Method>::Input

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 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 Peekable<<Integral as Method>::Output> for Integral

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

Peeks the very last value, produced by method or indicator

impl Serialize for Integral

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

where __S: Serializer,

Serialize this value into the given Serde serializer.