Struct yata::methods::TSI

pub struct TSI { /* fields omitted */ }

True Strength Index of specified short period and long period for timeseries of type ValueType

         EMA(EMA(momentum_1, long_period), short_period)
TSI = ------------------------------------------------------
       EMA(EMA(ABS(momentum_1), long_period), short_period)

Parameters

Tuple of (short_length, long_length) (PeriodType, PeriodType)

Input type

Input type is ValueType

Output type

Output type is ValueType

Examples

use yata::prelude::*;
use yata::methods::TSI;

// TSI with short length=3, long length=10
let mut tsi = TSI::new(3, 10, 3.0).unwrap();

tsi.next(3.0);
tsi.next(6.0);

println!("{}", tsi.next(9.0));
println!("{}", tsi.next(12.0));

Performance

O(1)

Implementations

impl TSI

pub fn new(
    short_period: PeriodType,
    long_period: PeriodType,
    value: ValueType
) -> Result<Self, Error>

Creates new instance of TSI

Trait Implementations

impl Clone for TSI

fn clone(&self) -> TSI

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for TSI

impl Debug for TSI

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TSI

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

Deserialize this value from the given Serde deserializer.

impl Method<'_> for TSI

type Params = (PeriodType, PeriodType)

Method parameters

type Input = ValueType

Input value type

type Output = Self::Input

Output value type

fn new(params: 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 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 TSI

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

Serialize this value into the given Serde serializer.