refactor: move the fenwick tree data structure to the project

Author: ThiagoFBastos

data structures/Fenwick Tree 2D.rs …g/src/data_structures/fenwick_tree_2d.rsdata structures/Fenwick Tree 2D.rs renamed to competitive_programming/src/data_structures/fenwick_tree_2d.rs data structures/Fenwick Tree 2D.rs renamed to competitive_programming/src/data_structures/fenwick_tree_2d.rs

@@ -1,29 +1,23 @@
-/*
- * Author: Thiago Felipe Bastos da Silva
- * Created: 2025-12-28
- * Description: Simple Fenwick Tree 2D data structure for sum operations.
- */
+use std::ops::{Add, AddAssign, Sub};
 
-struct FenwickTree2D<T> {
+pub struct FenwickTree2D<T> {
     data: Vec<Vec<T>>,
-    rows: usize,
-    columns: usize
+    pub rows: usize,
+    pub columns: usize,
 }
 
 impl<T: Default + Copy + AddAssign + Sub<Output = T> + Add<Output = T>> FenwickTree2D<T> {
-
     /**
      * create a new instance of FenwickTree2D
      * @param rows the number of rows of the matrix
      * @param columns the number of columns of the matrix
      * @return a new FenwickTree2D
      */
-    fn new(rows: usize, columns: usize) -> Self {
-
+    pub fn new(rows: usize, columns: usize) -> Self {
         Self {
-            data: vec![vec![T::default(); columns + 1]; rows + 1], 
-            rows: rows, 
-            columns: columns
+            data: vec![vec![T::default(); columns + 1]; rows + 1],
+            rows,
+            columns,
         }
     }
 
@@ -49,14 +43,15 @@ impl<T: Default + Copy + AddAssign + Sub<Output = T> + Add<Output = T>> FenwickT
             x -= x & -x;
         }
 
-        return answer;
+        answer
     }
 
     /**
      * calculate the sum of all values inside the submatrix (x0, y0) x (x1, y1)
      */
-    fn calculate(&self, x0: i32, y0: i32, x1: i32, y1: i32) -> T {
-        return self.query(x1, y1) - self.query(x1, y0 - 1) - self.query(x0 - 1, y1) + self.query(x0 - 1, y0 - 1);
+    pub fn calculate(&self, x0: i32, y0: i32, x1: i32, y1: i32) -> T {
+        self.query(x1, y1) - self.query(x1, y0 - 1) - self.query(x0 - 1, y1)
+            + self.query(x0 - 1, y0 - 1)
     }
 
     /**
@@ -65,12 +60,11 @@ impl<T: Default + Copy + AddAssign + Sub<Output = T> + Add<Output = T>> FenwickT
      * @param y the column position of the matrix
      * @param value the number that will be added to position (x, y)
      */
-    fn update(&mut self, mut x: i32, mut y: i32, value: T) {
+    pub fn update(&mut self, mut x: i32, mut y: i32, value: T) {
         x += 1;
         y += 1;
 
         while x as usize <= self.rows {
-
             let mut k = y;
 
             while k as usize <= self.columns {

competitive_programming/src/data_structures/mod.rs

@@ -1,10 +1,12 @@
 mod fenwick_tree;
+mod fenwick_tree_2d;
 mod recursive_segment_tree;
 mod segment_tree;
 mod sparse_table;
 mod union_find;
 
 pub use fenwick_tree::{FenwickTree, FenwickTreeConstants};
+pub use fenwick_tree_2d::FenwickTree2D;
 pub use recursive_segment_tree::SegTree as RecursiveSegTree;
 pub use segment_tree::{SegTree, SegTreeConstants};
 pub use sparse_table::SparseTable;

competitive_programming/tests/data_structures/fenwick_tree_2d.rs

@@ -0,0 +1,40 @@
+#[cfg(test)]
+mod tests {
+    use competitive_programming::data_structures::FenwickTree2D;
+
+    #[test]
+    fn test_sum_query() {
+        const R: i32 = 5;
+        const C: i32 = 5;
+
+        let mut ft = FenwickTree2D::<i32>::new(R as usize, C as usize);
+
+        for x0 in 0..R {
+            for x1 in x0..R {
+                for y0 in 0..C {
+                    for y1 in y0..C {
+                        let sum = ft.calculate(x0, y0, x1, y1);
+                        assert_eq!(sum, 0);
+                    }
+                }
+            }
+        }
+
+        for i in 0..R {
+            for j in 0..C {
+                ft.update(i, j, 1); // TODO add random numbers
+            }
+        }
+
+        for x0 in 0..R {
+            for x1 in x0..R {
+                for y0 in 0..C {
+                    for y1 in y0..C {
+                        let sum = ft.calculate(x0, y0, x1, y1);
+                        assert_eq!(sum, (x1 - x0 + 1) * (y1 - y0 + 1))
+                    }
+                }
+            }
+        }
+    }
+}

competitive_programming/tests/data_structures/mod.rs

@@ -1,4 +1,5 @@
 pub mod fenwick_tree;
+pub mod fenwick_tree_2d;
 pub mod recursive_segment_tree;
 pub mod segment_tree;
 pub mod sparse_table;