Use native_simd instead of GCC vectors, fix -Wconversion warnings

Author: adamant-pwn

.verify-helper/config.toml

@@ -1,3 +1,3 @@
 [[languages.cpp.environments]]
 CXX = "g++"
-CXXFLAGS = ["-std=c++23", "-Wall", "-Wextra", "-pedantic", "-Werror", "-O2", "-march=native"]
+CXXFLAGS = ["-std=c++23", "-Wall", "-Wextra", "-Wconversion", "-Werror", "-pedantic", "-O2", "-march=native"]

cp-algo/math/fft.hpp

@@ -8,19 +8,15 @@
 #include <ranges>
 #include <vector>
 #include <bit>
+#include <experimental/simd>
 
 namespace cp_algo::math::fft {
     using ftype = double;
-    static constexpr size_t bytes = 32;
-    static constexpr size_t flen = bytes / sizeof(ftype);
     using point = std::complex<ftype>;
-    using vftype [[gnu::vector_size(bytes)]] = ftype;
+    using vftype = std::experimental::native_simd<ftype>;
     using vpoint = std::complex<vftype>;
+    static constexpr size_t flen = vftype::size();
 
-#define WITH_IV(...)                             \
-  [&]<size_t ... i>(std::index_sequence<i...>) { \
-      return __VA_ARGS__;                        \
-  }(std::make_index_sequence<flen>());
 
     template<typename ft>
     constexpr ft to_ft(auto x) {
@@ -76,12 +72,12 @@ namespace cp_algo::math::fft {
             if(n < pre_roots) {
                 return roots.get<pt>(n + k);
             } else {
-                auto arg = std::numbers::pi / n;
+                auto arg = std::numbers::pi / (ftype)n;
                 if constexpr(std::is_same_v<pt, point>) {
-                    return {cos(k * arg), sin(k * arg)};
+                    return {(ftype)cos(k * arg), (ftype)sin(k * arg)};
                 } else {
-                    return WITH_IV(pt{vftype{cos((k + i) * arg)...},
-                                      vftype{sin((k + i) * arg)...}});
+                    return pt{vftype{[&](auto i) {return cos(ftype(k + i) * arg);}},
+                              vftype{[&](auto i) {return sin(ftype(k + i) * arg);}}};
                 }
             }
         }
@@ -118,7 +114,7 @@ namespace cp_algo::math::fft {
                 }
             }
             for(size_t k = 0; k < n; k += flen) {
-                set(k, get<vpoint>(k) /= to_pt<vpoint>(n));
+                set(k, get<vpoint>(k) /= to_pt<vpoint>((ftype)n));
             }
         }
         void fft() {
@@ -144,11 +140,11 @@ namespace cp_algo::math::fft {
     const cvector cvector::roots = []() {
         cvector res(pre_roots);
         for(size_t n = 1; n < res.size(); n *= 2) {
-            auto base = std::polar(1., std::numbers::pi / n);
+            auto base = std::polar(1., std::numbers::pi / (ftype)n);
             point cur = 1;
             for(size_t k = 0; k < n; k++) {
                 if((k & 15) == 0) {
-                    cur = std::polar(1., std::numbers::pi * k / n);
+                    cur = std::polar(1., std::numbers::pi * (ftype)k / (ftype)n);
                 }
                 res.set(n + k, cur);
                 cur *= base;
@@ -198,7 +194,7 @@ namespace cp_algo::math::fft {
         cvector A, B;
 
         dft(auto const& a, size_t n): A(n), B(n) {
-            split = std::sqrt(base::mod());
+            split = int(std::sqrt(base::mod()));
             cvector::exec_on_roots(2 * n, size(a), [&](size_t i, point rt) {
                 size_t ti = std::min(i, i - n);
                 A.set(ti, A.get(ti) + ftype(a[i].rem() % split) * rt);
@@ -273,12 +269,12 @@ namespace cp_algo::math::fft {
         if(empty(a) || empty(b)) {
             a.clear();
         } else {
-            int n = std::min(k, size(a));
-            int m = std::min(k, size(b));
+            size_t n = std::min(k, size(a));
+            size_t m = std::min(k, size(b));
             a.resize(k);
-            for(int j = k - 1; j >= 0; j--) {
+            for(int j = int(k - 1); j >= 0; j--) {
                 a[j] *= b[0];
-                for(int i = std::max(j - n, 0) + 1; i < std::min(j + 1, m); i++) {
+                for(size_t i = std::max<size_t>(j - n, 0) + 1; i < std::min<size_t>(j + 1, m); i++) {
                     a[j] += a[j - i] * b[i];
                 }
             }

cp-algo/math/poly.hpp

@@ -299,9 +299,9 @@ namespace cp_algo::math {
             if(is_zero()) {
                 return k ? *this : poly_t(1);
             }
-            int i = trailing_xk();
+            size_t i = trailing_xk();
             if(i > 0) {
-                return k >= int64_t(n + i - 1) / i ? poly_t(T(0)) : div_xk(i).pow(k, n - i * k).mul_xk(i * k);
+                return k >= int64_t(n + i - 1) / (int64_t)i ? poly_t(T(0)) : div_xk(i).pow(k, n - i * k).mul_xk(i * k);
             }
             if(std::min(deg(), (int)n) <= magic) {
                 return pow_dn(k, n);
@@ -319,7 +319,7 @@ namespace cp_algo::math {
             if(is_zero()) {
                 return *this;
             }
-            int i = trailing_xk();
+            size_t i = trailing_xk();
             if(i % 2) {
                 return std::nullopt;
             } else if(i > 0) {

cp-algo/math/poly/impl/div.hpp

@@ -82,7 +82,7 @@ namespace cp_algo::math::poly::impl {
         auto [q0, q1] = q.bisect();
         auto qq = q0 * q0 - (q1 * q1).mul_xk_inplace(1);
         inv_inplace(qq, k / 2 - q.deg() / 2, (n + 1) / 2 + q.deg() / 2);
-        int N = fft::com_size(size(q0.a), size(qq.a));
+        size_t N = fft::com_size(size(q0.a), size(qq.a));
         auto q0f = fft::dft<base>(q0.a, N);
         auto q1f = fft::dft<base>(q1.a, N);
         auto qqf = fft::dft<base>(qq.a, N);
@@ -109,7 +109,7 @@ namespace cp_algo::math::poly::impl {
         // Q(-x) = P0(x^2) + xP1(x^2)
         auto [q0, q1] = p.bisect(n);
 
-        int N = fft::com_size(size(q0.a), (n + 1) / 2);
+        size_t N = fft::com_size(size(q0.a), (n + 1) / 2);
 
         auto q0f = fft::dft<base>(q0.a, N);
         auto q1f = fft::dft<base>(q1.a, N);

cp-algo/number_theory/modint.hpp

@@ -31,10 +31,10 @@ namespace cp_algo::math {
         }
         static UInt m_reduce(UInt2 ab) {
             if(mod() % 2 == 0) [[unlikely]] {
-                return ab % mod();
+                return UInt(ab % mod());
             } else {
-                UInt m = ab * imod();
-                return (ab + (UInt2)m * mod()) >> bits;
+                UInt2 m = (UInt)ab * imod();
+                return UInt((ab + m * mod()) >> bits);
             }
         }
         static UInt m_transform(UInt a) {
@@ -45,7 +45,7 @@ namespace cp_algo::math {
             }
         }
         modint_base(): r(0) {}
-        modint_base(Int2 rr): r(rr % mod()) {
+        modint_base(Int2 rr): r(UInt(rr % mod())) {
             r = std::min(r, r + mod());
             r = m_transform(r);
         }