Struct yata::methods::Renko

pub struct Renko { /* fields omitted */ }

Converts timeseries to Renko timeseries

Renko is very different from the simple timeseries. On each step it may generate any amount of blocks or not genereate it at all. That’s why it needs to be implement throw three different structures:

• Renko method itself.

When call Method::next on Renko, it always returns RenkoOutput.

• RenkoOutput which is Renko’s method output type.

It implements an Iterator trait for generating RenkoBlocks after each step of calling Method::next on Renko. RenkoOutput may produce any amount of RenkoBlocks or may not produce it at all.

• RenkoBlock is final entity of Renko chart.

It has open and close values which are similar to corresponding OHLCV’s values.

So the final workflow is like that:

1. Call Renko’s Method::next on some ValueType and get RenkoOutput.
2. Iterate over taken RenkoOutput to get some (or none) RenkoBlocks.
3. Use produced RenkoBlocks on your own.

Parameters

Has a tuple of 2 parameters (size: ValueType, source: Source)

• size: ValueType. Represents relative block size.

size must be in range (0.0; 1.0)

• source: Source. Represents which value of input’s OHLCV it will use.

use yata::prelude::*;
use yata::core::Source;
use yata::methods::Renko;
let first_timeseries_value = Candle { close: 123.456, ..Candle::default() };
let renko = Renko::new((0.01, Source::Close), &first_timeseries_value); // creates a Renko method with relative block size of 1%.

Input type

Input type is reference to OHLCV

Output type

Input type is RenkoOutput

Examples

use yata::prelude::*;
use yata::core::Source;
use yata::methods::Renko;

// Here we just creating `Vec` of `OHLCV`s with only `close` value inside  
let inputs = (&[100.0, 100.5, 101.506, 105.0, 102.0, 101.4, 100.0])
    .iter()
    .map(|&v| Candle {
        close: v,
        ..Candle::default()
    })
    .collect::<Vec<_>>();
let mut renko = Renko::new((0.01, Source::Close), &inputs[0]).unwrap(); // renko with relative block size of 1%

assert!(renko.next(&inputs[0]).is_empty());
assert!(renko.next(&inputs[1]).is_empty());
assert_eq!(renko.next(&inputs[2]).len(), 1);
let blocks = renko.next(&inputs[3]);
assert_eq!(blocks.len(), 3);
blocks.for_each(|block| { println!("{:?}", &block); });
assert_eq!(renko.next(&inputs[4]).len(), 1);
assert_eq!(renko.next(&inputs[5]).len(), 1);
assert_eq!(renko.next(&inputs[6]).len(), 1);

Performance

O(1)

See also

• HeikinAshi

Trait Implementations

impl Clone for Renko

fn clone(&self) -> Renko

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for Renko

impl Debug for Renko

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Renko

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

Deserialize this value from the given Serde deserializer.

impl<'a> Method<'a> for Renko

type Params = (ValueType, Source)

Method parameters

type Input = &'a dyn OHLCV

Input value type

type Output = RenkoOutput

Output value type

fn new(
    (brick_size, src): 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, 

Returns memory size of the method (size, align)

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.

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.

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.

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.

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

Creates a function from the Method instance

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

impl Serialize for Renko

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

Serialize this value into the given Serde serializer.