use super::{DataFrame, DataFrameView, Dataset, Sample, SeriesView};
use crate::{Engine, Error, Matrix, Result};
use std::ops::Range;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum UnixTimeUnit {
Seconds,
Milliseconds,
Microseconds,
Nanoseconds,
}
#[derive(Clone, Copy, Debug)]
pub struct OhlcvView<'a> {
timestamps: &'a [i64],
unit: UnixTimeUnit,
columns: [SeriesView<'a>; 5],
}
impl<'a> OhlcvView<'a> {
pub fn new_from_frame(frame: &'a DataFrame, unit: UnixTimeUnit) -> Result<Self> {
Self::new_from_frame_view(frame.slice(0..frame.len())?, unit)
}
pub fn new_from_frame_view(frame: DataFrameView<'a>, unit: UnixTimeUnit) -> Result<Self> {
let SeriesView::I64(timestamps) = frame.column("timestamp")? else {
return Err(Error::invalid_argument(
"OHLCV timestamps must be exact I64 integers",
));
};
let columns = [
frame.column("open")?,
frame.column("high")?,
frame.column("low")?,
frame.column("close")?,
frame.column("volume")?,
];
if columns
.iter()
.any(|column| matches!(column, SeriesView::I64(_)))
{
return Err(Error::invalid_argument(
"OHLCV prices and volume require F32 or F64 columns",
));
}
if timestamps.windows(2).any(|pair| pair[0] >= pair[1]) {
return Err(Error::invalid_argument(
"OHLCV timestamps must be strictly increasing",
));
}
for row in 0..timestamps.len() {
let values = columns.map(|column| column.float_at(row).expect("frame lengths validated"));
let [open, high, low, close, volume] = values;
if values.iter().any(|v| !v.is_finite())
|| volume < 0.0
|| low > open
|| low > close
|| high < open
|| high < close
|| low > high
{
return Err(Error::invalid_argument(format!(
"invalid OHLCV candle at row {row}"
)));
}
}
Ok(Self {
timestamps,
unit,
columns,
})
}
pub fn timestamps(self) -> &'a [i64] {
self.timestamps
}
pub fn time_unit(self) -> UnixTimeUnit {
self.unit
}
pub fn columns(self) -> [SeriesView<'a>; 5] {
self.columns
}
pub fn len(self) -> usize {
self.timestamps.len()
}
pub fn is_empty(self) -> bool {
self.timestamps.is_empty()
}
pub fn slice(self, range: Range<usize>) -> Result<Self> {
if range.start > range.end || range.end > self.len() {
return Err(Error::out_of_range("OHLCV row range is outside the source"));
}
let columns = [
self.columns[0].slice(range.clone())?,
self.columns[1].slice(range.clone())?,
self.columns[2].slice(range.clone())?,
self.columns[3].slice(range.clone())?,
self.columns[4].slice(range.clone())?,
];
Ok(Self {
timestamps: &self.timestamps[range],
unit: self.unit,
columns,
})
}
pub fn chronological_split(self, train_end: usize, validation_end: usize) -> Result<[Self; 3]> {
if train_end > validation_end || validation_end > self.len() {
return Err(Error::out_of_range(
"OHLCV split boundaries must be ordered and within rows",
));
}
Ok([
self.slice(0..train_end)?,
self.slice(train_end..validation_end)?,
self.slice(validation_end..self.len())?,
])
}
}
#[derive(Clone, Copy, Debug)]
pub struct OhlcvWindowConfig {
pub lookback: usize,
pub horizon: usize,
pub stride: usize,
}
#[derive(Clone, Copy, Debug)]
pub struct OhlcvWindows<'a> {
source: OhlcvView<'a>,
config: OhlcvWindowConfig,
count: i64,
}
impl<'a> OhlcvWindows<'a> {
pub fn len(&self) -> i64 {
self.count
}
pub fn is_empty(&self) -> bool {
self.count == 0
}
pub fn new(source: OhlcvView<'a>, config: OhlcvWindowConfig) -> Result<Self> {
let span = config
.lookback
.checked_add(config.horizon)
.ok_or_else(|| Error::invalid_argument("OHLCV window extent overflow"))?;
if config.lookback == 0
|| config.horizon == 0
|| config.stride == 0
|| config.lookback.checked_mul(5).is_none()
{
return Err(Error::invalid_argument(
"OHLCV windows require positive checked extents and stride",
));
}
let count = if source.len() < span {
0
} else {
(source.len() - span) / config.stride + 1
};
let count = i64::try_from(count)
.map_err(|_| Error::invalid_argument("OHLCV window count exceeds i64"))?;
Ok(Self {
source,
config,
count,
})
}
pub fn window(&self, index: i64) -> Result<(OhlcvView<'a>, OhlcvView<'a>)> {
if index < 0 || index >= self.count {
return Err(Error::out_of_range("OHLCV window index outside dataset"));
}
let start = index as usize * self.config.stride;
let middle = start + self.config.lookback;
Ok((
self.source.slice(start..middle)?,
self.source.slice(middle..middle + self.config.horizon)?,
))
}
}
pub struct DsOhlcv<'a> {
engine: &'a Engine,
windows: OhlcvWindows<'a>,
}
impl<'a> DsOhlcv<'a> {
pub fn new(engine: &'a Engine, windows: OhlcvWindows<'a>) -> Self {
Self { engine, windows }
}
pub fn windows(&self) -> &OhlcvWindows<'a> {
&self.windows
}
}
impl Dataset for DsOhlcv<'_> {
fn len(&self) -> i64 {
self.windows.len()
}
fn get_item(&self, index: i64) -> Result<Matrix> {
let (input, _) = self.windows.window(index)?;
let mut values = Vec::new();
values
.try_reserve_exact(input.len() * 5)
.map_err(|_| Error::resource_exhausted("OHLCV feature packing allocation failed"))?;
for row in 0..input.len() {
for column in input.columns {
let value = column.float_at(row).expect("validated float column") as f32;
if !value.is_finite() {
return Err(Error::invalid_argument("OHLCV value exceeds FP32 range"));
}
values.push(value);
}
}
Matrix::new_from_slice(self.engine, vec![input.len(), 5], &values)
}
fn get_sample(&self, index: i64) -> Result<Sample> {
let (_, future) = self.windows.window(index)?;
let mut labels = Vec::new();
labels
.try_reserve_exact(future.len())
.map_err(|_| Error::resource_exhausted("OHLCV label packing allocation failed"))?;
for row in 0..future.len() {
let value = future.columns[3]
.float_at(row)
.expect("validated close column") as f32;
if !value.is_finite() {
return Err(Error::invalid_argument("OHLCV close exceeds FP32 range"));
}
labels.push(value);
}
let x = self.get_item(index)?;
let y = Matrix::new_from_slice(self.engine, vec![future.len()], &labels)?;
Ok(Sample::new_with_label(x, y))
}
}