Add series operations for cumulative sum and performance measurement

src/main.rs

@@ -1,7 +1,7 @@
 use chrono::NaiveDate;
 use rand::Rng; // Import thread_rng for random number generation
 use rustframe::frame::{Frame, RowIndex};
-use rustframe::matrix::{BoolMatrix, BoolOps, Matrix, SeriesOps}; // Explicitly list used items
+use rustframe::matrix::{BoolMatrix, BoolOps, Broadcastable, Matrix, SeriesOps}; // Explicitly list used items
 use rustframe::utils::{BDateFreq, BDatesList};
 use std::time::Instant; // Use Instant for timing
 
@@ -37,6 +37,53 @@ fn generate_random_frame(column_labels: Vec<String>, dates_vec: Vec<NaiveDate>)
     )
 }
 
+fn series_operations() {
+    // create a frame of 1s of len 1000 with 1000 columns
+    let num_cols = 1000;
+    let num_rows = 1000;
+    let frame = Frame::new(
+        Matrix::from_vec(vec![1.0; num_cols * num_rows], num_rows, num_cols),
+        generate_column_labels(num_cols),
+        Some(RowIndex::Date(
+            BDatesList::from_n_periods("2000-01-01".to_string(), BDateFreq::Daily, num_rows)
+                .unwrap()
+                .list()
+                .unwrap(),
+        )),
+    );
+    let cum_sum_start_time = Instant::now();
+    let cum_sum = Frame::new(
+        frame.matrix().cumsum_horizontal(),
+        frame.columns().to_vec(),
+        Some(frame.index().clone()),
+    );
+    let cum_sum_duration = cum_sum_start_time.elapsed();
+    println!("Cumulative sum duration: {:?}", cum_sum_duration);
+
+    // Check if the cumulative sum is correct
+    let check_start_time = Instant::now();
+    cum_sum.columns().iter().enumerate().for_each(|(i, col)| {
+        assert_eq!(cum_sum.column(col), vec![(i + 1) as f64; num_rows]);
+    });
+    let check_duration = check_start_time.elapsed();
+    println!("Cumulative sum check duration: {:?}", check_duration);
+
+    let cum_sum_start_time = Instant::now();
+    Frame::new(
+        frame.matrix().cumsum_horizontal(),
+        frame.columns().to_vec(),
+        Some(frame.index().clone()),
+    )
+    .matrix()
+    .iter_columns()
+    .enumerate()
+    .for_each(|(i, col)| {
+        assert_eq!(col, vec![(i + 1) as f64; num_rows]);
+    });
+    let cum_sum_duration = cum_sum_start_time.elapsed();
+    println!("Cumulative sum and check duration: {:?}", cum_sum_duration);
+}
+
 fn main() {
     // Start overall timing
     let total_start_time = Instant::now();
@@ -58,9 +105,11 @@ fn main() {
     // --- Setup Data (Dates and Labels) ---
     let setup_data_start_time = Instant::now();
 
-    let dates_list = BDatesList::from_n_periods(start_date_str, frequency, num_periods).unwrap();
-    let dates_vec: Vec<NaiveDate> = dates_list.list().unwrap().to_vec();
-    let column_labels: Vec<String> = generate_column_labels(num_columns);
+    let dates_vec = BDatesList::from_n_periods(start_date_str, frequency, num_periods)
+        .unwrap()
+        .list()
+        .unwrap();
+    let column_labels = generate_column_labels(num_columns);
 
     let setup_data_duration = setup_data_start_time.elapsed();
     println!(
@@ -128,18 +177,26 @@ fn main() {
 
     // Complex operation
     let complex_start_time = Instant::now();
-    let frame_r = &(&(&(&(&frame_a * &frame_b) / &frame_b) - &frame_a) + &frame_a) - &frame_a;
+    let frame_r = (&(&(&(&(&frame_a * &frame_b) / &frame_b) - &frame_a) + &frame_a) - &frame_a)
+        .matrix()
+        .lt_elementwise(0.0000001)
+        .all();
 
-    let frame_r = frame_r.matrix().lt_elementwise(0.0000001);
-    let complex_result = frame_r.all();
+    let complex_result = frame_r;
     let complex_duration = complex_start_time.elapsed();
+
     println!("Complex operation duration: {:?}", complex_duration);
     println!(
         "Complex operation result (expected true): {:?}",
         complex_result
     );
-    println!("-----------------------");
 
+    // --- Series Operations ---
+    let series_ops_start_time = Instant::now();
+    series_operations();
+    let series_ops_duration = series_ops_start_time.elapsed();
+    println!("Series operations duration: {:?}", series_ops_duration);
+    println!("-----------------------");
     // End overall timing
     let total_duration = total_start_time.elapsed();
     println!(