use ferrochart_core::data::Timestamp;
use ferrochart_core::error::{Error, Result};
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub enum Side {
Buy,
Sell,
#[default]
Unknown,
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct TickColumns {
pub time: Vec<Timestamp>,
pub price: Vec<f64>,
pub size: Vec<f64>,
pub side: Vec<Side>,
}
impl TickColumns {
pub fn len(&self) -> usize {
self.time.len()
}
pub fn is_empty(&self) -> bool {
self.time.is_empty()
}
pub(crate) fn get(&self, i: usize) -> (Timestamp, f64, f64, Side) {
(
self.time[i],
self.price[i],
self.size[i],
self.side.get(i).copied().unwrap_or_default(),
)
}
pub(crate) fn check(&self, after: Option<Timestamp>) -> Result<()> {
let n = self.time.len();
if self.price.len() != n
|| self.size.len() != n
|| !(self.side.is_empty() || self.side.len() == n)
{
return Err(Error::InvalidArgument(
"trade columns must have the same length",
));
}
let mut prev = after.unwrap_or(Timestamp::MIN);
for (i, &t) in self.time.iter().enumerate() {
if t < prev {
return Err(Error::TimeNotIncreasing { index: i });
}
prev = t;
}
if self.price.iter().any(|p| !p.is_finite()) {
return Err(Error::InvalidArgument("trade prices must be finite"));
}
if self.size.iter().any(|s| !(s.is_finite() && *s >= 0.0)) {
return Err(Error::InvalidArgument(
"trade sizes must be finite and non-negative",
));
}
Ok(())
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq)]
pub struct TickRule {
last: Option<(f64, Side)>,
}
impl TickRule {
pub fn classify(&mut self, price: f64, side: Side) -> Side {
let side = match (side, self.last) {
(Side::Unknown, Some((p, s))) => match price.partial_cmp(&p) {
Some(core::cmp::Ordering::Greater) => Side::Buy,
Some(core::cmp::Ordering::Less) => Side::Sell,
_ => s,
},
(Side::Unknown, None) => Side::Buy,
(s, _) => s,
};
self.last = Some((price, side));
side
}
}