Enum yata::helpers::MAInstance

#[non_exhaustive]
pub enum MAInstance {
    SMA(SMA),
    WMA(WMA),
    HMA(HMA),
    RMA(RMA),
    EMA(EMA),
    DMA(DMA),
    DEMA(DEMA),
    TMA(TMA),
    TEMA(TEMA),
    WSMA(WSMA),
    SMM(SMM),
    SWMA(SWMA),
    TRIMA(TRIMA),
    LinReg(LinReg),
    Vidya(Vidya),
}

Default moving average instance for constructor

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

SMA(SMA)

Tuple Fields

0: SMA

Simple Moving Average

WMA(WMA)

Tuple Fields

0: WMA

Weighed Moving Average

HMA(HMA)

Tuple Fields

0: HMA

Hull Moving Average

RMA(RMA)

Tuple Fields

0: RMA

Running Moving Average

EMA(EMA)

Tuple Fields

0: EMA

Exponential Moving Average

DMA(DMA)

Tuple Fields

0: DMA

Double Exponential Moving Average

DEMA(DEMA)

Tuple Fields

0: DEMA

Another type of Double Exponential Moving Average

TMA(TMA)

Tuple Fields

0: TMA

Triple Exponential Moving Average

TEMA(TEMA)

Tuple Fields

0: TEMA

Another type of Triple Exponential Moving Average

WSMA(WSMA)

Tuple Fields

0: WSMA

Wilder’s smoothing average

SMM(SMM)

Tuple Fields

0: SMM

Simple Moving Median

SWMA(SWMA)

Tuple Fields

0: SWMA

Symmetrically Weighted Moving Average

TRIMA(TRIMA)

Tuple Fields

0: TRIMA

Triangular Moving Average

LinReg(LinReg)

Tuple Fields

0: LinReg

Linear regression

Vidya(Vidya)

Tuple Fields

0: Vidya

Variable Index Dynamic Average

Trait Implementations

impl Clone for MAInstance

fn clone(&self) -> MAInstance

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for MAInstance

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MAInstance

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

Deserialize this value from the given Serde deserializer.

impl Method for MAInstance

type Input = ValueType

Input value type

type Output = ValueType

Output value type

type Params = MAInstanceCreationProtection

Method parameters

fn new(_: Self::Params, _: &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)

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, 

👎 Deprecated

Returns memory size of the method (size, align)

fn over<S>(&mut self, inputs: S) -> Vec<Self::Output> where
    S: Sequence<Self::Input>,
    Self::Input: Sized,
    Self: Sized, 

Iterates the Method over the given inputs slice and returns Vec of output values.

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_over<S>(
    parameters: Self::Params,
    inputs: S
) -> Result<Vec<Self::Output>, Error> where
    S: Sequence<Self::Input>,
    Self::Input: Sized,
    Self: Sized, 

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: &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 Serialize for MAInstance

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

Serialize this value into the given Serde serializer.

impl MovingAverage for MAInstance