Struct yata::methods::CollapseTimeframe

pub struct CollapseTimeframe<T = Candle>
where
    T: OHLCV + Clone + Add<Output = T>,
{ /* private fields */ }

Converting between different timeframes.

Parameters

Has a single parameter period: usize

period must be > 0

Input type

Input type is reference to OHLCV

Output type

Examples

use yata::prelude::*;
use yata::methods::CollapseTimeframe;

let timeframe: [Candle; 2] = [
//   open  high  low  close volume
    (10.0, 15.0, 5.0, 12.0, 1000.0).into(),
    (12.1, 17.0, 6.0, 13.0, 2000.0).into(),
];

let mut collapser = CollapseTimeframe::new(2, &timeframe[0]).unwrap();

assert_eq!(collapser.next(&timeframe[0]), None);

let collapsed = collapser.next(&timeframe[1]).unwrap();
assert_eq!(collapsed.open(), 10.0);
assert_eq!(collapsed.high(), 17.0);
assert_eq!(collapsed.low(), 5.0);
assert_eq!(collapsed.close(), 13.0);
assert_eq!(collapsed.volume(), 3000.0);

Output type is Candle

Performance

O(1)

See also Sequence’s collapse_timeframe function.

Trait Implementations

impl<T> Clone for CollapseTimeframe<T>

where T: OHLCV + Clone + Add<Output = T> + Clone,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for CollapseTimeframe<T>

where T: OHLCV + Clone + Add<Output = T> + Debug,

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for CollapseTimeframe<T>

where T: OHLCV + Clone + Add<Output = 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 CollapseTimeframe<T>

where T: OHLCV + Clone + Add<Output = T>,

type Params = usize

Method parameters

type Input = T

Input value type

type Output = Option<T>

Output value type

fn new(period: Self::Params, _candle: &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, candle: &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,

👎Deprecated

Returns memory size of the method (size, align)

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_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> Serialize for CollapseTimeframe<T>

where T: OHLCV + Clone + Add<Output = T> + Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.