use crate::{Error, Result};
use std::ops::Range;
#[derive(Clone, Debug, PartialEq)]
pub enum Series {
I64(Vec<i64>),
F32(Vec<f32>),
F64(Vec<f64>),
}
#[derive(Clone, Copy, Debug)]
pub enum SeriesView<'a> {
I64(&'a [i64]),
F32(&'a [f32]),
F64(&'a [f64]),
}
#[derive(Debug)]
pub enum SeriesViewMut<'a> {
I64(&'a mut [i64]),
F32(&'a mut [f32]),
F64(&'a mut [f64]),
}
impl Series {
pub fn view(&self) -> SeriesView<'_> {
match self {
Self::I64(v) => SeriesView::I64(v),
Self::F32(v) => SeriesView::F32(v),
Self::F64(v) => SeriesView::F64(v),
}
}
pub fn view_mut(&mut self) -> SeriesViewMut<'_> {
match self {
Self::I64(v) => SeriesViewMut::I64(v),
Self::F32(v) => SeriesViewMut::F32(v),
Self::F64(v) => SeriesViewMut::F64(v),
}
}
pub fn len(&self) -> usize {
self.view().len()
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
}
impl<'a> SeriesView<'a> {
pub fn len(self) -> usize {
match self {
Self::I64(v) => v.len(),
Self::F32(v) => v.len(),
Self::F64(v) => v.len(),
}
}
pub fn is_empty(self) -> bool {
self.len() == 0
}
pub fn slice(self, range: Range<usize>) -> Result<Self> {
if range.start > range.end || range.end > self.len() {
return Err(Error::out_of_range(
"series row range is outside the column",
));
}
Ok(match self {
Self::I64(v) => Self::I64(&v[range]),
Self::F32(v) => Self::F32(&v[range]),
Self::F64(v) => Self::F64(&v[range]),
})
}
pub(super) fn float_at(self, row: usize) -> Option<f64> {
match self {
Self::I64(_) => None,
Self::F32(v) => v.get(row).map(|&v| f64::from(v)),
Self::F64(v) => v.get(row).copied(),
}
}
}
#[derive(Clone, Debug, Default)]
pub struct DataFrame {
columns: Vec<(String, Series)>,
rows: usize,
}
impl DataFrame {
pub fn new() -> Self {
Self::default()
}
pub fn set_column(&mut self, name: impl Into<String>, series: Series) -> Result<()> {
let name = name.into();
if name.is_empty() || (!self.columns.is_empty() && series.len() != self.rows) {
return Err(Error::invalid_argument(
"frame columns require a name and equal row counts",
));
}
self.rows = series.len();
if let Some((_, column)) = self.columns.iter_mut().find(|(n, _)| *n == name) {
*column = series;
} else {
self.columns.push((name, series));
}
Ok(())
}
pub fn column(&self, name: &str) -> Result<SeriesView<'_>> {
self
.columns
.iter()
.find(|(n, _)| n == name)
.map(|(_, c)| c.view())
.ok_or_else(|| Error::invalid_argument(format!("missing frame column: {name}")))
}
pub fn column_mut(&mut self, name: &str) -> Result<SeriesViewMut<'_>> {
self
.columns
.iter_mut()
.find(|(n, _)| n == name)
.map(|(_, c)| c.view_mut())
.ok_or_else(|| Error::invalid_argument(format!("missing frame column: {name}")))
}
pub fn column_names(&self) -> impl ExactSizeIterator<Item = &str> {
self.columns.iter().map(|(n, _)| n.as_str())
}
pub fn len(&self) -> usize {
self.rows
}
pub fn is_empty(&self) -> bool {
self.rows == 0
}
}
#[derive(Clone, Copy, Debug)]
pub struct DataFrameView<'a> {
frame: &'a DataFrame,
start: usize,
end: usize,
}
impl DataFrame {
pub fn slice(&self, range: Range<usize>) -> Result<DataFrameView<'_>> {
if range.start > range.end || range.end > self.rows {
return Err(Error::out_of_range("frame row range is outside the source"));
}
Ok(DataFrameView {
frame: self,
start: range.start,
end: range.end,
})
}
}
impl<'a> DataFrameView<'a> {
pub fn len(self) -> usize {
self.end - self.start
}
pub fn is_empty(self) -> bool {
self.start == self.end
}
pub fn column(self, name: &str) -> Result<SeriesView<'a>> {
self.frame.column(name)?.slice(self.start..self.end)
}
}