Add tests of binary-indexed-tree

Author: xirc

lib/cpalgo/ds/binary_indexed_tree.hpp

@@ -12,7 +12,7 @@
 //   Update: O(logN)
 //
 // Verified:
-//  - http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=DSL_2_B
+//  - https://onlinejudge.u-aizu.ac.jp/problems/DSL_2_B
 //
 template <class T = int64_t>
 class BinaryIndexedTree {
@@ -58,11 +58,11 @@ class BinaryIndexedTree {
         return ans;
     }
     // Fold elements of array[l, r)
-    // l = [0,N)
+    // l = [0,N]
     // r = [l,N]
     // Time: O(logN)
     T fold(size_t l, size_t r) const {
-        if (l >= N) throw std::out_of_range("l");
+        if (l > N) throw std::out_of_range("l");
         if (r < l || r > N) throw std::out_of_range("r");
         return remove_func(fold(r), fold(l));
     }
@@ -75,4 +75,4 @@ class BinaryIndexedTree {
             bit[index] = combine_func(bit[index], value);
         }
     }
-};
+};

lib/cpalgo/ds/binary_indexed_tree_2d.hpp

@@ -62,13 +62,13 @@ class BinaryIndexedTree2D {
         return ans;
     }
     // Fold elements of array[[xl,xr),[yl,yr)]
-    // xl = [0,N), xr = [xl,N]
-    // yl = [0,M), yr = [yl,M]
+    // xl = [0,N], xr = [xl,N]
+    // yl = [0,M], yr = [yl,M]
     // Time: O(logN logM logNM)
     T fold(size_t xl, size_t xr, size_t yl, size_t yr) const {
-        if (xl >= N) throw std::out_of_range("xl");
+        if (xl > N) throw std::out_of_range("xl");
         if (xr < xl || xr > N) throw std::out_of_range("xr");
-        if (yl >= M) throw std::out_of_range("yl");
+        if (yl > M) throw std::out_of_range("yl");
         if (yr < yl || yr > M) std::out_of_range("yr");
         T ans = empty;
         ans = combine_func(ans, fold(xr, yr));
@@ -82,7 +82,7 @@ class BinaryIndexedTree2D {
     // Time: O(logN logN logNM)
     void combine(size_t x, size_t y, T const& value) {
         if (x >= N) throw std::out_of_range("x");
-        if ( y >= M) throw std::out_of_range("y");
+        if (y >= M) throw std::out_of_range("y");
         for (size_t i = x + 1; i < N; i += i & -i) {
             for (size_t j = y + 1; j < M; j += j & -j) {
                 if (!bit.count({i,j})) {
@@ -92,4 +92,4 @@ class BinaryIndexedTree2D {
             }
         }
     }
-};
+};

lib/cpalgo/ds/tests/binary_indexed_tree_2d_test.cpp

@@ -0,0 +1,51 @@
+#include <bits/stdc++.h>
+#include "gtest/gtest.h"
+#include "cpalgo/ds/binary_indexed_tree_2d.hpp"
+
+
+TEST(BinaryIndexedTree2DTest, ShouldHandleEmpty) {
+    BinaryIndexedTree2D<int> tree;
+    auto expected_size = std::make_pair(size_t(0), size_t(0));
+    EXPECT_EQ(expected_size, tree.size());
+}
+
+TEST(BinaryIndexedTree2DTest, ShouldReturnSize) {
+    auto tree = BinaryIndexedTree2D<int>(5, 10);
+    auto expected_size = std::make_pair(size_t(5), size_t(10));
+    EXPECT_EQ(expected_size, tree.size());
+}
+
+TEST(BinaryIndexedTree2DTest, ShouldCombineAndFold) {
+    const size_t N = 30, M = 20;
+    auto tree = BinaryIndexedTree2D<int>(N, M);
+
+    for (size_t x = 0; x < N; ++x) {
+        for (size_t y = 0; y < M; ++y) {
+            tree.combine(x, y, x+1);
+        }
+    }
+
+    for (size_t x = 0; x <= N; ++x) {
+        for (size_t y = 0; y <= M; ++y) {
+            int expected_sum = x * (x + 1) / 2 * y;
+            EXPECT_EQ(expected_sum, tree.fold(x, y));
+        }
+    }
+
+
+    for (size_t xl = 0; xl <= N; ++xl) {
+        for (size_t xr = xl; xr <= N; ++xr) {
+            for (size_t yl = 0; yl <= M; ++yl) {
+                for (size_t yr = yl; yr <= M; ++yr) {
+                    int expected_sum =
+                        xr * (xr + 1) / 2 * yr
+                        - xr * (xr + 1) / 2 * yl
+                        - xl * (xl + 1) / 2 * yr
+                        + xl * (xl + 1) / 2 * yl;
+                    EXPECT_EQ(expected_sum, tree.fold(xl, xr, yl, yr));
+                }
+            }
+        }
+    }
+
+}

lib/cpalgo/ds/tests/binary_indexed_tree_test.cpp

@@ -0,0 +1,38 @@
+#include <bits/stdc++.h>
+#include "gtest/gtest.h"
+#include "cpalgo/ds/binary_indexed_tree.hpp"
+
+
+TEST(BinaryIndexedTreeTest, ShouldHandleEmpty) {
+    BinaryIndexedTree<int> tree;
+    EXPECT_EQ(0ULL, tree.size());
+}
+
+TEST(BinaryIndexedTreeTest, ShouldReturnSize) {
+    auto tree = BinaryIndexedTree<int>(5);
+    EXPECT_EQ(5ULL, tree.size());
+}
+
+TEST(BinaryIndexedTreeTest, ShouldCombineAndFold) {
+    const size_t N = 1000;
+    auto tree = BinaryIndexedTree<int64_t>(N);
+
+    for (size_t i = 0; i < N; ++i) {
+        tree.combine(i, i+1);
+    }
+
+    for (size_t i = 0; i <= N; ++i) {
+        int64_t expected_sum = i * (i + 1) / 2;
+        EXPECT_EQ(expected_sum, tree.fold(i));
+    }
+
+    for (size_t l = 0; l <= N; ++l) {
+        for (size_t r = l; r <= N; ++r) {
+            int64_t lsum = l * (l + 1) / 2;
+            int64_t rsum = r * (r + 1) / 2;
+            auto expected_sum = rsum - lsum;
+            EXPECT_EQ(expected_sum, tree.fold(l,r));
+        }
+    }
+
+}