datasketches 0.2.1 → 0.2.2

data/vendor/datasketches-cpp/sampling/include/var_opt_sketch_impl.hpp

@@ -334,7 +334,7 @@ size_t var_opt_sketch<T,S,A>::get_serialized_size_bytes() const {
     num_bytes += (h_ / 8) + (h_ % 8 > 0);
   }
   // must iterate over the items
-  for (auto& it: *this)
+  for (auto it: *this)
     num_bytes += S().size_of_item(it.first);
   return num_bytes;
 }
@@ -359,21 +359,21 @@ std::vector<uint8_t, AllocU8<A>> var_opt_sketch<T,S,A>::serialize(unsigned heade
   // first prelong
   uint8_t ser_ver(SER_VER);
   uint8_t family(FAMILY_ID);
-  ptr += copy_to_mem(&first_byte, ptr, sizeof(uint8_t));
-  ptr += copy_to_mem(&ser_ver, ptr, sizeof(uint8_t));
-  ptr += copy_to_mem(&family, ptr, sizeof(uint8_t));
-  ptr += copy_to_mem(&flags, ptr, sizeof(uint8_t));
-  ptr += copy_to_mem(&k_, ptr, sizeof(uint32_t));
+  ptr += copy_to_mem(first_byte, ptr);
+  ptr += copy_to_mem(ser_ver, ptr);
+  ptr += copy_to_mem(family, ptr);
+  ptr += copy_to_mem(flags, ptr);
+  ptr += copy_to_mem(k_, ptr);
 
   if (!empty) {
     // second and third prelongs
-    ptr += copy_to_mem(&n_, ptr, sizeof(uint64_t));
-    ptr += copy_to_mem(&h_, ptr, sizeof(uint32_t));
-    ptr += copy_to_mem(&r_, ptr, sizeof(uint32_t));
+    ptr += copy_to_mem(n_, ptr);
+    ptr += copy_to_mem(h_, ptr);
+    ptr += copy_to_mem(r_, ptr);
 
     // fourth prelong, if needed
     if (r_ > 0) {
-      ptr += copy_to_mem(&total_wt_r_, ptr, sizeof(double));
+      ptr += copy_to_mem(total_wt_r_, ptr);
     }
 
     // first h_ weights
@@ -388,14 +388,14 @@ std::vector<uint8_t, AllocU8<A>> var_opt_sketch<T,S,A>::serialize(unsigned heade
         }
 
         if ((i & 0x7) == 0x7) {
-          ptr += copy_to_mem(&val, ptr, sizeof(uint8_t));
+          ptr += copy_to_mem(val, ptr);
           val = 0;
         }
       }
 
       // write out any remaining values
       if ((h_ & 0x7) > 0) {
-        ptr += copy_to_mem(&val, ptr, sizeof(uint8_t));
+        ptr += copy_to_mem(val, ptr);
       }
     }
 
@@ -428,25 +428,25 @@ void var_opt_sketch<T,S,A>::serialize(std::ostream& os) const {
   // first prelong
   const uint8_t ser_ver(SER_VER);
   const uint8_t family(FAMILY_ID);
-  os.write((char*)&first_byte, sizeof(uint8_t));
-  os.write((char*)&ser_ver, sizeof(uint8_t));
-  os.write((char*)&family, sizeof(uint8_t));
-  os.write((char*)&flags, sizeof(uint8_t));
-  os.write((char*)&k_, sizeof(uint32_t));
+  write(os, first_byte);
+  write(os, ser_ver);
+  write(os, family);
+  write(os, flags);
+  write(os, k_);
 
   if (!empty) {
     // second and third prelongs
-    os.write((char*)&n_, sizeof(uint64_t));
-    os.write((char*)&h_, sizeof(uint32_t));
-    os.write((char*)&r_, sizeof(uint32_t));
+    write(os, n_);
+    write(os, h_);
+    write(os, r_);
     
     // fourth prelong, if needed
     if (r_ > 0) {
-      os.write((char*)&total_wt_r_, sizeof(double));
+      write(os, total_wt_r_);
     }
 
     // write the first h_ weights
-    os.write((char*)weights_, h_ * sizeof(double));
+    write(os, weights_, h_ * sizeof(double));
 
     // write the first h_ marks as packed bytes iff we have a gadget
     if (marks_ != nullptr) {
@@ -457,14 +457,14 @@ void var_opt_sketch<T,S,A>::serialize(std::ostream& os) const {
         }
 
         if ((i & 0x7) == 0x7) {
-          os.write((char*)&val, sizeof(uint8_t));
+          write(os, val);
           val = 0;
         }
       }
 
       // write out any remaining values
       if ((h_ & 0x7) > 0) {
-        os.write((char*)&val, sizeof(uint8_t));
+        write(os, val);
       }
     }
 
@@ -481,17 +481,17 @@ var_opt_sketch<T,S,A> var_opt_sketch<T,S,A>::deserialize(const void* bytes, size
   const char* base = ptr;
   const char* end_ptr = ptr + size;
   uint8_t first_byte;
-  ptr += copy_from_mem(ptr, &first_byte, sizeof(first_byte));
+  ptr += copy_from_mem(ptr, first_byte);
   uint8_t preamble_longs = first_byte & 0x3f;
   resize_factor rf = static_cast<resize_factor>((first_byte >> 6) & 0x03);
   uint8_t serial_version;
-  ptr += copy_from_mem(ptr, &serial_version, sizeof(serial_version));
+  ptr += copy_from_mem(ptr, serial_version);
   uint8_t family_id;
-  ptr += copy_from_mem(ptr, &family_id, sizeof(family_id));
+  ptr += copy_from_mem(ptr, family_id);
   uint8_t flags;
-  ptr += copy_from_mem(ptr, &flags, sizeof(flags));
+  ptr += copy_from_mem(ptr, flags);
   uint32_t k;
-  ptr += copy_from_mem(ptr, &k, sizeof(k));
+  ptr += copy_from_mem(ptr, k);
 
   check_preamble_longs(preamble_longs, flags);
   check_family_and_serialization_version(family_id, serial_version);
@@ -507,16 +507,16 @@ var_opt_sketch<T,S,A> var_opt_sketch<T,S,A>::deserialize(const void* bytes, size
   // second and third prelongs
   uint64_t n;
   uint32_t h, r;
-  ptr += copy_from_mem(ptr, &n, sizeof(n));
-  ptr += copy_from_mem(ptr, &h, sizeof(h));
-  ptr += copy_from_mem(ptr, &r, sizeof(r));
+  ptr += copy_from_mem(ptr, n);
+  ptr += copy_from_mem(ptr, h);
+  ptr += copy_from_mem(ptr, r);
 
   const uint32_t array_size = validate_and_get_target_size(preamble_longs, k, n, h, r, rf);
   
   // current_items_alloc_ is set but validate R region weight (4th prelong), if needed, before allocating
   double total_wt_r = 0.0;
   if (preamble_longs == PREAMBLE_LONGS_FULL) {
-    ptr += copy_from_mem(ptr, &total_wt_r, sizeof(total_wt_r));
+    ptr += copy_from_mem(ptr, total_wt_r);
     if (std::isnan(total_wt_r) || r == 0 || total_wt_r <= 0.0) {
       throw std::invalid_argument("Possible corruption: deserializing in full mode but r = 0 or invalid R weight. "
        "Found r = " + std::to_string(r) + ", R region weight = " + std::to_string(total_wt_r));
@@ -548,7 +548,7 @@ var_opt_sketch<T,S,A> var_opt_sketch<T,S,A>::deserialize(const void* bytes, size
     check_memory_size(ptr - base + size_marks, size);
     for (uint32_t i = 0; i < h; ++i) {
      if ((i & 0x7) == 0x0) { // should trigger on first iteration
-        ptr += copy_from_mem(ptr, &val, sizeof(val));
+        ptr += copy_from_mem(ptr, val);
       }
       marks.get()[i] = ((val >> (i & 0x7)) & 0x1) == 1;
       num_marks_in_h += (marks.get()[i] ? 1 : 0);
@@ -571,18 +571,13 @@ var_opt_sketch<T,S,A> var_opt_sketch<T,S,A>::deserialize(const void* bytes, size
 
 template<typename T, typename S, typename A>
 var_opt_sketch<T,S,A> var_opt_sketch<T,S,A>::deserialize(std::istream& is, const A& allocator) {
-  uint8_t first_byte;
-  is.read((char*)&first_byte, sizeof(first_byte));
+  const auto first_byte = read<uint8_t>(is);
   uint8_t preamble_longs = first_byte & 0x3f;
-  resize_factor rf = static_cast<resize_factor>((first_byte >> 6) & 0x03);
-  uint8_t serial_version;
-  is.read((char*)&serial_version, sizeof(serial_version));
-  uint8_t family_id;
-  is.read((char*)&family_id, sizeof(family_id));
-  uint8_t flags;
-  is.read((char*)&flags, sizeof(flags));
-  uint32_t k;
-  is.read((char*)&k, sizeof(k));
+  const resize_factor rf = static_cast<resize_factor>((first_byte >> 6) & 0x03);
+  const auto serial_version = read<uint8_t>(is);
+  const auto family_id = read<uint8_t>(is);
+  const auto flags = read<uint8_t>(is);
+  const auto k = read<uint32_t>(is);
 
   check_preamble_longs(preamble_longs, flags);
   check_family_and_serialization_version(family_id, serial_version);
@@ -598,31 +593,27 @@ var_opt_sketch<T,S,A> var_opt_sketch<T,S,A>::deserialize(std::istream& is, const
   }
 
   // second and third prelongs
-  uint64_t n;
-  uint32_t h, r;
-  is.read((char*)&n, sizeof(n));
-  is.read((char*)&h, sizeof(h));
-  is.read((char*)&r, sizeof(r));
+  const auto n = read<uint64_t>(is);
+  const auto h = read<uint32_t>(is);
+  const auto r = read<uint32_t>(is);
 
   const uint32_t array_size = validate_and_get_target_size(preamble_longs, k, n, h, r, rf);
 
   // current_items_alloc_ is set but validate R region weight (4th prelong), if needed, before allocating
   double total_wt_r = 0.0;
   if (preamble_longs == PREAMBLE_LONGS_FULL) { 
-    is.read((char*)&total_wt_r, sizeof(total_wt_r));
+    total_wt_r = read<double>(is);
     if (std::isnan(total_wt_r) || r == 0 || total_wt_r <= 0.0) {
       throw std::invalid_argument("Possible corruption: deserializing in full mode but r = 0 or invalid R weight. "
        "Found r = " + std::to_string(r) + ", R region weight = " + std::to_string(total_wt_r));
     }
-  } else {
-    total_wt_r = 0.0;
   }
 
   // read the first h weights, fill remainder with -1.0
   std::unique_ptr<double, weights_deleter> weights(AllocDouble(allocator).allocate(array_size),
       weights_deleter(array_size, allocator));
   double* wts = weights.get(); // to avoid lots of .get() calls -- do not delete
-  is.read((char*)wts, h * sizeof(double));
+  read(is, wts, h * sizeof(double));
   for (size_t i = 0; i < h; ++i) {
     if (!(wts[i] > 0.0)) {
       throw std::invalid_argument("Possible corruption: Non-positive weight when deserializing: " + std::to_string(wts[i]));
@@ -638,7 +629,7 @@ var_opt_sketch<T,S,A> var_opt_sketch<T,S,A>::deserialize(std::istream& is, const
     uint8_t val = 0;
     for (uint32_t i = 0; i < h; ++i) {
       if ((i & 0x7) == 0x0) { // should trigger on first iteration
-        is.read((char*)&val, sizeof(val));
+        val = read<uint8_t>(is);
       }
       marks.get()[i] = ((val >> (i & 0x7)) & 0x1) == 1;
       num_marks_in_h += (marks.get()[i] ? 1 : 0);
@@ -1420,7 +1411,7 @@ subset_summary var_opt_sketch<T, S, A>::estimate_subset_sum(P predicate) const {
   if (effective_sampling_rate < 0.0 || effective_sampling_rate > 1.0)
     throw std::logic_error("invalid sampling rate outside [0.0, 1.0]");
 
-  size_t r_true_count = 0;
+  uint32_t r_true_count = 0;
   ++idx; // skip the gap
   for (; idx < (k_ + 1); ++idx) {
     if (predicate(data_[idx])) {

data/vendor/datasketches-cpp/sampling/include/var_opt_union_impl.hpp

@@ -30,8 +30,8 @@ namespace datasketches {
 template<typename T, typename S, typename A>
 var_opt_union<T,S,A>::var_opt_union(uint32_t max_k, const A& allocator) :
   n_(0),
-  outer_tau_numer_(0),
-  outer_tau_denom_(0.0),
+  outer_tau_numer_(0.0),
+  outer_tau_denom_(0),
   max_k_(max_k),
   gadget_(max_k, var_opt_sketch<T,S,A>::DEFAULT_RESIZE_FACTOR, true, allocator)
 {}
@@ -129,16 +129,11 @@ var_opt_union<T,S,A>& var_opt_union<T,S,A>::operator=(var_opt_union&& other) {
 
 template<typename T, typename S, typename A>
 var_opt_union<T,S,A> var_opt_union<T,S,A>::deserialize(std::istream& is, const A& allocator) {
-  uint8_t preamble_longs;
-  is.read((char*)&preamble_longs, sizeof(preamble_longs));
-  uint8_t serial_version;
-  is.read((char*)&serial_version, sizeof(serial_version));
-  uint8_t family_id;
-  is.read((char*)&family_id, sizeof(family_id));
-  uint8_t flags;
-  is.read((char*)&flags, sizeof(flags));
-  uint32_t max_k;
-  is.read((char*)&max_k, sizeof(max_k));
+  const auto preamble_longs = read<uint8_t>(is);
+  const auto serial_version = read<uint8_t>(is);
+  const auto family_id = read<uint8_t>(is);
+  const auto flags = read<uint8_t>(is);
+  const auto max_k = read<uint32_t>(is);
 
   check_preamble_longs(preamble_longs, flags);
   check_family_and_serialization_version(family_id, serial_version);
@@ -156,12 +151,9 @@ var_opt_union<T,S,A> var_opt_union<T,S,A>::deserialize(std::istream& is, const A
       return var_opt_union<T,S,A>(max_k);
   }
 
-  uint64_t items_seen;
-  is.read((char*)&items_seen, sizeof(items_seen));
-  double outer_tau_numer;
-  is.read((char*)&outer_tau_numer, sizeof(outer_tau_numer));
-  uint64_t outer_tau_denom;
-  is.read((char*)&outer_tau_denom, sizeof(outer_tau_denom));
+  const auto items_seen = read<uint64_t>(is);
+  const auto outer_tau_numer = read<double>(is);
+  const auto outer_tau_denom = read<uint64_t>(is);
 
   var_opt_sketch<T,S,A> gadget = var_opt_sketch<T,S,A>::deserialize(is, allocator);
 
@@ -176,15 +168,15 @@ var_opt_union<T,S,A> var_opt_union<T,S,A>::deserialize(const void* bytes, size_t
   ensure_minimum_memory(size, 8);
   const char* ptr = static_cast<const char*>(bytes);
   uint8_t preamble_longs;
-  ptr += copy_from_mem(ptr, &preamble_longs, sizeof(preamble_longs));
+  ptr += copy_from_mem(ptr, preamble_longs);
   uint8_t serial_version;
-  ptr += copy_from_mem(ptr, &serial_version, sizeof(serial_version));
+  ptr += copy_from_mem(ptr, serial_version);
   uint8_t family_id;
-  ptr += copy_from_mem(ptr, &family_id, sizeof(family_id));
+  ptr += copy_from_mem(ptr, family_id);
   uint8_t flags;
-  ptr += copy_from_mem(ptr, &flags, sizeof(flags));
+  ptr += copy_from_mem(ptr, flags);
   uint32_t max_k;
-  ptr += copy_from_mem(ptr, &max_k, sizeof(max_k));
+  ptr += copy_from_mem(ptr, max_k);
 
   check_preamble_longs(preamble_longs, flags);
   check_family_and_serialization_version(family_id, serial_version);
@@ -200,11 +192,11 @@ var_opt_union<T,S,A> var_opt_union<T,S,A>::deserialize(const void* bytes, size_t
   }
 
   uint64_t items_seen;
-  ptr += copy_from_mem(ptr, &items_seen, sizeof(items_seen));
+  ptr += copy_from_mem(ptr, items_seen);
   double outer_tau_numer;
-  ptr += copy_from_mem(ptr, &outer_tau_numer, sizeof(outer_tau_numer));
+  ptr += copy_from_mem(ptr, outer_tau_numer);
   uint64_t outer_tau_denom;
-  ptr += copy_from_mem(ptr, &outer_tau_denom, sizeof(outer_tau_denom));
+  ptr += copy_from_mem(ptr, outer_tau_denom);
 
   const size_t gadget_size = size - (PREAMBLE_LONGS_NON_EMPTY << 3);
   var_opt_sketch<T,S,A> gadget = var_opt_sketch<T,S,A>::deserialize(ptr, gadget_size, allocator);
@@ -238,16 +230,16 @@ void var_opt_union<T,S,A>::serialize(std::ostream& os) const {
     flags = 0;
   }
 
-  os.write((char*) &preamble_longs, sizeof(uint8_t));
-  os.write((char*) &serialization_version, sizeof(uint8_t));
-  os.write((char*) &family_id, sizeof(uint8_t));
-  os.write((char*) &flags, sizeof(uint8_t));
-  os.write((char*) &max_k_, sizeof(uint32_t));
+  write(os, preamble_longs);
+  write(os, serialization_version);
+  write(os, family_id);
+  write(os, flags);
+  write(os, max_k_);
 
   if (!empty) {
-    os.write((char*) &n_, sizeof(uint64_t));
-    os.write((char*) &outer_tau_numer_, sizeof(double));
-    os.write((char*) &outer_tau_denom_, sizeof(uint64_t));
+    write(os, n_);
+    write(os, outer_tau_numer_);
+    write(os, outer_tau_denom_);
     gadget_.serialize(os);
   }
 }
@@ -275,16 +267,16 @@ std::vector<uint8_t, AllocU8<A>> var_opt_union<T,S,A>::serialize(unsigned header
   }
 
   // first prelong
-  ptr += copy_to_mem(&preamble_longs, ptr, sizeof(uint8_t));
-  ptr += copy_to_mem(&serialization_version, ptr, sizeof(uint8_t));
-  ptr += copy_to_mem(&family_id, ptr, sizeof(uint8_t));
-  ptr += copy_to_mem(&flags, ptr, sizeof(uint8_t));
-  ptr += copy_to_mem(&max_k_, ptr, sizeof(uint32_t));
+  ptr += copy_to_mem(preamble_longs, ptr);
+  ptr += copy_to_mem(serialization_version, ptr);
+  ptr += copy_to_mem(family_id, ptr);
+  ptr += copy_to_mem(flags, ptr);
+  ptr += copy_to_mem(max_k_, ptr);
 
   if (!empty) {
-    ptr += copy_to_mem(&n_, ptr, sizeof(uint64_t));
-    ptr += copy_to_mem(&outer_tau_numer_, ptr, sizeof(double));
-    ptr += copy_to_mem(&outer_tau_denom_, ptr, sizeof(uint64_t));
+    ptr += copy_to_mem(n_, ptr);
+    ptr += copy_to_mem(outer_tau_numer_, ptr);
+    ptr += copy_to_mem(outer_tau_denom_, ptr);
 
     auto gadget_bytes = gadget_.serialize();
     ptr += copy_to_mem(gadget_bytes.data(), ptr, gadget_bytes.size() * sizeof(uint8_t));

data/vendor/datasketches-cpp/sampling/test/var_opt_sketch_test.cpp

@@ -41,7 +41,7 @@ static constexpr double EPS = 1e-13;
 static var_opt_sketch<int> create_unweighted_sketch(uint32_t k, uint64_t n) {
   var_opt_sketch<int> sk(k);
   for (uint64_t i = 0; i < n; ++i) {
-    sk.update(i, 1.0);
+    sk.update(static_cast<int>(i), 1.0);
   }
   return sk;
 }
@@ -71,7 +71,7 @@ static void check_if_equal(var_opt_sketch<T,S,A>& sk1, var_opt_sketch<T,S,A>& sk
 
 TEST_CASE("varopt sketch: invalid k", "[var_opt_sketch]") {
   REQUIRE_THROWS_AS(var_opt_sketch<int>(0), std::invalid_argument);
-  REQUIRE_THROWS_AS(var_opt_sketch<int>(1 << 31), std::invalid_argument); // aka k < 0
+  REQUIRE_THROWS_AS(var_opt_sketch<int>(1U << 31), std::invalid_argument); // aka k < 0
 }
 
 TEST_CASE("varopt sketch: bad serialization version", "[var_opt_sketch]") {
@@ -216,11 +216,11 @@ TEST_CASE("varopt sketch: cumulative weight", "[var_opt_sketch]") {
     // which covers about 10 orders of magnitude
     double w = std::exp(5 * N(rand));
     input_sum += w;
-    sk.update(i, w);
+    sk.update(static_cast<int>(i), w);
   }
 
   double output_sum = 0.0;
-  for (auto& it : sk) { // std::pair<int, weight>
+  for (auto it : sk) { // std::pair<int, weight>
     output_sum += it.second;
   }
     
@@ -350,7 +350,7 @@ TEST_CASE("varopt sketch: pseudo-heavy update", "[var_opt_sketch]") {
   // Last one should call update_pseudo_heavy_r_eq_1(), since we'll have
   // added k-1 heavy items, leaving only 1 item left in R
   for (uint32_t i = 1; i <= k; ++i) {
-    sk.update(-i, k + (i * wt_scale));
+    sk.update(-1 * static_cast<int>(i), k + (i * wt_scale));
   }
 
   auto it = sk.begin();
@@ -442,7 +442,7 @@ TEST_CASE("varopt sketch: estimate subset sum", "[var_opt_sketch]") {
   // finally, a non-degenerate predicate
   // insert negative items with identical weights, filter for negative weights only
   for (uint32_t i = 1; i <= (k + 1); ++i) {
-    sk.update(static_cast<int32_t>(-i), 1.0 * i);
+    sk.update(-1 * static_cast<int32_t>(i), static_cast<double>(i));
     total_weight += 1.0 * i;
   }
 

data/vendor/datasketches-cpp/sampling/test/var_opt_union_test.cpp

@@ -41,7 +41,7 @@ static constexpr double EPS = 1e-13;
 static var_opt_sketch<int> create_unweighted_sketch(uint32_t k, uint64_t n) {
   var_opt_sketch<int> sk(k);
   for (uint64_t i = 0; i < n; ++i) {
-    sk.update(i, 1.0);
+    sk.update(static_cast<int>(i), 1.0);
   }
   return sk;
 }
@@ -147,7 +147,7 @@ TEST_CASE("varopt union: bad serialization version", "[var_opt_union]") {
 
 TEST_CASE("varopt union: invalid k", "[var_opt_union]") {
   REQUIRE_THROWS_AS(var_opt_union<int>(0), std::invalid_argument);
-  REQUIRE_THROWS_AS(var_opt_union<int>(1<<31), std::invalid_argument);
+  REQUIRE_THROWS_AS(var_opt_union<int>(1U << 31), std::invalid_argument);
 }
 
 TEST_CASE("varopt union: bad family", "[var_opt_union]") {
@@ -179,13 +179,13 @@ TEST_CASE("varopt union: empty union", "[var_opt_union]") {
 }
 
 TEST_CASE("varopt union: two exact sketches", "[var_opt_union]") {
-  uint64_t n = 4; // 2n < k
+  int n = 4; // 2n < k
   uint32_t k = 10;
   var_opt_sketch<int> sk1(k), sk2(k);
 
-  for (uint64_t i = 1; i <= n; ++i) {
-    sk1.update(i, i);
-    sk2.update(static_cast<int64_t>(-i), i);
+  for (int i = 1; i <= n; ++i) {
+    sk1.update(i, static_cast<double>(i));
+    sk2.update(-i, static_cast<double>(i));
   }
 
   var_opt_union<int> u(k);
@@ -193,7 +193,7 @@ TEST_CASE("varopt union: two exact sketches", "[var_opt_union]") {
   u.update(sk2);
 
   var_opt_sketch<int> result = u.get_result();
-  REQUIRE(result.get_n() == 2 * n);
+  REQUIRE(result.get_n() == 2ULL * n);
   REQUIRE(result.get_k() == k);
 }
 
@@ -204,13 +204,13 @@ TEST_CASE("varopt union: heavy sampling sketch", "[var_opt_union]") {
   uint32_t k2 = 5;
   var_opt_sketch<int64_t> sk1(k1), sk2(k2);
   for (uint64_t i = 1; i <= n1; ++i) {
-    sk1.update(i, i);
+    sk1.update(i, static_cast<double>(i));
   }
 
   for (uint64_t i = 1; i < n2; ++i) { // we'll add a very heavy one later
-    sk2.update(static_cast<int64_t>(-i), i + 1000.0);
+    sk2.update(-1 * static_cast<int64_t>(i), i + 1000.0);
   }
-  sk2.update(-n2, 1000000.0);
+  sk2.update(-1 * static_cast<int64_t>(n2), 1000000.0);
 
   var_opt_union<int64_t> u(k1);
   u.update(sk1);
@@ -258,15 +258,15 @@ TEST_CASE("varopt union: small sampling sketch", "[var_opt_union]") {
   uint64_t n2 = 64;
 
   var_opt_sketch<float> sk(k_small);
-  for (uint64_t i = 0; i < n1; ++i) { sk.update(i); }
-  sk.update(-1, n1 * n1); // add a heavy item
+  for (uint64_t i = 0; i < n1; ++i) { sk.update(static_cast<float>(i)); }
+  sk.update(-1.0f, static_cast<double>(n1 * n1)); // add a heavy item
 
   var_opt_union<float> u(k_max);
   u.update(sk);
 
   // another one, but different n to get a different per-item weight
   var_opt_sketch<float> sk2(k_small);
-  for (uint64_t i = 0; i < n2; ++i) { sk2.update(i); }
+  for (uint64_t i = 0; i < n2; ++i) { sk2.update(static_cast<float>(i)); }
   u.update(sk2);
 
   // should trigger migrate_marked_items_by_decreasing_k()