datasketches 0.2.1 → 0.2.2

data/vendor/datasketches-cpp/tuple/include/tuple_sketch_impl.hpp

@@ -315,7 +315,7 @@ uint64_t compact_tuple_sketch<S, A>::get_theta64() const {
 
 template<typename S, typename A>
 uint32_t compact_tuple_sketch<S, A>::get_num_retained() const {
-  return entries_.size();
+  return static_cast<uint32_t>(entries_.size());
 }
 
 template<typename S, typename A>
@@ -347,36 +347,36 @@ template<typename SerDe>
 void compact_tuple_sketch<S, A>::serialize(std::ostream& os, const SerDe& sd) const {
   const bool is_single_item = entries_.size() == 1 && !this->is_estimation_mode();
   const uint8_t preamble_longs = this->is_empty() || is_single_item ? 1 : this->is_estimation_mode() ? 3 : 2;
-  os.write(reinterpret_cast<const char*>(&preamble_longs), sizeof(preamble_longs));
+  write(os, preamble_longs);
   const uint8_t serial_version = SERIAL_VERSION;
-  os.write(reinterpret_cast<const char*>(&serial_version), sizeof(serial_version));
+  write(os, serial_version);
   const uint8_t family = SKETCH_FAMILY;
-  os.write(reinterpret_cast<const char*>(&family), sizeof(family));
+  write(os, family);
   const uint8_t type = SKETCH_TYPE;
-  os.write(reinterpret_cast<const char*>(&type), sizeof(type));
+  write(os, type);
   const uint8_t unused8 = 0;
-  os.write(reinterpret_cast<const char*>(&unused8), sizeof(unused8));
+  write(os, unused8);
   const uint8_t flags_byte(
     (1 << flags::IS_COMPACT) |
     (1 << flags::IS_READ_ONLY) |
     (this->is_empty() ? 1 << flags::IS_EMPTY : 0) |
     (this->is_ordered() ? 1 << flags::IS_ORDERED : 0)
   );
-  os.write(reinterpret_cast<const char*>(&flags_byte), sizeof(flags_byte));
+  write(os, flags_byte);
   const uint16_t seed_hash = get_seed_hash();
-  os.write(reinterpret_cast<const char*>(&seed_hash), sizeof(seed_hash));
+  write(os, seed_hash);
   if (!this->is_empty()) {
     if (!is_single_item) {
-      const uint32_t num_entries = entries_.size();
-      os.write(reinterpret_cast<const char*>(&num_entries), sizeof(num_entries));
+      const uint32_t num_entries = static_cast<uint32_t>(entries_.size());
+      write(os, num_entries);
       const uint32_t unused32 = 0;
-      os.write(reinterpret_cast<const char*>(&unused32), sizeof(unused32));
+      write(os, unused32);
       if (this->is_estimation_mode()) {
-        os.write(reinterpret_cast<const char*>(&(this->theta_)), sizeof(uint64_t));
+        write(os, this->theta_);
       }
     }
     for (const auto& it: entries_) {
-      os.write(reinterpret_cast<const char*>(&it.first), sizeof(uint64_t));
+      write(os, it.first);
       sd.serialize(os, &it.second, 1);
     }
   }
@@ -393,36 +393,34 @@ auto compact_tuple_sketch<S, A>::serialize(unsigned header_size_bytes, const Ser
   uint8_t* ptr = bytes.data() + header_size_bytes;
   const uint8_t* end_ptr = ptr + size;
 
-  ptr += copy_to_mem(&preamble_longs, ptr, sizeof(preamble_longs));
+  ptr += copy_to_mem(preamble_longs, ptr);
   const uint8_t serial_version = SERIAL_VERSION;
-  ptr += copy_to_mem(&serial_version, ptr, sizeof(serial_version));
+  ptr += copy_to_mem(serial_version, ptr);
   const uint8_t family = SKETCH_FAMILY;
-  ptr += copy_to_mem(&family, ptr, sizeof(family));
+  ptr += copy_to_mem(family, ptr);
   const uint8_t type = SKETCH_TYPE;
-  ptr += copy_to_mem(&type, ptr, sizeof(type));
-  const uint8_t unused8 = 0;
-  ptr += copy_to_mem(&unused8, ptr, sizeof(unused8));
+  ptr += copy_to_mem(type, ptr);
+  ptr += sizeof(uint8_t); // unused
   const uint8_t flags_byte(
     (1 << flags::IS_COMPACT) |
     (1 << flags::IS_READ_ONLY) |
     (this->is_empty() ? 1 << flags::IS_EMPTY : 0) |
     (this->is_ordered() ? 1 << flags::IS_ORDERED : 0)
   );
-  ptr += copy_to_mem(&flags_byte, ptr, sizeof(flags_byte));
+  ptr += copy_to_mem(flags_byte, ptr);
   const uint16_t seed_hash = get_seed_hash();
-  ptr += copy_to_mem(&seed_hash, ptr, sizeof(seed_hash));
+  ptr += copy_to_mem(seed_hash, ptr);
   if (!this->is_empty()) {
     if (!is_single_item) {
-      const uint32_t num_entries = entries_.size();
-      ptr += copy_to_mem(&num_entries, ptr, sizeof(num_entries));
-      const uint32_t unused32 = 0;
-      ptr += copy_to_mem(&unused32, ptr, sizeof(unused32));
+      const uint32_t num_entries = static_cast<uint32_t>(entries_.size());
+      ptr += copy_to_mem(num_entries, ptr);
+      ptr += sizeof(uint32_t); // unused
       if (this->is_estimation_mode()) {
-        ptr += copy_to_mem(&theta_, ptr, sizeof(uint64_t));
+        ptr += copy_to_mem(theta_, ptr);
       }
     }
     for (const auto& it: entries_) {
-      ptr += copy_to_mem(&it.first, ptr, sizeof(uint64_t));
+      ptr += copy_to_mem(it.first, ptr);
       ptr += sd.serialize(ptr, end_ptr - ptr, &it.second, 1);
     }
   }
@@ -432,20 +430,13 @@ auto compact_tuple_sketch<S, A>::serialize(unsigned header_size_bytes, const Ser
 template<typename S, typename A>
 template<typename SerDe>
 compact_tuple_sketch<S, A> compact_tuple_sketch<S, A>::deserialize(std::istream& is, uint64_t seed, const SerDe& sd, const A& allocator) {
-  uint8_t preamble_longs;
-  is.read(reinterpret_cast<char*>(&preamble_longs), sizeof(preamble_longs));
-  uint8_t serial_version;
-  is.read(reinterpret_cast<char*>(&serial_version), sizeof(serial_version));
-  uint8_t family;
-  is.read(reinterpret_cast<char*>(&family), sizeof(family));
-  uint8_t type;
-  is.read(reinterpret_cast<char*>(&type), sizeof(type));
-  uint8_t unused8;
-  is.read(reinterpret_cast<char*>(&unused8), sizeof(unused8));
-  uint8_t flags_byte;
-  is.read(reinterpret_cast<char*>(&flags_byte), sizeof(flags_byte));
-  uint16_t seed_hash;
-  is.read(reinterpret_cast<char*>(&seed_hash), sizeof(seed_hash));
+  const auto preamble_longs = read<uint8_t>(is);
+  const auto serial_version = read<uint8_t>(is);
+  const auto family = read<uint8_t>(is);
+  const auto type = read<uint8_t>(is);
+  read<uint8_t>(is); // unused
+  const auto flags_byte = read<uint8_t>(is);
+  const auto seed_hash = read<uint16_t>(is);
   checker<true>::check_serial_version(serial_version, SERIAL_VERSION);
   checker<true>::check_sketch_family(family, SKETCH_FAMILY);
   checker<true>::check_sketch_type(type, SKETCH_TYPE);
@@ -458,11 +449,10 @@ compact_tuple_sketch<S, A> compact_tuple_sketch<S, A>::deserialize(std::istream&
     if (preamble_longs == 1) {
       num_entries = 1;
     } else {
-      is.read(reinterpret_cast<char*>(&num_entries), sizeof(num_entries));
-      uint32_t unused32;
-      is.read(reinterpret_cast<char*>(&unused32), sizeof(unused32));
+      num_entries = read<uint32_t>(is);
+      read<uint32_t>(is); // unused
       if (preamble_longs > 2) {
-        is.read(reinterpret_cast<char*>(&theta), sizeof(theta));
+        theta = read<uint64_t>(is);
       }
     }
   }
@@ -472,8 +462,7 @@ compact_tuple_sketch<S, A> compact_tuple_sketch<S, A>::deserialize(std::istream&
     entries.reserve(num_entries);
     std::unique_ptr<S, deleter_of_summaries> summary(alloc.allocate(1), deleter_of_summaries(1, false, allocator));
     for (size_t i = 0; i < num_entries; ++i) {
-      uint64_t key;
-      is.read(reinterpret_cast<char*>(&key), sizeof(uint64_t));
+      const auto key = read<uint64_t>(is);
       sd.deserialize(is, summary.get(), 1);
       entries.push_back(Entry(key, std::move(*summary)));
       (*summary).~S();
@@ -491,19 +480,18 @@ compact_tuple_sketch<S, A> compact_tuple_sketch<S, A>::deserialize(const void* b
   const char* ptr = static_cast<const char*>(bytes);
   const char* base = ptr;
   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;
-  ptr += copy_from_mem(ptr, &family, sizeof(family));
+  ptr += copy_from_mem(ptr, family);
   uint8_t type;
-  ptr += copy_from_mem(ptr, &type, sizeof(type));
-  uint8_t unused8;
-  ptr += copy_from_mem(ptr, &unused8, sizeof(unused8));
+  ptr += copy_from_mem(ptr, type);
+  ptr += sizeof(uint8_t); // unused
   uint8_t flags_byte;
-  ptr += copy_from_mem(ptr, &flags_byte, sizeof(flags_byte));
+  ptr += copy_from_mem(ptr, flags_byte);
   uint16_t seed_hash;
-  ptr += copy_from_mem(ptr, &seed_hash, sizeof(seed_hash));
+  ptr += copy_from_mem(ptr, seed_hash);
   checker<true>::check_serial_version(serial_version, SERIAL_VERSION);
   checker<true>::check_sketch_family(family, SKETCH_FAMILY);
   checker<true>::check_sketch_type(type, SKETCH_TYPE);
@@ -518,12 +506,11 @@ compact_tuple_sketch<S, A> compact_tuple_sketch<S, A>::deserialize(const void* b
       num_entries = 1;
     } else {
       ensure_minimum_memory(size, 8); // read the first prelong before this method
-      ptr += copy_from_mem(ptr, &num_entries, sizeof(num_entries));
-      uint32_t unused32;
-      ptr += copy_from_mem(ptr, &unused32, sizeof(unused32));
+      ptr += copy_from_mem(ptr, num_entries);
+      ptr += sizeof(uint32_t); // unused
       if (preamble_longs > 2) {
         ensure_minimum_memory(size, (preamble_longs - 1) << 3);
-        ptr += copy_from_mem(ptr, &theta, sizeof(theta));
+        ptr += copy_from_mem(ptr, theta);
       }
     }
   }
@@ -536,7 +523,7 @@ compact_tuple_sketch<S, A> compact_tuple_sketch<S, A>::deserialize(const void* b
     std::unique_ptr<S, deleter_of_summaries> summary(alloc.allocate(1), deleter_of_summaries(1, false, allocator));
     for (size_t i = 0; i < num_entries; ++i) {
       uint64_t key;
-      ptr += copy_from_mem(ptr, &key, sizeof(key));
+      ptr += copy_from_mem(ptr, key);
       ptr += sd.deserialize(ptr, base + size - ptr, summary.get(), 1);
       entries.push_back(Entry(key, std::move(*summary)));
       (*summary).~S();
@@ -548,22 +535,22 @@ compact_tuple_sketch<S, A> compact_tuple_sketch<S, A>::deserialize(const void* b
 
 template<typename S, typename A>
 auto compact_tuple_sketch<S, A>::begin() -> iterator {
-  return iterator(entries_.data(), entries_.size(), 0);
+  return iterator(entries_.data(), static_cast<uint32_t>(entries_.size()), 0);
 }
 
 template<typename S, typename A>
 auto compact_tuple_sketch<S, A>::end() -> iterator {
-  return iterator(nullptr, 0, entries_.size());
+  return iterator(nullptr, 0, static_cast<uint32_t>(entries_.size()));
 }
 
 template<typename S, typename A>
 auto compact_tuple_sketch<S, A>::begin() const -> const_iterator {
-  return const_iterator(entries_.data(), entries_.size(), 0);
+  return const_iterator(entries_.data(), static_cast<uint32_t>(entries_.size()), 0);
 }
 
 template<typename S, typename A>
 auto compact_tuple_sketch<S, A>::end() const -> const_iterator {
-  return const_iterator(nullptr, 0, entries_.size());
+  return const_iterator(nullptr, 0, static_cast<uint32_t>(entries_.size()));
 }
 
 template<typename S, typename A>

data/vendor/datasketches-cpp/tuple/test/array_of_doubles_sketch_test.cpp

@@ -75,7 +75,7 @@ TEST_CASE("aod sketch: serialization compatibility with java - empty configured
 }
 
 TEST_CASE("aod sketch: serialization compatibility with java - non-empty no entries", "[tuple_sketch]") {
-  auto update_sketch = update_array_of_doubles_sketch::builder().set_p(0.01).build();
+  auto update_sketch = update_array_of_doubles_sketch::builder().set_p(0.01f).build();
   std::vector<double> a = {1};
   update_sketch.update(1, a);
   REQUIRE_FALSE(update_sketch.is_empty());

data/vendor/datasketches-cpp/tuple/test/tuple_a_not_b_test.cpp

@@ -38,8 +38,8 @@ TEST_CASE("tuple a-not-b: empty", "[tuple_a_not_b]") {
 
 TEST_CASE("tuple a-not-b: non empty no retained keys", "[tuple_a_not_b]") {
   auto a = update_tuple_sketch<float>::builder().build();
-  a.update(1, 1);
-  auto b = update_tuple_sketch<float>::builder().set_p(0.001).build();
+  a.update(1, 1.0f);
+  auto b = update_tuple_sketch<float>::builder().set_p(0.001f).build();
   tuple_a_not_b<float> a_not_b;
 
   // B is still empty
@@ -51,7 +51,7 @@ TEST_CASE("tuple a-not-b: non empty no retained keys", "[tuple_a_not_b]") {
   REQUIRE(result.get_estimate() == 1.0);
 
   // B is not empty in estimation mode and no entries
-  b.update(1, 1);
+  b.update(1, 1.0f);
   REQUIRE(b.get_num_retained() == 0);
 
   result = a_not_b.compute(a, b);
@@ -65,11 +65,11 @@ TEST_CASE("tuple a-not-b: non empty no retained keys", "[tuple_a_not_b]") {
 TEST_CASE("tuple a-not-b: exact mode half overlap", "[tuple_a_not_b]") {
   auto a = update_tuple_sketch<float>::builder().build();
   int value = 0;
-  for (int i = 0; i < 1000; i++) a.update(value++, 1);
+  for (int i = 0; i < 1000; i++) a.update(value++, 1.0f);
 
   auto b = update_tuple_sketch<float>::builder().build();
   value = 500;
-  for (int i = 0; i < 1000; i++) b.update(value++, 1);
+  for (int i = 0; i < 1000; i++) b.update(value++, 1.0f);
 
   tuple_a_not_b<float> a_not_b;
 
@@ -105,7 +105,7 @@ TEST_CASE("tuple a-not-b: exact mode half overlap", "[tuple_a_not_b]") {
 TEST_CASE("mixed a-not-b: exact mode half overlap", "[tuple_a_not_b]") {
   auto a = update_tuple_sketch<float>::builder().build();
   int value = 0;
-  for (int i = 0; i < 1000; i++) a.update(value++, 1);
+  for (int i = 0; i < 1000; i++) a.update(value++, 1.0f);
 
   auto b = update_theta_sketch::builder().build();
   value = 500;
@@ -145,10 +145,10 @@ TEST_CASE("mixed a-not-b: exact mode half overlap", "[tuple_a_not_b]") {
 TEST_CASE("tuple a-not-b: exact mode disjoint", "[tuple_a_not_b]") {
   auto a = update_tuple_sketch<float>::builder().build();
   int value = 0;
-  for (int i = 0; i < 1000; i++) a.update(value++, 1);
+  for (int i = 0; i < 1000; i++) a.update(value++, 1.0f);
 
   auto b = update_tuple_sketch<float>::builder().build();
-  for (int i = 0; i < 1000; i++) b.update(value++, 1);
+  for (int i = 0; i < 1000; i++) b.update(value++, 1.0f);
 
   tuple_a_not_b<float> a_not_b;
 
@@ -168,7 +168,7 @@ TEST_CASE("tuple a-not-b: exact mode disjoint", "[tuple_a_not_b]") {
 TEST_CASE("tuple a-not-b: exact mode full overlap", "[tuple_a_not_b]") {
   auto sketch = update_tuple_sketch<float>::builder().build();
   int value = 0;
-  for (int i = 0; i < 1000; i++) sketch.update(value++, 1);
+  for (int i = 0; i < 1000; i++) sketch.update(value++, 1.0f);
 
   tuple_a_not_b<float> a_not_b;
 
@@ -188,11 +188,11 @@ TEST_CASE("tuple a-not-b: exact mode full overlap", "[tuple_a_not_b]") {
 TEST_CASE("tuple a-not-b: estimation mode half overlap", "[tuple_a_not_b]") {
   auto a = update_tuple_sketch<float>::builder().build();
   int value = 0;
-  for (int i = 0; i < 10000; i++) a.update(value++, 1);
+  for (int i = 0; i < 10000; i++) a.update(value++, 1.0f);
 
   auto b = update_tuple_sketch<float>::builder().build();
   value = 5000;
-  for (int i = 0; i < 10000; i++) b.update(value++, 1);
+  for (int i = 0; i < 10000; i++) b.update(value++, 1.0f);
 
   tuple_a_not_b<float> a_not_b;
 
@@ -212,10 +212,10 @@ TEST_CASE("tuple a-not-b: estimation mode half overlap", "[tuple_a_not_b]") {
 TEST_CASE("tuple a-not-b: estimation mode disjoint", "[tuple_a_not_b]") {
   auto a = update_tuple_sketch<float>::builder().build();
   int value = 0;
-  for (int i = 0; i < 10000; i++) a.update(value++, 1);
+  for (int i = 0; i < 10000; i++) a.update(value++, 1.0f);
 
   auto b = update_tuple_sketch<float>::builder().build();
-  for (int i = 0; i < 10000; i++) b.update(value++, 1);
+  for (int i = 0; i < 10000; i++) b.update(value++, 1.0f);
 
   tuple_a_not_b<float> a_not_b;
 
@@ -235,7 +235,7 @@ TEST_CASE("tuple a-not-b: estimation mode disjoint", "[tuple_a_not_b]") {
 TEST_CASE("tuple a-not-b: estimation mode full overlap", "[tuple_a_not_b]") {
   auto sketch = update_tuple_sketch<float>::builder().build();
   int value = 0;
-  for (int i = 0; i < 10000; i++) sketch.update(value++, 1);
+  for (int i = 0; i < 10000; i++) sketch.update(value++, 1.0f);
 
   tuple_a_not_b<float> a_not_b;
 
@@ -254,7 +254,7 @@ TEST_CASE("tuple a-not-b: estimation mode full overlap", "[tuple_a_not_b]") {
 
 TEST_CASE("tuple a-not-b: seed mismatch", "[tuple_a_not_b]") {
   auto sketch = update_tuple_sketch<float>::builder().build();
-  sketch.update(1, 1); // non-empty should not be ignored
+  sketch.update(1, 1.0f); // non-empty should not be ignored
   tuple_a_not_b<float> a_not_b(123);
   REQUIRE_THROWS_AS(a_not_b.compute(sketch, sketch), std::invalid_argument);
 }
@@ -262,11 +262,11 @@ TEST_CASE("tuple a-not-b: seed mismatch", "[tuple_a_not_b]") {
 TEST_CASE("tuple a-not-b: issue #152", "[tuple_a_not_b]") {
   auto a = update_tuple_sketch<float>::builder().build();
   int value = 0;
-  for (int i = 0; i < 10000; i++) a.update(value++, 1);
+  for (int i = 0; i < 10000; i++) a.update(value++, 1.0f);
 
   auto b = update_tuple_sketch<float>::builder().build();
   value = 5000;
-  for (int i = 0; i < 25000; i++) b.update(value++, 1);
+  for (int i = 0; i < 25000; i++) b.update(value++, 1.0f);
 
   tuple_a_not_b<float> a_not_b;
 

data/vendor/datasketches-cpp/tuple/test/tuple_intersection_test.cpp

@@ -59,8 +59,8 @@ TEST_CASE("tuple intersection: empty", "[tuple_intersection]") {
 }
 
 TEST_CASE("tuple intersection: non empty no retained keys", "[tuple_intersection]") {
-  auto sketch = update_tuple_sketch<float>::builder().set_p(0.001).build();
-  sketch.update(1, 1);
+  auto sketch = update_tuple_sketch<float>::builder().set_p(0.001f).build();
+  sketch.update(1, 1.0f);
   tuple_intersection_float intersection;
   intersection.update(sketch);
   auto result = intersection.get_result();
@@ -82,11 +82,11 @@ TEST_CASE("tuple intersection: non empty no retained keys", "[tuple_intersection
 TEST_CASE("tuple intersection: exact mode half overlap", "[tuple_intersection]") {
   auto sketch1 = update_tuple_sketch<float>::builder().build();
   int value = 0;
-  for (int i = 0; i < 1000; i++) sketch1.update(value++, 1);
+  for (int i = 0; i < 1000; i++) sketch1.update(value++, 1.0f);
 
   auto sketch2 = update_tuple_sketch<float>::builder().build();
   value = 500;
-  for (int i = 0; i < 1000; i++) sketch2.update(value++, 1);
+  for (int i = 0; i < 1000; i++) sketch2.update(value++, 1.0f);
 
   { // unordered
     tuple_intersection_float intersection;
@@ -111,10 +111,10 @@ TEST_CASE("tuple intersection: exact mode half overlap", "[tuple_intersection]")
 TEST_CASE("tuple intersection: exact mode disjoint", "[tuple_intersection]") {
   auto sketch1 = update_tuple_sketch<float>::builder().build();
   int value = 0;
-  for (int i = 0; i < 1000; i++) sketch1.update(value++, 1);
+  for (int i = 0; i < 1000; i++) sketch1.update(value++, 1.0f);
 
   auto sketch2 = update_tuple_sketch<float>::builder().build();
-  for (int i = 0; i < 1000; i++) sketch2.update(value++, 1);
+  for (int i = 0; i < 1000; i++) sketch2.update(value++, 1.0f);
 
   { // unordered
     tuple_intersection_float intersection;
@@ -139,7 +139,7 @@ TEST_CASE("tuple intersection: exact mode disjoint", "[tuple_intersection]") {
 TEST_CASE("mixed intersection: exact mode half overlap", "[tuple_intersection]") {
   auto sketch1 = update_tuple_sketch<float>::builder().build();
   int value = 0;
-  for (int i = 0; i < 1000; i++) sketch1.update(value++, 1);
+  for (int i = 0; i < 1000; i++) sketch1.update(value++, 1.0f);
 
   auto sketch2 = update_theta_sketch::builder().build();
   value = 500;
@@ -168,11 +168,11 @@ TEST_CASE("mixed intersection: exact mode half overlap", "[tuple_intersection]")
 TEST_CASE("tuple intersection: estimation mode half overlap", "[tuple_intersection]") {
   auto sketch1 = update_tuple_sketch<float>::builder().build();
   int value = 0;
-  for (int i = 0; i < 10000; i++) sketch1.update(value++, 1);
+  for (int i = 0; i < 10000; i++) sketch1.update(value++, 1.0f);
 
   auto sketch2 = update_tuple_sketch<float>::builder().build();
   value = 5000;
-  for (int i = 0; i < 10000; i++) sketch2.update(value++, 1);
+  for (int i = 0; i < 10000; i++) sketch2.update(value++, 1.0f);
 
   { // unordered
     tuple_intersection_float intersection;
@@ -197,10 +197,10 @@ TEST_CASE("tuple intersection: estimation mode half overlap", "[tuple_intersecti
 TEST_CASE("tuple intersection: estimation mode disjoint", "[tuple_intersection]") {
   auto sketch1 = update_tuple_sketch<float>::builder().build();
   int value = 0;
-  for (int i = 0; i < 10000; i++) sketch1.update(value++, 1);
+  for (int i = 0; i < 10000; i++) sketch1.update(value++, 1.0f);
 
   auto sketch2 = update_tuple_sketch<float>::builder().build();
-  for (int i = 0; i < 10000; i++) sketch2.update(value++, 1);
+  for (int i = 0; i < 10000; i++) sketch2.update(value++, 1.0f);
 
   { // unordered
     tuple_intersection_float intersection;
@@ -224,7 +224,7 @@ TEST_CASE("tuple intersection: estimation mode disjoint", "[tuple_intersection]"
 
 TEST_CASE("tuple intersection: seed mismatch", "[tuple_intersection]") {
   auto sketch = update_tuple_sketch<float>::builder().build();
-  sketch.update(1, 1); // non-empty should not be ignored
+  sketch.update(1, 1.0f); // non-empty should not be ignored
   tuple_intersection_float intersection(123);
   REQUIRE_THROWS_AS(intersection.update(sketch), std::invalid_argument);
 }

data/vendor/datasketches-cpp/tuple/test/tuple_jaccard_similarity_test.cpp

@@ -44,7 +44,7 @@ TEST_CASE("tuple jaccard: empty", "[tuple_sketch]") {
 
 TEST_CASE("tuple jaccard: same sketch exact mode", "[tuple_sketch]") {
   auto sk = update_tuple_sketch<float>::builder().build();
-  for (int i = 0; i < 1000; ++i) sk.update(i, 1);
+  for (int i = 0; i < 1000; ++i) sk.update(i, 1.0f);
 
   // update sketch
   auto jc = tuple_jaccard_similarity_float::jaccard(sk, sk);
@@ -61,8 +61,8 @@ TEST_CASE("tuple jaccard: full overlap exact mode", "[tuple_sketch]") {
   auto sk_a = update_tuple_sketch<float>::builder().build();
   auto sk_b = update_tuple_sketch<float>::builder().build();
   for (int i = 0; i < 1000; ++i) {
-    sk_a.update(i, 1);
-    sk_b.update(i, 1);
+    sk_a.update(i, 1.0f);
+    sk_b.update(i, 1.0f);
   }
 
   // update sketches
@@ -83,8 +83,8 @@ TEST_CASE("tuple jaccard: disjoint exact mode", "[tuple_sketch]") {
   auto sk_a = update_tuple_sketch<float>::builder().build();
   auto sk_b = update_tuple_sketch<float>::builder().build();
   for (int i = 0; i < 1000; ++i) {
-    sk_a.update(i, 1);
-    sk_b.update(i + 1000, 1);
+    sk_a.update(i, 1.0f);
+    sk_b.update(i + 1000, 1.0f);
   }
 
   // update sketches