tests: use >> 1 instead of / 2 for non-negative halving

Author: cameroncuster

tests/library_checker_aizu_tests/data_structures/bit_ordered_set.test.cpp

@@ -22,7 +22,7 @@ int main() {
   auto get_compressed_idx = [&](int val) -> int {
     int l = 0, r = sz(compress);
     while (l + 1 < r) {
-      int m = (l + r) / 2;
+      int m = (l + r) >> 1;
       if (compress[m] <= val) l = m;
       else r = m;
     }

tests/library_checker_aizu_tests/data_structures/kth_smallest_pst.test.cpp

@@ -14,7 +14,7 @@ int main() {
   for (int& val : arr) {
     int start = 0, end = sz(sorted);
     while (start + 1 < end) {
-      int mid = (start + end) / 2;
+      int mid = (start + end) >> 1;
       if (sorted[mid] <= val) start = mid;
       else end = mid;
     }

tests/library_checker_aizu_tests/data_structures/mode_query.test.cpp

@@ -14,7 +14,7 @@ int main() {
   for (int& val : a) {
     int start = 0, end = sz(comp);
     while (start + 1 < end) {
-      int mid = (start + end) / 2;
+      int mid = (start + end) >> 1;
       if (comp[mid] <= val) start = mid;
       else end = mid;
     }

tests/library_checker_aizu_tests/data_structures/pq_ds_undo_sliding_window.test.cpp

@@ -22,7 +22,7 @@ int main() {
   rep(i, 0, n) cin >> arr[i];
   stack_with_get_max stm;
   pq_updates<stack_with_get_max, int> pq(stm);
-  int pri = (n - l) / 2;
+  int pri = (n - l) >> 1;
   rep(i, 0, l) pq.push_update(arr[i], pri--);
   cout << pq.ds.get_max();
   rep(i, l, n) {

tests/library_checker_aizu_tests/graphs/two_edge_components.test.cpp

@@ -29,7 +29,8 @@ int main() {
         return sum + sz(neighbors);
       });
     int cnt_bridges = accumulate(all(is_br), 0);
-    assert(sum_deg % 2 == 0 && sum_deg / 2 == cnt_bridges);
+    assert(
+      sum_deg % 2 == 0 && (sum_deg >> 1) == cnt_bridges);
   }
   DSU dsu(n);
   int num_sets_dsu = n;

tests/library_checker_aizu_tests/handmade_tests/seg_tree_midpoint.test.cpp

@@ -24,12 +24,12 @@ int main() {
       } else {
         assert(1 <= v && v < n);
         if (((tr - tl) & (tr - tl - 1)) == 0)
-          assert(split(tl, tr) == (tl + tr) / 2);
+          assert(split(tl, tr) == (tl + tr) >> 1);
         {
           int pow_2 = bit_floor(tr - tl + 0u);
-          if (tl + pow_2 < tr - pow_2 / 2) {
+          if (tl + pow_2 < tr - (pow_2 >> 1)) {
             assert(pow_2 != tr - tl);
-            assert(pow_2 / 2 < tr - tl - pow_2 &&
+            assert((pow_2 >> 1) < tr - tl - pow_2 &&
                    tr - tl - pow_2 < pow_2);
             assert(
               pow_2 <= 2 * (tr - tl - pow_2) - 1 &&
@@ -38,18 +38,18 @@ int main() {
                      lg(2 * ((tr - tl) - pow_2) - 1) &&
                    lg(pow_2) == lg(2 * pow_2 - 1));
           } else if (pow_2 < tr - tl) {
-            assert(pow_2 / 2 < tr - tl - pow_2 / 2 &&
-                   tr - tl - pow_2 / 2 <= pow_2);
-            assert(
-              pow_2 <= 2 * ((tr - tl) - pow_2 / 2) - 1 &&
-              2 * ((tr - tl) - pow_2 / 2) - 1 <=
-                2 * pow_2 - 1);
-            assert(lg(2 * (tr - tl - pow_2 / 2) - 1) ==
+            assert((pow_2 >> 1) < tr - tl - (pow_2 >> 1) &&
+                   tr - tl - (pow_2 >> 1) <= pow_2);
+            assert(pow_2 <=
+                     2 * ((tr - tl) - (pow_2 >> 1)) - 1 &&
+                   2 * ((tr - tl) - (pow_2 >> 1)) - 1 <=
+                     2 * pow_2 - 1);
+            assert(lg(2 * (tr - tl - (pow_2 >> 1)) - 1) ==
                    lg(2 * pow_2 - 1));
-            assert(lg(2 * ((tr - tl) - pow_2 / 2) - 1) ==
-                   lg(pow_2));
+            assert(lg(2 * ((tr - tl) - (pow_2 >> 1)) -
+                      1) == lg(pow_2));
             assert(
-              lg(pow_2) == 1 + lg(2 * (pow_2 / 2) - 1));
+              lg(pow_2) == 1 + lg(2 * (pow_2 >> 1) - 1));
           }
         }
         int tm = split(tl, tr);

tests/library_checker_aizu_tests/math/count_paths.test.cpp

@@ -13,7 +13,7 @@
 #undef modpow
 ll modpow(ll b, ll e) {
   ll res = 1;
-  for (; e; b = b * b % 998'244'353, e /= 2)
+  for (; e; b = b * b % 998'244'353, e >>= 1)
     if (e & 1) res = res * b % 998'244'353;
   return res;
 }

tests/library_checker_aizu_tests/mono_st_asserts.hpp

@@ -57,7 +57,7 @@ void mono_st_asserts(const vi& a) {
         assert(j <= r[i]);
         assert(cmp(a[i], a[j]));
         assert(cmp(a[i], a[r[j] - 1]));
-        assert(cmp(a[i], a[j + (r[j] - j) / 2]));
+        assert(cmp(a[i], a[j + ((r[j] - j) >> 1)]));
         iterations++;
       }
     }

tests/library_checker_aizu_tests/strings/lcp_array.test.cpp

@@ -25,6 +25,7 @@ int main() {
   assert(sa_inv == sa_inv1);
   assert(lcp == lcp1);
   assert(sz(lcp) == n - 1);
-  cout << 1LL * n * (n + 1) / 2 - accumulate(all(lcp), 0LL)
-       << '\n';
+  cout
+    << (1LL * n * (n + 1) >> 1) - accumulate(all(lcp), 0LL)
+    << '\n';
 }

tests/library_checker_aizu_tests/strings/sa_sort_pairs.test.cpp

@@ -14,7 +14,7 @@ int main() {
   for (int& x : arr) {
     int l = -1, r = int(sz(compress));
     while (r - l > 1) {
-      int mi = l + (r - l) / 2;
+      int mi = l + ((r - l) >> 1);
       if (compress[mi] >= x) r = mi;
       else l = mi;
     }