magnus167/rustframe
1
0
Fork 0
mirror of https://github.com/Magnus167/rustframe.git synced 2025-08-20 07:09:59 +00:00
Code Issues Packages Projects Releases Wiki Activity

updating comments in frame implementation

Browse Source
This commit is contained in:
Palash Tyagi 2025-04-23 22:22:34 +01:00
parent de6b419911
commit f2c4f297a6
1 changed files with 32 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

67
src/frame/base.rs
View File

@ -511,9 +511,6 @@ impl<T: Clone + PartialEq> Frame<T> {
} }
} }
// Trait for resolving logical to physical row indices // Trait for resolving logical to physical row indices
/// Internal trait to abstract the logic for looking up physical row indices. /// Internal trait to abstract the logic for looking up physical row indices.
trait RowIndexLookupHelper<Idx> { trait RowIndexLookupHelper<Idx> {
@ -608,9 +605,6 @@ impl<'a, T: Clone + PartialEq + fmt::Debug> fmt::Debug for FrameRowView<'a, T> {
} }
} }
impl<'a, T: Clone + PartialEq> FrameRowView<'a, T> { impl<'a, T: Clone + PartialEq> FrameRowView<'a, T> {
/// Returns a reference to the element at the given physical column index. /// Returns a reference to the element at the given physical column index.
/// Panics with a descriptive message if `col_idx` is out of bounds. /// Panics with a descriptive message if `col_idx` is out of bounds.
@ -765,12 +759,7 @@ impl<'a, T: Clone + PartialEq> IndexMut<usize> for FrameRowViewMut<'a, T> {
} }
} }
/// Enables immutable access to a column's data via `frame["col_name"]`.
/* ---------- Frame Indexing Implementation ---------- */
/// Allows accessing a column's data as a slice using `frame["col_name"]`.
impl<T: Clone + PartialEq> Index<&str> for Frame<T> { impl<T: Clone + PartialEq> Index<&str> for Frame<T> {
type Output = [T]; type Output = [T];
#[inline] #[inline]
@ -778,7 +767,8 @@ impl<T: Clone + PartialEq> Index<&str> for Frame<T> {
self.column(name) self.column(name)
} }
} }
/// Allows mutating a column's data as a slice using `frame["col_name"]`.
/// Enables mutable access to a column's data via `frame["col_name"]`.
impl<T: Clone + PartialEq> IndexMut<&str> for Frame<T> { impl<T: Clone + PartialEq> IndexMut<&str> for Frame<T> {
#[inline] #[inline]
fn index_mut(&mut self, name: &str) -> &mut Self::Output { fn index_mut(&mut self, name: &str) -> &mut Self::Output {
@ -786,8 +776,9 @@ impl<T: Clone + PartialEq> IndexMut<&str> for Frame<T> {
} }
} }
/* ---------- Element-wise numerical ops ---------- */ /* ---------- Element-wise Arithmetic Operations ---------- */
/// Macro to implement element-wise binary operations (+, -, *, /) for Frames. /// Generates implementations for element-wise arithmetic (`+`, `-`, `*`, `/`) on `Frame<T>`.
/// Panics if column labels or row indices differ between operands.
macro_rules! impl_elementwise_frame_op { macro_rules! impl_elementwise_frame_op {
($OpTrait:ident, $method:ident) => { ($OpTrait:ident, $method:ident) => {
impl<'a, 'b, T> std::ops::$OpTrait<&'b Frame<T>> for &'a Frame<T> impl<'a, 'b, T> std::ops::$OpTrait<&'b Frame<T>> for &'a Frame<T>
@ -795,11 +786,12 @@ macro_rules! impl_elementwise_frame_op {
T: Clone + PartialEq + std::ops::$OpTrait<Output = T>, T: Clone + PartialEq + std::ops::$OpTrait<Output = T>,
{ {
type Output = Frame<T>; type Output = Frame<T>;
fn $method(self, rhs: &'b Frame<T>) -> Frame<T> { fn $method(self, rhs: &'b Frame<T>) -> Frame<T> {
// 1. Check for compatibility // Verify matching schema
if self.column_names != rhs.column_names { if self.column_names != rhs.column_names {
panic!( panic!(
"Element-wise op ({}): column names mismatch. Left: {:?}, Right: {:?}", "Element-wise {}: column names do not match. Left: {:?}, Right: {:?}",
stringify!($method), stringify!($method),
self.column_names, self.column_names,
rhs.column_names rhs.column_names
@ -807,22 +799,22 @@ macro_rules! impl_elementwise_frame_op {
} }
if self.index != rhs.index { if self.index != rhs.index {
panic!( panic!(
"Element-wise op ({}): row indices mismatch. Left: {:?}, Right: {:?}", "Element-wise {}: row indices do not match. Left: {:?}, Right: {:?}",
stringify!($method), stringify!($method),
self.index, self.index,
rhs.index rhs.index
); );
} }
// 2. Perform operation on underlying matrices // Apply the matrix operation
let result_matrix = (&self.matrix).$method(&rhs.matrix); let result_matrix = (&self.matrix).$method(&rhs.matrix);
// 3. Construct the new Frame // Determine index for the result
// Clone index unless it's Range, then pass None to use default construction
let new_index = match self.index { let new_index = match self.index {
RowIndex::Range(_) => None, // Frame::new handles None correctly RowIndex::Range(_) => None,
_ => Some(self.index.clone()), // Clone Int or Date index _ => Some(self.index.clone()),
}; };
Frame::new(result_matrix, self.column_names.clone(), new_index) Frame::new(result_matrix, self.column_names.clone(), new_index)
} }
} }
@ -833,17 +825,19 @@ impl_elementwise_frame_op!(Sub, sub);
impl_elementwise_frame_op!(Mul, mul); impl_elementwise_frame_op!(Mul, mul);
impl_elementwise_frame_op!(Div, div); impl_elementwise_frame_op!(Div, div);
/* ---------- Boolean-specific bitwise ops ---------- */ /* ---------- Boolean Bitwise Operations ---------- */
/// Macro to implement element-wise binary bitwise operations (&, |, ^) for Frames of bool. /// Generates implementations for element-wise bitwise operations (`&`, `|`, `^`) on `Frame<bool>`.
/// Panics if column labels or row indices differ between operands.
macro_rules! impl_bitwise_frame_op { macro_rules! impl_bitwise_frame_op {
($OpTrait:ident, $method:ident) => { ($OpTrait:ident, $method:ident) => {
impl<'a, 'b> std::ops::$OpTrait<&'b Frame<bool>> for &'a Frame<bool> { impl<'a, 'b> std::ops::$OpTrait<&'b Frame<bool>> for &'a Frame<bool> {
type Output = Frame<bool>; type Output = Frame<bool>;
fn $method(self, rhs: &'b Frame<bool>) -> Frame<bool> { fn $method(self, rhs: &'b Frame<bool>) -> Frame<bool> {
// 1. Check for compatibility // Verify matching schema
if self.column_names != rhs.column_names { if self.column_names != rhs.column_names {
panic!( panic!(
"Bitwise op ({}): column names mismatch. Left: {:?}, Right: {:?}", "Bitwise {}: column names do not match. Left: {:?}, Right: {:?}",
stringify!($method), stringify!($method),
self.column_names, self.column_names,
rhs.column_names rhs.column_names
@ -851,21 +845,22 @@ macro_rules! impl_bitwise_frame_op {
} }
if self.index != rhs.index { if self.index != rhs.index {
panic!( panic!(
"Bitwise op ({}): row indices mismatch. Left: {:?}, Right: {:?}", "Bitwise {}: row indices do not match. Left: {:?}, Right: {:?}",
stringify!($method), stringify!($method),
self.index, self.index,
rhs.index rhs.index
); );
} }
// 2. Perform operation on underlying matrices // Apply the matrix operation
let result_matrix = (&self.matrix).$method(&rhs.matrix); let result_matrix = (&self.matrix).$method(&rhs.matrix);
// 3. Construct the new Frame // Determine index for the result
let new_index = match self.index { let new_index = match self.index {
RowIndex::Range(_) => None, RowIndex::Range(_) => None,
_ => Some(self.index.clone()), _ => Some(self.index.clone()),
}; };
Frame::new(result_matrix, self.column_names.clone(), new_index) Frame::new(result_matrix, self.column_names.clone(), new_index)
} }
} }
@ -875,19 +870,21 @@ impl_bitwise_frame_op!(BitAnd, bitand);
impl_bitwise_frame_op!(BitOr, bitor); impl_bitwise_frame_op!(BitOr, bitor);
impl_bitwise_frame_op!(BitXor, bitxor); impl_bitwise_frame_op!(BitXor, bitxor);
/// Implements element-wise logical NOT (!) for Frames of bool. Consumes the frame. /// Implements logical NOT (`!`) for `Frame<bool>`, consuming the frame.
impl Not for Frame<bool> { impl Not for Frame<bool> {
type Output = Frame<bool>; type Output = Frame<bool>;
fn not(self) -> Frame<bool> { fn not(self) -> Frame<bool> {
// Perform operation on underlying matrix (Matrix::not consumes the matrix) // Apply NOT to the underlying matrix
let result_matrix = !self.matrix; let result_matrix = !self.matrix;
// Construct the new Frame (index can be moved as self is consumed) // Determine index for the result
let new_index = match self.index { let new_index = match self.index {
RowIndex::Range(_) => None, RowIndex::Range(_) => None,
_ => Some(self.index), // Move index _ => Some(self.index),
}; };
Frame::new(result_matrix, self.column_names, new_index) // Move column names
Frame::new(result_matrix, self.column_names, new_index)
} }
} }