Fixes for integer precision loss

src/false_positives.h

@@ -81,7 +81,8 @@ uint64_t BaseFPBits(uint32_t bits, uint32_t capacity) {
 
 size_t ComputeCapacity(uint32_t bits, size_t max_elements, uint32_t fpbits) {
     if (bits == 0) return 0;
-    uint64_t base_fpbits = BaseFPBits(bits, max_elements);
+    if (max_elements > 0xffffffff) return max_elements;
+    uint64_t base_fpbits = BaseFPBits(bits, static_cast<uint32_t>(max_elements));
     // The fpbits provided by the base max_elements==capacity case are sufficient.
     if (base_fpbits >= fpbits) return max_elements;
     // Otherwise, increment capacity by ceil(fpbits / bits) beyond that.
@@ -90,6 +91,7 @@ size_t ComputeCapacity(uint32_t bits, size_t max_elements, uint32_t fpbits) {
 
 size_t ComputeMaxElements(uint32_t bits, size_t capacity, uint32_t fpbits) {
     if (bits == 0) return 0;
+    if (capacity > 0xffffffff) return capacity;
     // Start with max_elements=capacity, and decrease max_elements until the corresponding capacity is capacity.
     size_t max_elements = capacity;
     while (true) {

src/int_utils.h

@@ -210,7 +210,7 @@ class BitsInt {
     static constexpr inline int TopBits(I val) {
         static_assert(Count > 0, "BitsInt::TopBits needs Count > 0");
         static_assert(Count <= BITS, "BitsInt::TopBits needs Offset <= BITS");
-        return val >> (BITS - Count);
+        return static_cast<int>(val >> (BITS - Count));
     }
 
     static inline constexpr I CondXorWith(I val, bool cond, I v) {

src/minisketch.cpp

@@ -468,7 +468,7 @@ size_t minisketch_merge(minisketch* sketch, const minisketch* other_sketch) {
 ssize_t minisketch_decode(const minisketch* sketch, size_t max_elements, uint64_t* output) {
     const Sketch* s = (const Sketch*)sketch;
     s->Check();
-    return s->Decode(max_elements, output);
+    return s->Decode(static_cast<int>(max_elements), output);
 }
 
 void minisketch_set_seed(minisketch* sketch, uint64_t seed) {

src/sketch.h

@@ -29,7 +29,7 @@ class Sketch
     virtual ~Sketch() {}
     virtual size_t Syndromes() const = 0;
 
-    virtual void Init(int syndromes) = 0;
+    virtual void Init(size_t syndromes) = 0;
     virtual void Add(uint64_t element) = 0;
     virtual void Serialize(unsigned char*) const = 0;
     virtual void Deserialize(const unsigned char*) = 0;

src/sketch_impl.h

@@ -92,7 +92,8 @@ template<typename F>
 void Sqr(std::vector<typename F::Elem>& poly, const F& field) {
     if (poly.size() == 0) return;
     poly.resize(poly.size() * 2 - 1);
-    for (int x = poly.size() - 1; x >= 0; --x) {
+    for (size_t i = 0; i < poly.size(); ++i) {
+        auto x = poly.size() - i - 1;
         poly[x] = (x & 1) ? 0 : field.Sqr(poly[x / 2]);
     }
 }
@@ -297,7 +298,7 @@ std::vector<typename F::Elem> BerlekampMassey(const std::vector<typename F::Elem
         auto discrepancy = syndromes[n];
         for (size_t i = 1; i < current.size(); ++i) discrepancy ^= table[n - i](current[i]);
         if (discrepancy != 0) {
-            int x = n + 1 - (current.size() - 1) - (prev.size() - 1);
+            int x = static_cast<int>(n + 1 - (current.size() - 1) - (prev.size() - 1));
             if (!b_have_inv) {
                 b_inv = field.Inv(b);
                 b_have_inv = true;
@@ -366,7 +367,7 @@ class SketchImpl final : public Sketch
     }
 
     size_t Syndromes() const override { return m_syndromes.size(); }
-    void Init(int count) override { m_syndromes.assign(count, 0); }
+    void Init(size_t count) override { m_syndromes.assign(count, 0); }
 
     void Add(uint64_t val) override
     {
@@ -405,7 +406,7 @@ class SketchImpl final : public Sketch
         for (const auto& root : roots) {
             *(out++) = m_field.ToUint64(root);
         }
-        return roots.size();
+        return static_cast<int>(roots.size());
     }
 
     size_t Merge(const Sketch* other_sketch) override