More fixes for -Wconversion

adamant-pwn · adamant-pwn · commit 1db7e8e8d169 · 2024-11-21T04:16:11.000+01:00
diff --git a/cp-algo/math/combinatorics.hpp b/cp-algo/math/combinatorics.hpp
@@ -24,7 +24,7 @@ namespace cp_algo::math {
         static std::vector<T> F(maxn);
         static bool init = false;
         if(!init) {
-            int t = std::min<int64_t>(T::mod(), maxn) - 1;
+            int t = (int)std::min<int64_t>(T::mod(), maxn) - 1;
             F[t] = T(1) / fact<T>(t);
             for(int i = t - 1; i >= 0; i--) {
                 F[i] = F[i + 1] * T(i + 1);
diff --git a/cp-algo/math/poly.hpp b/cp-algo/math/poly.hpp
@@ -462,7 +462,7 @@ namespace cp_algo::math {
             if(is_zero()) {
                 return *this;
             }
-            int n = p.size();
+            size_t n = p.size();
             std::vector<poly_t> tree(4 * n);
             build(tree, 1, begin(p), end(p));
             return to_newton(tree, 1, begin(p), end(p));
@@ -481,7 +481,7 @@ namespace cp_algo::math {
         }
         
         std::vector<T> eval(std::vector<T> x) { // evaluate polynomial in (x1, ..., xn)
-            int n = x.size();
+            size_t n = x.size();
             if(is_zero()) {
                 return std::vector<T>(n, T(0));
             }
@@ -502,7 +502,7 @@ namespace cp_algo::math {
         }
         
         static auto inter(std::vector<T> x, std::vector<T> y) { // interpolates minimum polynomial from (xi, yi) pairs
-            int n = x.size();
+            size_t n = x.size();
             std::vector<poly_t> tree(4 * n);
             return build(tree, 1, begin(x), end(x)).deriv().inter(tree, 1, begin(y), end(y));
         }
@@ -600,11 +600,11 @@ namespace cp_algo::math {
         // Find [x^k] P / Q
         static T kth_rec_inplace(poly_t &P, poly_t &Q, int64_t k) {
             while(k > Q.deg()) {
-                int n = Q.a.size();
+                size_t n = Q.a.size();
                 auto [Q0, Q1] = Q.bisect();
                 auto [P0, P1] = P.bisect();
                 
-                int N = fft::com_size((n + 1) / 2, (n + 1) / 2);
+                size_t N = fft::com_size((n + 1) / 2, (n + 1) / 2);
                 
                 auto Q0f = fft::dft<T>(Q0.a, N);
                 auto Q1f = fft::dft<T>(Q1.a, N);
@@ -619,7 +619,7 @@ namespace cp_algo::math {
                 }
                 k /= 2;
             }
-            return (P *= Q.inv_inplace(Q.deg() + 1))[k];
+            return (P *= Q.inv_inplace(Q.deg() + 1))[(int)k];
         }
         static T kth_rec(poly_t const& P, poly_t const& Q, int64_t k) {
             return kth_rec_inplace(poly_t(P), poly_t(Q), k);
@@ -638,7 +638,7 @@ namespace cp_algo::math {
             return poly::impl::inv_inplace(*this, k, n);
         }
         poly_t inv(int64_t k, size_t n) const {
-            return poly_t(*this).inv_inplace(k, n);;
+            return poly_t(*this).inv_inplace(k, n);
         }
         
         // compute A(B(x)) mod x^n in O(n^2)
diff --git a/cp-algo/math/poly/impl/div.hpp b/cp-algo/math/poly/impl/div.hpp
@@ -86,7 +86,7 @@ namespace cp_algo::math::poly::impl {
         auto q0f = fft::dft<base>(q0.a, N);
         auto q1f = fft::dft<base>(q1.a, N);
         auto qqf = fft::dft<base>(qq.a, N);
-        int M = q0.deg() + (n + 1) / 2;
+        size_t M = q0.deg() + (n + 1) / 2;
         std::vector<base> A(M), B(M);
         q0f.mul(qqf, A, M);
         q1f.mul_inplace(qqf, B, M);
diff --git a/cp-algo/math/poly/impl/euclid.hpp b/cp-algo/math/poly/impl/euclid.hpp
@@ -19,16 +19,16 @@ namespace cp_algo::math::poly::impl {
     template<typename poly>
     gcd_result<poly> half_gcd(poly &&A, poly &&B) {
         assert(A.deg() >= B.deg());
-        int m = size(A.a) / 2;
-        if(B.deg() < m) {
+        size_t m = size(A.a) / 2;
+        if(B.deg() < (int)m) {
             return {};
         }
         auto [ai, R] = A.divmod(B);
         std::tie(A, B) = {B, R};
         std::list a = {ai};
         auto T = -linfrac(ai).adj();
 
-        auto advance = [&](int k) {
+        auto advance = [&](size_t k) {
             auto [ak, Tk] = half_gcd(A.div_xk(k), B.div_xk(k));
             a.splice(end(a), ak);
             T.prepend(Tk);
@@ -83,7 +83,7 @@ namespace cp_algo::math::poly::impl {
         auto [a, Tr] = full_gcd(R1, R2);
         a.emplace_back();
         auto pref = begin(a);
-        for(int delta = d - a.front().deg(); delta >= 0; pref++) {
+        for(int delta = (int)d - a.front().deg(); delta >= 0; pref++) {
             delta -= pref->deg() + next(pref)->deg();
         }
         return convergent(begin(a), pref).a;
diff --git a/cp-algo/structures/fenwick.hpp b/cp-algo/structures/fenwick.hpp
@@ -63,7 +63,7 @@ namespace cp_algo::structures {
         // Assumes prefix_fold is monotonic
         // returns [x, prefix_fold(x)]
         auto prefix_lower_bound(T k) const {
-            int x = 0;
+            size_t x = 0;
             T pref = {};
             for(size_t i = std::bit_floor(n); i; i /= 2) {
                 if(x + i <= n && op(pref, data[x + i]) <= k) {
diff --git a/cp-algo/structures/fenwick_set.hpp b/cp-algo/structures/fenwick_set.hpp
@@ -43,7 +43,7 @@ namespace cp_algo::structures {
             if(order >= sz) {
                 return -1;
             }
-            auto [x, pref] = Base::prefix_lower_bound(order);
+            auto [x, pref] = Base::prefix_lower_bound((int)order);
             return x * word + kth_set_bit(bits.word(x), order - pref);
         }
         size_t lower_bound(size_t x) const {
diff --git a/cp-algo/structures/segtree.hpp b/cp-algo/structures/segtree.hpp
@@ -1,39 +1,40 @@
 #ifndef CP_ALGO_STRUCTURES_SEGMENT_TREE_HPP
 #define CP_ALGO_STRUCTURES_SEGMENT_TREE_HPP
 #include <vector>
+#include <numeric>
 namespace cp_algo::structures {
     template<typename meta>
     struct segtree_t {
-        const int N;
+        const size_t N;
         std::vector<meta> _meta;
 
-        segtree_t(int n): N(n), _meta(4 * N) {}
+        segtree_t(size_t n): N(n), _meta(4 * N) {}
 
         segtree_t(std::vector<meta> leafs): N(size(leafs)), _meta(4 * N) {
             build(leafs);
         }
 
-        void pull(int v, int l, int r) {
+        void pull(size_t v, size_t l, size_t r) {
             if(r - l > 1) {
                 _meta[v].pull(_meta[2 * v], _meta[2 * v + 1], l, r);
             }
         }
 
-        void push(int v, int l, int r) {
+        void push(size_t v, size_t l, size_t r) {
             if(r - l > 1) {
                 _meta[v].push(&_meta[2 * v], &_meta[2 * v + 1], l, r);
             } else {
                 _meta[v].push(nullptr, nullptr, l, r);
             }
         }
 
-        void build(auto &a, int v, size_t l, size_t r) {
+        void build(auto &a, size_t v, size_t l, size_t r) {
             if(r - l == 1) {
                 if(l < size(a)) {
                     _meta[v] = a[l];
                 }
             } else {
-                size_t m = (l + r) / 2;
+                size_t m = std::midpoint(l, r);
                 build(a, 2 * v, l, m);
                 build(a, 2 * v + 1, m, r);
                 pull(v, l, r);
@@ -44,15 +45,15 @@ namespace cp_algo::structures {
             build(a, 1, 0, N);
         }
 
-        void exec_on_segment(int a, int b, auto func, auto proceed, auto stop, int v, int l, int r) {
+        void exec_on_segment(size_t a, size_t b, auto func, auto proceed, auto stop, size_t v, size_t l, size_t r) {
             push(v, l, r);
             if(r <= a || b <= l || stop(_meta[v])) {
                 return;
             } else if(a <= l && r <= b && proceed(_meta[v])) {
                 func(_meta[v]);
                 push(v, l, r);
             } else {
-                int m = (l + r) / 2;
+                size_t m = std::midpoint(l, r);
                 exec_on_segment(a, b, func, proceed, stop, 2 * v, l, m);
                 exec_on_segment(a, b, func, proceed, stop, 2 * v + 1, m, r);
                 pull(v, l, r);
@@ -62,11 +63,11 @@ namespace cp_algo::structures {
         static constexpr auto default_true = [](auto const&){return true;};
         static constexpr auto default_false = [](auto const&){return false;};
 
-        void exec_on_segment(int a, int b, auto func, auto proceed, auto stop) {
+        void exec_on_segment(size_t a, size_t b, auto func, auto proceed, auto stop) {
             exec_on_segment(a, b, func, proceed, stop, 1, 0, N);
         }
 
-        void exec_on_segment(int a, int b, auto func) {
+        void exec_on_segment(size_t a, size_t b, auto func) {
             exec_on_segment(a, b, func, default_true, default_false);
         }
     };
diff --git a/cp-algo/structures/segtree/metas/affine.hpp b/cp-algo/structures/segtree/metas/affine.hpp
@@ -14,7 +14,7 @@ namespace cp_algo::structures::segtree::metas {
         affine_meta() {}
         affine_meta(base sum): sum(sum) {}
 
-        void push(meta *L, meta *R, int l, int r) override {
+        void push(meta *L, meta *R, size_t l, size_t r) override {
             if(to_push.a != 1 || to_push.b != 0) {
                 sum = to_push.a * sum + to_push.b * (r - l);
                 if(r - l > 1) {
@@ -25,7 +25,7 @@ namespace cp_algo::structures::segtree::metas {
             }
         }
 
-        void pull(meta const& L, meta const& R, int, int) override {
+        void pull(meta const& L, meta const& R, size_t, size_t) override {
             sum = L.sum + R.sum;
         }
     };
diff --git a/cp-algo/structures/segtree/metas/base.hpp b/cp-algo/structures/segtree/metas/base.hpp
@@ -1,11 +1,12 @@
 #ifndef CP_ALGO_STRUCTURES_SEGMENT_TREE_METAS_BASE_HPP
 #define CP_ALGO_STRUCTURES_SEGMENT_TREE_METAS_BASE_HPP
+#include <cstddef>
 namespace cp_algo::structures::segtree::metas {
     template<typename derived_meta>
     struct base_meta {
         using meta = derived_meta;
-        virtual void pull(meta const&, meta const&, int, int) {};
-        virtual void push(meta*, meta*, int, int) {};
+        virtual void pull(meta const&, meta const&, size_t, size_t) {};
+        virtual void push(meta*, meta*, size_t, size_t) {};
     };
 }
 #endif // CP_ALGO_STRUCTURES_SEGMENT_TREE_METAS_BASE_HPP
diff --git a/cp-algo/structures/segtree/metas/chmin_chmax_add.hpp b/cp-algo/structures/segtree/metas/chmin_chmax_add.hpp
@@ -14,7 +14,7 @@ namespace cp_algo::structures::segtree::metas {
         template<typename Comp>
         struct data {
             int64_t val;
-            int64_t count = 1;
+            size_t count = 1;
             int64_t second = std::max(inf, -inf, comp);
             static const Comp comp;
 
@@ -50,7 +50,7 @@ namespace cp_algo::structures::segtree::metas {
         chmin_chmax_sum_meta() {}
         chmin_chmax_sum_meta(int64_t val): sum(val) {}
 
-        void pull(meta const& L, meta const& R, int, int) override {
+        void pull(meta const& L, meta const& R, size_t, size_t) override {
             sum = L.sum + R.sum;
             mn = L.mn.combine(R.mn);
             mx = L.mx.combine(R.mx);
@@ -62,7 +62,7 @@ namespace cp_algo::structures::segtree::metas {
             t.chmax = std::clamp(t.chmax, chmax, chmin);
         }
 
-        void push(meta* L, meta* R, int l, int r) override {
+        void push(meta* L, meta* R, size_t l, size_t r) override {
             if(r - l > 1) {
                 push(*L);
                 push(*R);
diff --git a/cp-algo/util/compress_coords.hpp b/cp-algo/util/compress_coords.hpp
@@ -14,7 +14,7 @@ namespace cp_algo {
         }
         original.reserve(size(coords));
         radix_sort(coords);
-        size_t idx = -1;
+        int idx = -1;
         T prev = ~coords.front();
         for(auto &x: coords) {
             if(x != prev) {
diff --git a/verify/poly/wildcard.test.cpp b/verify/poly/wildcard.test.cpp
@@ -33,7 +33,7 @@ string matches(string const& A, string const& B, char wild = '*') {
     if(!init) {
         init = true;
         for(int i = 0; i < sigma; i++) {
-            project[0][i] = polar(1., (ftype)cp_algo::random::rng());
+            project[0][i] = cp_algo::polar(1., (ftype)cp_algo::random::rng());
             project[1][i] = conj(project[0][i]);
         }
     }
diff --git a/verify/structures/bitpack/det_mod_2.test.cpp b/verify/structures/bitpack/det_mod_2.test.cpp
@@ -16,7 +16,7 @@ void solve() {
     int n;
     cin >> n;
     string row;
-    vector<int> lead(n);
+    vector<size_t> lead(n);
     for(int i = 0; i < n; i++) {
         cin >> row;
         a[i] = row;
diff --git a/verify/structures/bitpack/inv_mod_2.test.cpp b/verify/structures/bitpack/inv_mod_2.test.cpp
@@ -11,15 +11,15 @@ const int maxn = 1 << 13;
 bitpack<maxn> a[maxn];
 
 void solve() {
-    int n;
+    size_t n;
     cin >> n;
     string row;
-    vector<int> lead(n);
-    for(int i = 0; i < n; i++) {
+    vector<size_t> lead(n);
+    for(size_t i = 0; i < n; i++) {
         cin >> row;
         a[i] = row;
         a[i].set(n + i);
-        for(int j = 0; j < i; j++) {
+        for(size_t j = 0; j < i; j++) {
             if(a[i][lead[j]]) {
                 a[i].xor_hint(a[j], lead[j]);
             }
@@ -29,13 +29,13 @@ void solve() {
             cout << -1 << "\n";
             return;
         }
-        for(int j = 0; j < i; j++) {
+        for(size_t j = 0; j < i; j++) {
             if(a[j][lead[i]]) {
                 a[j].xor_hint(a[i], lead[i]);
             }
         }
     }
-    for(int i = 0; i < n; i++) {
+    for(size_t i = 0; i < n; i++) {
         while(lead[i] != i) {
             swap(a[i], a[lead[i]]);
             swap(lead[i], lead[lead[i]]);
diff --git a/verify/structures/bitpack/system_mod_2.test.cpp b/verify/structures/bitpack/system_mod_2.test.cpp
@@ -11,23 +11,23 @@ const int maxn = (1 << 12) + 1;
 bitpack<maxn> a[maxn];
 
 void solve() {
-    int n, m;
+    size_t n, m;
     cin >> n >> m;
     vector<string> As(n);
-    for(int i = 0; i < n; i++) {
+    for(size_t i = 0; i < n; i++) {
         cin >> As[i];
     }
     string bs;
     cin >> bs;
-    for(int i = 0; i < n; i++) {
+    for(size_t i = 0; i < n; i++) {
         As[i] += bs[i];
         a[i] = As[i];
     }
-    vector<int> lead(n);
-    auto vars = views::iota(0, m + 1);
-    set<int> free(begin(vars), end(vars));
-    for(int i = 0; i < n; i++) {
-        for(int j = 0; j < i; j++) {
+    vector<size_t> lead(n);
+    auto vars = views::iota((size_t)0, m + 1);
+    set<size_t> free(begin(vars), end(vars));
+    for(size_t i = 0; i < n; i++) {
+        for(size_t j = 0; j < i; j++) {
             if(a[i][lead[j]]) {
                 a[i].xor_hint(a[j], lead[j]);
             }
@@ -41,7 +41,7 @@ void solve() {
             continue;
         }
         free.erase(lead[i]);
-        for(int j = 0; j < i; j++) {
+        for(size_t j = 0; j < i; j++) {
             if(a[j][lead[i]]) {
                 a[j].xor_hint(a[i], lead[i]);
             }
@@ -50,16 +50,16 @@ void solve() {
     bitpack<maxn> x[maxn];
     for(auto [j, pj]: views::enumerate(free)) {
         x[j].set(pj);
-        for(int i = 0; i < n; i++) {
+        for(size_t i = 0; i < n; i++) {
             if(lead[i] < m && a[i][pj]) {
                 x[j].set(lead[i]);
             }
         }
     }
-    int rk = size(free) - 1;
+    size_t rk = size(free) - 1;
     swap(x[0], x[rk]);
     cout << rk << "\n";
-    for(int i = 0; i <= rk; i++) {
+    for(size_t i = 0; i <= rk; i++) {
         cout << x[i].to_string().substr(0, m) << "\n";
     }
 }
diff --git a/verify/structures/fenwick/ordered_set.test.cpp b/verify/structures/fenwick/ordered_set.test.cpp

Original file line number	Diff line number	Diff line change
`@@ -462,7 +462,7 @@ namespace cp_algo::math {`
`462`	`462`	`if(is_zero()) {`
`463`	`463`	`return *this;`
`464`	`464`	`}`
`465`		`- int n = p.size();`
	`465`	`+ size_t n = p.size();`
`466`	`466`	`std::vector<poly_t> tree(4 * n);`
`467`	`467`	`build(tree, 1, begin(p), end(p));`
`468`	`468`	`return to_newton(tree, 1, begin(p), end(p));`
`@@ -481,7 +481,7 @@ namespace cp_algo::math {`
`481`	`481`	`}`
`482`	`482`
`483`	`483`	`std::vector<T> eval(std::vector<T> x) { // evaluate polynomial in (x1, ..., xn)`
`484`		`- int n = x.size();`
	`484`	`+ size_t n = x.size();`
`485`	`485`	`if(is_zero()) {`
`486`	`486`	`return std::vector<T>(n, T(0));`
`487`	`487`	`}`
`@@ -502,7 +502,7 @@ namespace cp_algo::math {`
`502`	`502`	`}`
`503`	`503`
`504`	`504`	`static auto inter(std::vector<T> x, std::vector<T> y) { // interpolates minimum polynomial from (xi, yi) pairs`
`505`		`- int n = x.size();`
	`505`	`+ size_t n = x.size();`
`506`	`506`	`std::vector<poly_t> tree(4 * n);`
`507`	`507`	`return build(tree, 1, begin(x), end(x)).deriv().inter(tree, 1, begin(y), end(y));`
`508`	`508`	`}`
`@@ -600,11 +600,11 @@ namespace cp_algo::math {`
`600`	`600`	`// Find [x^k] P / Q`
`601`	`601`	`static T kth_rec_inplace(poly_t &P, poly_t &Q, int64_t k) {`
`602`	`602`	`while(k > Q.deg()) {`
`603`		`- int n = Q.a.size();`
	`603`	`+ size_t n = Q.a.size();`
`604`	`604`	`auto [Q0, Q1] = Q.bisect();`
`605`	`605`	`auto [P0, P1] = P.bisect();`
`606`	`606`
`607`		`- int N = fft::com_size((n + 1) / 2, (n + 1) / 2);`
	`607`	`+ size_t N = fft::com_size((n + 1) / 2, (n + 1) / 2);`
`608`	`608`
`609`	`609`	`auto Q0f = fft::dft<T>(Q0.a, N);`
`610`	`610`	`auto Q1f = fft::dft<T>(Q1.a, N);`
`@@ -619,7 +619,7 @@ namespace cp_algo::math {`
`619`	`619`	`}`
`620`	`620`	`k /= 2;`
`621`	`621`	`}`
`622`		`- return (P *= Q.inv_inplace(Q.deg() + 1))[k];`
	`622`	`+ return (P *= Q.inv_inplace(Q.deg() + 1))[(int)k];`
`623`	`623`	`}`
`624`	`624`	`static T kth_rec(poly_t const& P, poly_t const& Q, int64_t k) {`
`625`	`625`	`return kth_rec_inplace(poly_t(P), poly_t(Q), k);`
`@@ -638,7 +638,7 @@ namespace cp_algo::math {`
`638`	`638`	`return poly::impl::inv_inplace(*this, k, n);`
`639`	`639`	`}`
`640`	`640`	`poly_t inv(int64_t k, size_t n) const {`
`641`		`- return poly_t(*this).inv_inplace(k, n);;`
	`641`	`+ return poly_t(*this).inv_inplace(k, n);`
`642`	`642`	`}`
`643`	`643`
`644`	`644`	`// compute A(B(x)) mod x^n in O(n^2)`
Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ namespace cp_algo::structures {`
`43`	`43`	`if(order >= sz) {`
`44`	`44`	`return -1;`
`45`	`45`	`}`
`46`		`- auto [x, pref] = Base::prefix_lower_bound(order);`
	`46`	`+ auto [x, pref] = Base::prefix_lower_bound((int)order);`
`47`	`47`	`return x * word + kth_set_bit(bits.word(x), order - pref);`
`48`	`48`	`}`
`49`	`49`	`size_t lower_bound(size_t x) const {`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ namespace cp_algo::structures::segtree::metas {`
`14`	`14`	`affine_meta() {}`
`15`	`15`	`affine_meta(base sum): sum(sum) {}`
`16`	`16`
`17`		`- void push(meta L, meta R, int l, int r) override {`
	`17`	`+ void push(meta L, meta R, size_t l, size_t r) override {`
`18`	`18`	`if(to_push.a != 1 \|\| to_push.b != 0) {`
`19`	`19`	`sum = to_push.a * sum + to_push.b * (r - l);`
`20`	`20`	`if(r - l > 1) {`
`@@ -25,7 +25,7 @@ namespace cp_algo::structures::segtree::metas {`
`25`	`25`	`}`
`26`	`26`	`}`
`27`	`27`
`28`		`- void pull(meta const& L, meta const& R, int, int) override {`
	`28`	`+ void pull(meta const& L, meta const& R, size_t, size_t) override {`
`29`	`29`	`sum = L.sum + R.sum;`
`30`	`30`	`}`
`31`	`31`	`};`