pub trait Method {
type Params;
type Input: ?Sized;
type Output;
// Required methods
fn new(
parameters: Self::Params,
initial_value: &Self::Input
) -> Result<Self, Error>
where Self: Sized;
fn next(&mut self, value: &Self::Input) -> Self::Output;
// Provided methods
fn with_history(
parameters: Self::Params,
initial_value: &Self::Input
) -> Result<WithHistory<Self, Self::Output>, Error>
where Self: Sized,
Self::Output: Debug + Clone { ... }
fn with_last_value(
parameters: Self::Params,
initial_value: &Self::Input
) -> Result<WithLastValue<Self, Self::Output>, Error>
where Self: Sized,
Self::Output: Debug + Clone { ... }
fn name(&self) -> &str { ... }
fn memsize(&self) -> (usize, usize)
where Self: Sized { ... }
fn over<S>(&mut self, inputs: S) -> Vec<Self::Output>
where S: Sequence<Self::Input>,
Self::Input: Sized,
Self: Sized { ... }
fn apply<T, S>(&mut self, sequence: &mut S)
where S: Sequence<T> + AsMut<[T]> + ?Sized,
Self: Method<Input = T, Output = T> + Sized { ... }
fn new_over<S>(
parameters: Self::Params,
inputs: S
) -> Result<Vec<Self::Output>, Error>
where S: Sequence<Self::Input>,
Self::Input: Sized,
Self: Sized { ... }
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 { ... }
fn into_fn<'a>(
self
) -> Box<dyn FnMut(&'a <Self as Method>::Input) -> <Self as Method>::Output>
where Self: Sized + 'static,
Self::Input: 'static { ... }
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 { ... }
}Expand description
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(&mut 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(&mut 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.
Required Associated Types§
Required Methods§
Provided Methods§
sourcefn with_history(
parameters: Self::Params,
initial_value: &Self::Input
) -> Result<WithHistory<Self, Self::Output>, Error>
fn with_history( parameters: Self::Params, initial_value: &Self::Input ) -> Result<WithHistory<Self, Self::Output>, Error>
Creates an instance of the method with given parameters and initial value, wrapped by historical data holder
sourcefn with_last_value(
parameters: Self::Params,
initial_value: &Self::Input
) -> Result<WithLastValue<Self, Self::Output>, Error>
fn with_last_value( parameters: Self::Params, initial_value: &Self::Input ) -> Result<WithLastValue<Self, Self::Output>, Error>
Creates an instance of the method with given parameters and initial value, wrapped by last produced value holder
sourcefn memsize(&self) -> (usize, usize)where
Self: Sized,
👎Deprecated
fn memsize(&self) -> (usize, usize)where
Self: Sized,
Returns memory size of the method (size, align)
sourcefn over<S>(&mut self, inputs: S) -> Vec<Self::Output>
fn over<S>(&mut self, inputs: S) -> Vec<Self::Output>
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());sourcefn new_over<S>(
parameters: Self::Params,
inputs: S
) -> Result<Vec<Self::Output>, Error>
fn new_over<S>( parameters: Self::Params, inputs: S ) -> Result<Vec<Self::Output>, Error>
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.
sourcefn new_apply<T, S>(
parameters: Self::Params,
sequence: &mut S
) -> Result<(), Error>
fn new_apply<T, S>( parameters: Self::Params, sequence: &mut S ) -> Result<(), Error>
Creates new Method instance and applies it to the sequence.