Trait yata::core::Method

pub trait Method<'a>: Debug {
    type Params;
    type Input;
    type Output: Copy;
    pub fn new(
        parameters: Self::Params, 
        initial_value: Self::Input
    ) -> Result<Self, Error>
    where
        Self: Sized;
    pub fn next(&mut self, value: Self::Input) -> Self::Output;

    pub fn name(&self) -> &str { ... }
    pub fn memsize(&self) -> (usize, usize)
    where
        Self: Sized,
    { ... }
    pub fn over<S>(&'a mut self, inputs: S) -> Vec<Self::Output>
    where
        S: Sequence<Self::Input>,
        Self: Sized,
    { ... }
    pub 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,
    { ... }
    pub 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,
    { ... }
    pub 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,
    { ... }
    pub fn into_fn(self) -> Box<dyn FnMut(Self::Input) -> Self::Output>
    where
        Self: Sized + 'static,
    { ... }
    pub fn new_fn(
        params: Self::Params, 
        initial_value: Self::Input
    ) -> Result<Box<dyn FnMut(Self::Input) -> Self::Output>, Error>
    where
        Self: Sized + 'static,
    { ... }
}

Trait for creating methods for timeseries

Regular methods usage

Iterate over vector's values

use yata::methods::SMA;
use yata::prelude::*;

let s: Vec<_> = vec![1.,2.,3.,4.,5.,6.,7.,8.,9.,10.];
let mut ma = SMA::new(2, s[0]).unwrap();

s.iter().enumerate().for_each(|(index, &value)| {
    assert_eq!(ma.next(value), (value + s[index.saturating_sub(1)])/2.);
});

Get a whole new vector over the input vector

You can call method over any Sequence:

use yata::methods::SMA;
use yata::prelude::*;

let s: Vec<_> = vec![1.,2.,3.,4.,5.,6.,7.,8.,9.,10.];
let mut ma = SMA::new(2, s[0]).unwrap();

let result = ma.over(s);
assert_eq!(result.as_slice(), &[1., 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5]);

Or you can provide Method to Sequence:

use yata::methods::SMA;
use yata::prelude::*;

let s: Vec<_> = vec![1.,2.,3.,4.,5.,6.,7.,8.,9.,10.];
let mut ma = SMA::new(2, s[0]).unwrap();

let result = s.call(ma);
assert_eq!(result.as_slice(), &[1., 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5]);

Or you can even change Sequence values in-place:

use yata::methods::SMA;
use yata::prelude::*;

let mut s: Vec<_> = vec![1.,2.,3.,4.,5.,6.,7.,8.,9.,10.];
let mut ma = SMA::new(2, s[0]).unwrap();

s.apply(ma);
assert_eq!(s.as_slice(), &[1., 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5]);

Be advised

There is no reset method on the trait. If you need reset a state of the Method instance, you should just create a new one.

Associated Types

type Params

Method parameters

type Input

Input value type

type Output: Copy

Output value type

Loading content...

Required methods

pub fn new(
    parameters: Self::Params,
    initial_value: Self::Input
) -> Result<Self, Error> where
    Self: Sized, 

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

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

Generates next output value based on the given input value

Loading content...

Provided methods

pub fn name(&self) -> &str

Returns a name of the method

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

Returns memory size of the method (size, align)

pub 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.

Guarantees

The length of an output Vec is always equal to the length of an inputs slice.

use yata::methods::SMA;
use yata::prelude::*;

let s: Vec<_> = vec![1.,2.,3.,4.,5.,6.,7.,8.,9.,10.];
let mut ma = SMA::new(5, s[0]).unwrap();

let result = ma.over(&s);
assert_eq!(result.len(), s.len());

use yata::methods::SMA;
use yata::prelude::*;

let s: Vec<_> = vec![1.,2.,3.,4.,5.,6.,7.,8.,9.,10.];
let mut ma = SMA::new(100, s[0]).unwrap();

let result = ma.over(&s);
assert_eq!(result.len(), s.len());

pub 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.

pub 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.

Guarantees

The length of an output Vec is always equal to the length of an inputs slice.

pub 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.

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

Creates a function from the Method instance

pub 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

Loading content...

Implementations on Foreign Types

impl<'a, M: Method<'a>> Method<'a> for &'a mut M

type Params = M::Params

type Input = M::Input

Input value type

type Output = M::Output

Output value type

pub fn new(
    _parameters: Self::Params,
    _initial_value: Self::Input
) -> Result<Self, Error>

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

Generates next output value based on the given input value

Loading content...

Implementors

impl Method<'_> for CCI

type Params = PeriodType

type Input = ValueType

type Output = Self::Input

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

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

impl Method<'_> for Conv

type Params = Vec<ValueType>

type Input = ValueType

type Output = Self::Input

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

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

impl Method<'_> for Cross

type Params = ()

type Input = (ValueType, ValueType)

type Output = Action

pub fn new(_: Self::Params, value: Self::Input) -> Result<Self, Error> where
    Self: Sized, 

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

impl Method<'_> for CrossAbove

type Params = ()

type Input = (ValueType, ValueType)

type Output = Action

pub fn new(_: Self::Params, value: Self::Input) -> Result<Self, Error> where
    Self: Sized, 

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

impl Method<'_> for CrossUnder

type Params = ()

type Input = (ValueType, ValueType)

type Output = Action

pub fn new(_: Self::Params, value: Self::Input) -> Result<Self, Error> where
    Self: Sized, 

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

impl Method<'_> for DEMA

type Params = PeriodType

type Input = ValueType

type Output = Self::Input

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

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

impl Method<'_> for DMA

type Params = PeriodType

type Input = ValueType

type Output = Self::Input

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

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

impl Method<'_> for Derivative

type Params = PeriodType

type Input = ValueType

type Output = Self::Input

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

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

impl Method<'_> for EMA

type Params = PeriodType

type Input = ValueType

type Output = Self::Input

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

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

impl Method<'_> for HMA

type Params = PeriodType

type Input = ValueType

type Output = Self::Input

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

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

impl Method<'_> for Highest

type Params = PeriodType

type Input = ValueType

type Output = Self::Input

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

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

impl Method<'_> for HighestIndex

type Params = PeriodType

type Input = ValueType

type Output = PeriodType

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

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

impl Method<'_> for HighestLowestDelta

type Params = PeriodType

type Input = ValueType

type Output = Self::Input

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

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

impl Method<'_> for Integral

type Params = PeriodType

type Input = ValueType

type Output = Self::Input

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

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

impl Method<'_> for LinReg

type Params = PeriodType

type Input = ValueType

type Output = Self::Input

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

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

impl Method<'_> for LinearVolatility

type Params = PeriodType

type Input = ValueType

type Output = Self::Input

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

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

impl Method<'_> for LowerReversalSignal

type Params = (PeriodType, PeriodType)

type Input = ValueType

type Output = Action

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

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

impl Method<'_> for Lowest

type Params = PeriodType

type Input = ValueType

type Output = Self::Input

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

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

impl Method<'_> for LowestIndex

type Params = PeriodType

type Input = ValueType

type Output = PeriodType

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

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

impl Method<'_> for MeanAbsDev

type Params = PeriodType

type Input = ValueType

type Output = Self::Input

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

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

impl Method<'_> for MedianAbsDev

type Params = PeriodType

type Input = ValueType

type Output = Self::Input

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

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

impl Method<'_> for Momentum

type Params = PeriodType

type Input = ValueType

type Output = Self::Input

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

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

impl Method<'_> for RMA

type Params = PeriodType

type Input = ValueType

type Output = Self::Input

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

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

impl Method<'_> for RateOfChange

type Params = PeriodType

type Input = ValueType

type Output = Self::Input

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

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

impl Method<'_> for ReversalSignal

type Params = (PeriodType, PeriodType)

type Input = ValueType

type Output = Action

pub fn new(params: Self::Params, value: Self::Input) -> Result<Self, Error> where
    Self: Sized, 

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

impl Method<'_> for SMA

type Params = PeriodType

type Input = ValueType

type Output = Self::Input

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

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

impl Method<'_> for SMM

type Params = PeriodType

type Input = ValueType

type Output = Self::Input

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

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

impl Method<'_> for SWMA

type Params = PeriodType

type Input = ValueType

type Output = Self::Input

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

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

impl Method<'_> for StDev

type Params = PeriodType

type Input = ValueType

type Output = Self::Input

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

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

impl Method<'_> for TEMA

type Params = PeriodType

type Input = ValueType

type Output = Self::Input

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

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

impl Method<'_> for TMA

type Params = PeriodType

type Input = ValueType

type Output = Self::Input

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

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

impl Method<'_> for TRIMA

type Params = PeriodType

type Input = ValueType

type Output = Self::Input

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

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

impl Method<'_> for TSI

type Params = (PeriodType, PeriodType)

type Input = ValueType

type Output = Self::Input

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

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

impl Method<'_> for UpperReversalSignal

type Params = (PeriodType, PeriodType)

type Input = ValueType

type Output = Action

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

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

impl Method<'_> for VWMA

type Params = PeriodType

type Input = (ValueType, ValueType)

type Output = ValueType

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

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

impl Method<'_> for Vidya

type Params = PeriodType

type Input = ValueType

type Output = Self::Input

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

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

impl Method<'_> for WMA

type Params = PeriodType

type Input = ValueType

type Output = Self::Input

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

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

impl Method<'_> for WSMA

type Params = PeriodType

type Input = ValueType

type Output = Self::Input

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

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

impl<'a> Method<'a> for ADI

type Params = PeriodType

type Input = &'a dyn OHLCV

type Output = ValueType

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

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

impl<'a> Method<'a> for HeikinAshi

type Params = ()

type Input = &'a dyn OHLCV

type Output = Candle

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

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

impl<'a, T> Method<'a> for Past<T> where
    T: Copy + Debug, 

type Params = PeriodType

type Input = T

type Output = T

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

pub fn next(&mut self, value: T) -> T

Loading content...