#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};
use crate::core::{Action, Error, Method, MovingAverageConstructor, Source, ValueType, OHLCV};
use crate::core::{IndicatorConfig, IndicatorInstance, IndicatorResult};
use crate::helpers::MA;
#[derive(Debug, Clone, Copy)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct Envelopes<M: MovingAverageConstructor = MA> {
pub ma: M,
pub k: ValueType,
pub source: Source,
pub source2: Source,
}
impl<M: MovingAverageConstructor> IndicatorConfig for Envelopes<M> {
type Instance = EnvelopesInstance<M>;
const NAME: &'static str = "Envelopes";
fn init<T: OHLCV>(self, candle: &T) -> Result<Self::Instance, Error> {
if !self.validate() {
return Err(Error::WrongConfig);
}
let cfg = self;
let src = candle.source(cfg.source);
Ok(Self::Instance {
ma: cfg.ma.init(src)?, k_high: 1.0 + cfg.k,
k_low: 1.0 - cfg.k,
cfg,
})
}
fn validate(&self) -> bool {
self.k > 0.0 && self.ma.ma_period() > 1
}
fn set(&mut self, name: &str, value: String) -> Result<(), Error> {
match name {
"ma" => match value.parse() {
Err(_) => return Err(Error::ParameterParse(name.to_string(), value.to_string())),
Ok(value) => self.ma = value,
},
"k" => match value.parse() {
Err(_) => return Err(Error::ParameterParse(name.to_string(), value.to_string())),
Ok(value) => self.k = value,
},
"source" => match value.parse() {
Err(_) => return Err(Error::ParameterParse(name.to_string(), value.to_string())),
Ok(value) => self.source = value,
},
"source2" => match value.parse() {
Err(_) => return Err(Error::ParameterParse(name.to_string(), value.to_string())),
Ok(value) => self.source2 = value,
},
_ => {
return Err(Error::ParameterParse(name.to_string(), value));
}
};
Ok(())
}
fn size(&self) -> (u8, u8) {
(3, 1)
}
}
impl Default for Envelopes<MA> {
fn default() -> Self {
Self {
ma: MA::SMA(20),
k: 0.1,
source: Source::Close,
source2: Source::Close,
}
}
}
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct EnvelopesInstance<M: MovingAverageConstructor = MA> {
cfg: Envelopes<M>,
ma: M::Instance,
k_high: ValueType,
k_low: ValueType,
}
impl<M: MovingAverageConstructor> IndicatorInstance for EnvelopesInstance<M> {
type Config = Envelopes<M>;
fn config(&self) -> &Self::Config {
&self.cfg
}
fn next<T: OHLCV>(&mut self, candle: &T) -> IndicatorResult {
let src = candle.source(self.cfg.source);
let v = self.ma.next(&src);
let (value1, value2) = (v * self.k_high, v * self.k_low);
let src2 = candle.source(self.cfg.source2);
let signal = (src2 < value2) as i8 - (src2 > value1) as i8;
IndicatorResult::new(&[value1, value2, src2], &[Action::from(signal)])
}
}