datasketches 0.2.1 → 0.2.2

data/vendor/datasketches-cpp/theta/include/theta_union.hpp

@@ -35,13 +35,13 @@ public:
   using CompactSketch = compact_theta_sketch_alloc<Allocator>;
   using resize_factor = theta_constants::resize_factor;
 
-  struct pass_through_policy {
-    uint64_t operator()(uint64_t internal_entry, uint64_t incoming_entry) const {
+  struct nop_policy {
+    void operator()(uint64_t internal_entry, uint64_t incoming_entry) const {
+      unused(internal_entry);
       unused(incoming_entry);
-      return internal_entry;
     }
   };
-  using State = theta_union_base<Entry, ExtractKey, pass_through_policy, Sketch, CompactSketch, Allocator>;
+  using State = theta_union_base<Entry, ExtractKey, nop_policy, Sketch, CompactSketch, Allocator>;
 
   // No constructor here. Use builder instead.
   class builder;

data/vendor/datasketches-cpp/theta/include/theta_union_base_impl.hpp

@@ -43,7 +43,7 @@ void theta_union_base<EN, EK, P, S, CS, A>::update(SS&& sketch) {
   if (sketch.get_theta64() < union_theta_) union_theta_ = sketch.get_theta64();
   for (auto& entry: sketch) {
     const uint64_t hash = EK()(entry);
-    if (hash < union_theta_) {
+    if (hash < union_theta_ && hash < table_.theta_) {
       auto result = table_.find(hash);
       if (!result.second) {
         table_.insert(result.first, conditional_forward<SS>(entry));

data/vendor/datasketches-cpp/theta/include/theta_union_impl.hpp

@@ -24,7 +24,7 @@ namespace datasketches {
 
 template<typename A>
 theta_union_alloc<A>::theta_union_alloc(uint8_t lg_cur_size, uint8_t lg_nom_size, resize_factor rf, uint64_t theta, uint64_t seed, const A& allocator):
-state_(lg_cur_size, lg_nom_size, rf, theta, seed, pass_through_policy(), allocator)
+state_(lg_cur_size, lg_nom_size, rf, theta, seed, nop_policy(), allocator)
 {}
 
 template<typename A>

data/vendor/datasketches-cpp/theta/include/theta_update_sketch_base.hpp

@@ -53,6 +53,8 @@ struct theta_update_sketch_base {
   inline uint64_t hash_and_screen(const void* data, size_t length);
 
   inline std::pair<iterator, bool> find(uint64_t key) const;
+  static inline std::pair<iterator, bool> find(Entry* entries, uint8_t lg_size, uint64_t key);
+
 
   template<typename FwdEntry>
   inline void insert(iterator it, FwdEntry&& entry);

data/vendor/datasketches-cpp/theta/include/theta_update_sketch_base_impl.hpp

@@ -39,7 +39,7 @@ seed_(seed),
 entries_(nullptr)
 {
   if (lg_cur_size > 0) {
-    const size_t size = 1 << lg_cur_size;
+    const size_t size = 1ULL << lg_cur_size;
     entries_ = allocator_.allocate(size);
     for (size_t i = 0; i < size; ++i) EK()(entries_[i]) = 0;
   }
@@ -58,7 +58,7 @@ seed_(other.seed_),
 entries_(nullptr)
 {
   if (other.entries_ != nullptr) {
-    const size_t size = 1 << lg_cur_size_;
+    const size_t size = 1ULL << lg_cur_size_;
     entries_ = allocator_.allocate(size);
     for (size_t i = 0; i < size; ++i) {
       if (EK()(other.entries_[i]) != 0) {
@@ -89,7 +89,7 @@ template<typename EN, typename EK, typename A>
 theta_update_sketch_base<EN, EK, A>::~theta_update_sketch_base()
 {
   if (entries_ != nullptr) {
-    const size_t size = 1 << lg_cur_size_;
+    const size_t size = 1ULL << lg_cur_size_;
     for (size_t i = 0; i < size; ++i) {
       if (EK()(entries_[i]) != 0) entries_[i].~EN();
     }
@@ -136,18 +136,23 @@ uint64_t theta_update_sketch_base<EN, EK, A>::hash_and_screen(const void* data,
 
 template<typename EN, typename EK, typename A>
 auto theta_update_sketch_base<EN, EK, A>::find(uint64_t key) const -> std::pair<iterator, bool> {
-  const size_t size = 1 << lg_cur_size_;
-  const size_t mask = size - 1;
-  const uint32_t stride = get_stride(key, lg_cur_size_);
+  return find(entries_, lg_cur_size_, key);
+}
+
+template<typename EN, typename EK, typename A>
+auto theta_update_sketch_base<EN, EK, A>::find(EN* entries, uint8_t lg_size, uint64_t key) -> std::pair<iterator, bool> {
+  const uint32_t size = 1 << lg_size;
+  const uint32_t mask = size - 1;
+  const uint32_t stride = get_stride(key, lg_size);
   uint32_t index = static_cast<uint32_t>(key) & mask;
   // search for duplicate or zero
   const uint32_t loop_index = index;
   do {
-    const uint64_t probe = EK()(entries_[index]);
+    const uint64_t probe = EK()(entries[index]);
     if (probe == 0) {
-      return std::pair<iterator, bool>(&entries_[index], false);
+      return std::pair<iterator, bool>(&entries[index], false);
     } else if (probe == key) {
-      return std::pair<iterator, bool>(&entries_[index], true);
+      return std::pair<iterator, bool>(&entries[index], true);
     }
     index = (index + stride) & mask;
   } while (index != loop_index);
@@ -175,13 +180,13 @@ auto theta_update_sketch_base<EN, EK, A>::begin() const -> iterator {
 
 template<typename EN, typename EK, typename A>
 auto theta_update_sketch_base<EN, EK, A>::end() const -> iterator {
-  return &entries_[1 << lg_cur_size_];
+  return &entries_[1ULL << lg_cur_size_];
 }
 
 template<typename EN, typename EK, typename A>
 uint32_t theta_update_sketch_base<EN, EK, A>::get_capacity(uint8_t lg_cur_size, uint8_t lg_nom_size) {
   const double fraction = (lg_cur_size <= lg_nom_size) ? RESIZE_THRESHOLD : REBUILD_THRESHOLD;
-  return std::floor(fraction * (1 << lg_cur_size));
+  return static_cast<uint32_t>(std::floor(fraction * (1 << lg_cur_size)));
 }
 
 template<typename EN, typename EK, typename A>
@@ -192,29 +197,29 @@ uint32_t theta_update_sketch_base<EN, EK, A>::get_stride(uint64_t key, uint8_t l
 
 template<typename EN, typename EK, typename A>
 void theta_update_sketch_base<EN, EK, A>::resize() {
-  const size_t old_size = 1 << lg_cur_size_;
-  const uint8_t lg_tgt_size = lg_nom_size_ + 1;
-  const uint8_t factor = std::max(1, std::min(static_cast<int>(rf_), lg_tgt_size - lg_cur_size_));
-  lg_cur_size_ += factor;
-  const size_t new_size = 1 << lg_cur_size_;
-  EN* old_entries = entries_;
-  entries_ = allocator_.allocate(new_size);
-  for (size_t i = 0; i < new_size; ++i) EK()(entries_[i]) = 0;
-  num_entries_ = 0;
+  const size_t old_size = 1ULL << lg_cur_size_;
+  const uint8_t lg_new_size = std::min<uint8_t>(lg_cur_size_ + static_cast<uint8_t>(rf_), lg_nom_size_ + 1);
+  const size_t new_size = 1ULL << lg_new_size;
+  EN* new_entries = allocator_.allocate(new_size);
+  for (size_t i = 0; i < new_size; ++i) EK()(new_entries[i]) = 0;
   for (size_t i = 0; i < old_size; ++i) {
-    const uint64_t key = EK()(old_entries[i]);
+    const uint64_t key = EK()(entries_[i]);
     if (key != 0) {
-      insert(find(key).first, std::move(old_entries[i])); // consider a special insert with no comparison
-      old_entries[i].~EN();
+      // always finds an empty slot in a larger table
+      new (find(new_entries, lg_new_size, key).first) EN(std::move(entries_[i]));
+      entries_[i].~EN();
+      EK()(entries_[i]) = 0;
     }
   }
-  allocator_.deallocate(old_entries, old_size);
+  std::swap(entries_, new_entries);
+  lg_cur_size_ = lg_new_size;
+  allocator_.deallocate(new_entries, old_size);
 }
 
 // assumes number of entries > nominal size
 template<typename EN, typename EK, typename A>
 void theta_update_sketch_base<EN, EK, A>::rebuild() {
-  const size_t size = 1 << lg_cur_size_;
+  const size_t size = 1ULL << lg_cur_size_;
   const uint32_t nominal_size = 1 << lg_nom_size_;
 
   // empty entries have uninitialized payloads
@@ -227,10 +232,10 @@ void theta_update_sketch_base<EN, EK, A>::rebuild() {
   const size_t num_old_entries = num_entries_;
   entries_ = allocator_.allocate(size);
   for (size_t i = 0; i < size; ++i) EK()(entries_[i]) = 0;
-  num_entries_ = 0;
+  num_entries_ = nominal_size;
   // relies on consolidating non-empty entries to the front
   for (size_t i = 0; i < nominal_size; ++i) {
-    insert(find(EK()(old_entries[i])).first, std::move(old_entries[i])); // consider a special insert with no comparison
+    new (find(EK()(old_entries[i])).first) EN(std::move(old_entries[i]));
     old_entries[i].~EN();
   }
   for (size_t i = nominal_size; i < num_old_entries; ++i) old_entries[i].~EN();
@@ -301,7 +306,7 @@ Derived& theta_base_builder<Derived, Allocator>::set_seed(uint64_t seed) {
 
 template<typename Derived, typename Allocator>
 uint64_t theta_base_builder<Derived, Allocator>::starting_theta() const {
-  if (p_ < 1) return theta_constants::MAX_THETA * p_;
+  if (p_ < 1) return static_cast<uint64_t>(theta_constants::MAX_THETA * p_);
   return theta_constants::MAX_THETA;
 }
 

data/vendor/datasketches-cpp/theta/test/theta_a_not_b_test.cpp

@@ -37,7 +37,7 @@ TEST_CASE("theta a-not-b: empty", "[theta_a_not_b]") {
 TEST_CASE("theta a-not-b: non empty no retained keys", "[theta_a_not_b]") {
   update_theta_sketch a = update_theta_sketch::builder().build();
   a.update(1);
-  update_theta_sketch b = update_theta_sketch::builder().set_p(0.001).build();
+  update_theta_sketch b = update_theta_sketch::builder().set_p(0.001f).build();
   theta_a_not_b a_not_b;
 
   // B is still empty
@@ -167,6 +167,28 @@ TEST_CASE("theta a-not-b: estimation mode half overlap", "[theta_a_not_b]") {
   REQUIRE(result.get_estimate() == Approx(5000).margin(5000 * 0.02));
 }
 
+TEST_CASE("theta a-not-b: estimation mode half overlap wrapped compact", "[theta_a_not_b]") {
+  update_theta_sketch a = update_theta_sketch::builder().build();
+  int value = 0;
+  for (int i = 0; i < 10000; i++) a.update(value++);
+  auto bytes_a = a.compact().serialize();
+
+  update_theta_sketch b = update_theta_sketch::builder().build();
+  value = 5000;
+  for (int i = 0; i < 10000; i++) b.update(value++);
+  auto bytes_b = b.compact().serialize();
+
+  theta_a_not_b a_not_b;
+
+  auto result = a_not_b.compute(
+    wrapped_compact_theta_sketch::wrap(bytes_a.data(), bytes_a.size()),
+    wrapped_compact_theta_sketch::wrap(bytes_b.data(), bytes_b.size())
+  );
+  REQUIRE_FALSE(result.is_empty());
+  REQUIRE(result.is_estimation_mode());
+  REQUIRE(result.get_estimate() == Approx(5000).margin(5000 * 0.02));
+}
+
 TEST_CASE("theta a-not-b: estimation mode disjoint", "[theta_a_not_b]") {
   update_theta_sketch a = update_theta_sketch::builder().build();
   int value = 0;

data/vendor/datasketches-cpp/theta/test/theta_intersection_test.cpp

@@ -48,7 +48,7 @@ TEST_CASE("theta intersection: empty", "[theta_intersection]") {
 }
 
 TEST_CASE("theta intersection: non empty no retained keys", "[theta_intersection]") {
-  update_theta_sketch sketch = update_theta_sketch::builder().set_p(0.001).build();
+  update_theta_sketch sketch = update_theta_sketch::builder().set_p(0.001f).build();
   sketch.update(1);
   theta_intersection intersection;
   intersection.update(sketch);
@@ -174,6 +174,26 @@ TEST_CASE("theta intersection: estimation mode half overlap ordered", "[theta_in
   REQUIRE(result.get_estimate() == Approx(5000).margin(5000 * 0.02));
 }
 
+TEST_CASE("theta intersection: estimation mode half overlap ordered wrapped compact", "[theta_intersection]") {
+  update_theta_sketch sketch1 = update_theta_sketch::builder().build();
+  int value = 0;
+  for (int i = 0; i < 10000; i++) sketch1.update(value++);
+  auto bytes1 = sketch1.compact().serialize();
+
+  update_theta_sketch sketch2 = update_theta_sketch::builder().build();
+  value = 5000;
+  for (int i = 0; i < 10000; i++) sketch2.update(value++);
+  auto bytes2 = sketch2.compact().serialize();
+
+  theta_intersection intersection;
+  intersection.update(wrapped_compact_theta_sketch::wrap(bytes1.data(), bytes1.size()));
+  intersection.update(wrapped_compact_theta_sketch::wrap(bytes2.data(), bytes2.size()));
+  compact_theta_sketch result = intersection.get_result();
+  REQUIRE_FALSE(result.is_empty());
+  REQUIRE(result.is_estimation_mode());
+  REQUIRE(result.get_estimate() == Approx(5000).margin(5000 * 0.02));
+}
+
 TEST_CASE("theta intersection: estimation mode disjoint unordered", "[theta_intersection]") {
   update_theta_sketch sketch1 = update_theta_sketch::builder().build();
   int value = 0;

data/vendor/datasketches-cpp/theta/test/theta_jaccard_similarity_test.cpp

@@ -100,6 +100,28 @@ TEST_CASE("theta jaccard: half overlap estimation mode", "[theta_sketch]") {
   REQUIRE(jc[2] == Approx(0.33).margin(0.01));
 }
 
+TEST_CASE("theta jaccard: half overlap estimation mode custom seed", "[theta_sketch]") {
+  const uint64_t seed = 123;
+  auto sk_a = update_theta_sketch::builder().set_seed(seed).build();
+  auto sk_b = update_theta_sketch::builder().set_seed(seed).build();
+  for (int i = 0; i < 10000; ++i) {
+    sk_a.update(i);
+    sk_b.update(i + 5000);
+  }
+
+  // update sketches
+  auto jc = theta_jaccard_similarity::jaccard(sk_a, sk_b, seed);
+  REQUIRE(jc[0] == Approx(0.33).margin(0.01));
+  REQUIRE(jc[1] == Approx(0.33).margin(0.01));
+  REQUIRE(jc[2] == Approx(0.33).margin(0.01));
+
+  // compact sketches
+  jc = theta_jaccard_similarity::jaccard(sk_a.compact(), sk_b.compact(), seed);
+  REQUIRE(jc[0] == Approx(0.33).margin(0.01));
+  REQUIRE(jc[1] == Approx(0.33).margin(0.01));
+  REQUIRE(jc[2] == Approx(0.33).margin(0.01));
+}
+
 /**
  * The distribution is quite tight, about +/- 0.7%, which is pretty good since the accuracy of the
  * underlying sketch is about +/- 1.56%.
@@ -107,7 +129,7 @@ TEST_CASE("theta jaccard: half overlap estimation mode", "[theta_sketch]") {
 TEST_CASE("theta jaccard: similarity test", "[theta_sketch]") {
   const int8_t min_lg_k = 12;
   const int u1 = 1 << 20;
-  const int u2 = u1 * 0.95;
+  const int u2 = static_cast<int>(u1 * 0.95);
   const double threshold = 0.943;
 
   auto expected = update_theta_sketch::builder().set_lg_k(min_lg_k).build();
@@ -120,6 +142,23 @@ TEST_CASE("theta jaccard: similarity test", "[theta_sketch]") {
   REQUIRE(theta_jaccard_similarity::similarity_test(actual, actual, threshold));
 }
 
+TEST_CASE("theta jaccard: similarity test custom seed", "[theta_sketch]") {
+  const int8_t min_lg_k = 12;
+  const int u1 = 1 << 20;
+  const int u2 = static_cast<int>(u1 * 0.95);
+  const double threshold = 0.943;
+  const uint64_t seed = 1234;
+
+  auto expected = update_theta_sketch::builder().set_lg_k(min_lg_k).set_seed(seed).build();
+  for (int i = 0; i < u1; ++i) expected.update(i);
+
+  auto actual = update_theta_sketch::builder().set_lg_k(min_lg_k).set_seed(seed).build();
+  for (int i = 0; i < u2; ++i) actual.update(i);
+
+  REQUIRE(theta_jaccard_similarity::similarity_test(actual, expected, threshold, seed));
+  REQUIRE(theta_jaccard_similarity::similarity_test(actual, actual, threshold, seed));
+}
+
 /**
  * The distribution is much looser here, about +/- 14%. This is due to the fact that intersections loose accuracy
  * as the ratio of intersection to the union becomes a small number.
@@ -127,7 +166,7 @@ TEST_CASE("theta jaccard: similarity test", "[theta_sketch]") {
 TEST_CASE("theta jaccard: dissimilarity test", "[theta_sketch]") {
   const int8_t min_lg_k = 12;
   const int u1 = 1 << 20;
-  const int u2 = u1 * 0.05;
+  const int u2 = static_cast<int>(u1 * 0.05);
   const double threshold = 0.061;
 
   auto expected = update_theta_sketch::builder().set_lg_k(min_lg_k).build();
@@ -140,4 +179,21 @@ TEST_CASE("theta jaccard: dissimilarity test", "[theta_sketch]") {
   REQUIRE_FALSE(theta_jaccard_similarity::dissimilarity_test(actual, actual, threshold));
 }
 
+TEST_CASE("theta jaccard: dissimilarity test custom seed", "[theta_sketch]") {
+  const int8_t min_lg_k = 12;
+  const int u1 = 1 << 20;
+  const int u2 = static_cast<int>(u1 * 0.05);
+  const double threshold = 0.061;
+  const uint64_t seed = 1234;
+
+  auto expected = update_theta_sketch::builder().set_lg_k(min_lg_k).set_seed(seed).build();
+  for (int i = 0; i < u1; ++i) expected.update(i);
+
+  auto actual = update_theta_sketch::builder().set_lg_k(min_lg_k).set_seed(seed).build();
+  for (int i = 0; i < u2; ++i) actual.update(i);
+
+  REQUIRE(theta_jaccard_similarity::dissimilarity_test(actual, expected, threshold, seed));
+  REQUIRE_FALSE(theta_jaccard_similarity::dissimilarity_test(actual, actual, threshold, seed));
+}
+
 } /* namespace datasketches */

data/vendor/datasketches-cpp/theta/test/theta_sketch_test.cpp

@@ -50,7 +50,7 @@ TEST_CASE("theta sketch: empty", "[theta_sketch]") {
 }
 
 TEST_CASE("theta sketch: non empty no retained keys", "[theta_sketch]") {
-  update_theta_sketch update_sketch = update_theta_sketch::builder().set_p(0.001).build();
+  update_theta_sketch update_sketch = update_theta_sketch::builder().set_p(0.001f).build();
   update_sketch.update(1);
   //std::cerr << update_sketch.to_string();
   REQUIRE(update_sketch.get_num_retained() == 0);
@@ -238,4 +238,40 @@ TEST_CASE("theta sketch: deserialize compact single item buffer overrun", "[thet
   REQUIRE_THROWS_AS(compact_theta_sketch::deserialize(bytes.data(), bytes.size() - 1), std::out_of_range);
 }
 
+TEST_CASE("theta sketch: conversion constructor and wrapped compact", "[theta_sketch]") {
+  update_theta_sketch update_sketch = update_theta_sketch::builder().build();
+  const int n = 8192;
+  for (int i = 0; i < n; i++) update_sketch.update(i);
+
+  // unordered
+  auto unordered_compact1 = update_sketch.compact(false);
+  compact_theta_sketch unordered_compact2(update_sketch, false);
+  auto it = unordered_compact1.begin();
+  for (auto entry: unordered_compact2) {
+    REQUIRE(*it == entry);
+    ++it;
+  }
+
+  // ordered
+  auto ordered_compact1 = update_sketch.compact();
+  compact_theta_sketch ordered_compact2(update_sketch, true);
+  it = ordered_compact1.begin();
+  for (auto entry: ordered_compact2) {
+    REQUIRE(*it == entry);
+    ++it;
+  }
+
+  // wrapped compact
+  auto bytes = ordered_compact1.serialize();
+  auto ordered_compact3 = wrapped_compact_theta_sketch::wrap(bytes.data(), bytes.size());
+  it = ordered_compact1.begin();
+  for (auto entry: ordered_compact3) {
+    REQUIRE(*it == entry);
+    ++it;
+  }
+
+  // seed mismatch
+  REQUIRE_THROWS_AS(wrapped_compact_theta_sketch::wrap(bytes.data(), bytes.size(), 0), std::invalid_argument);
+}
+
 } /* namespace datasketches */

data/vendor/datasketches-cpp/theta/test/theta_union_test.cpp

@@ -39,7 +39,7 @@ TEST_CASE("theta union: empty", "[theta_union]") {
 }
 
 TEST_CASE("theta union: non empty no retained keys", "[theta_union]") {
-  update_theta_sketch update_sketch = update_theta_sketch::builder().set_p(0.001).build();
+  update_theta_sketch update_sketch = update_theta_sketch::builder().set_p(0.001f).build();
   update_sketch.update(1);
   theta_union u = theta_union::builder().build();
   u.update(update_sketch);
@@ -65,7 +65,27 @@ TEST_CASE("theta union: exact mode half overlap", "[theta_union]") {
   compact_theta_sketch sketch3 = u.get_result();
   REQUIRE_FALSE(sketch3.is_empty());
   REQUIRE_FALSE(sketch3.is_estimation_mode());
-  REQUIRE(sketch3.get_estimate() == Approx(1500).margin(1500 * 0.01));
+  REQUIRE(sketch3.get_estimate() == 1500.0);
+}
+
+TEST_CASE("theta union: exact mode half overlap wrapped compact", "[theta_union]") {
+  update_theta_sketch sketch1 = update_theta_sketch::builder().build();
+  int value = 0;
+  for (int i = 0; i < 1000; i++) sketch1.update(value++);
+  auto bytes1 = sketch1.compact().serialize();
+
+  update_theta_sketch sketch2 = update_theta_sketch::builder().build();
+  value = 500;
+  for (int i = 0; i < 1000; i++) sketch2.update(value++);
+  auto bytes2 = sketch2.compact().serialize();
+
+  theta_union u = theta_union::builder().build();
+  u.update(wrapped_compact_theta_sketch::wrap(bytes1.data(), bytes1.size()));
+  u.update(wrapped_compact_theta_sketch::wrap(bytes2.data(), bytes2.size()));
+  compact_theta_sketch sketch3 = u.get_result();
+  REQUIRE_FALSE(sketch3.is_empty());
+  REQUIRE_FALSE(sketch3.is_estimation_mode());
+  REQUIRE(sketch3.get_estimate() == 1500.0);
 }
 
 TEST_CASE("theta union: estimation mode half overlap", "[theta_union]") {

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

@@ -70,33 +70,33 @@ uint8_t compact_array_of_doubles_sketch_alloc<A>::get_num_values() const {
 template<typename A>
 void compact_array_of_doubles_sketch_alloc<A>::serialize(std::ostream& os) const {
   const uint8_t preamble_longs = 1;
-  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 flags_byte(
     (this->is_empty() ? 1 << flags::IS_EMPTY : 0) |
     (this->get_num_retained() > 0 ? 1 << flags::HAS_ENTRIES : 0) |
     (this->is_ordered() ? 1 << flags::IS_ORDERED : 0)
   );
-  os.write(reinterpret_cast<const char*>(&flags_byte), sizeof(flags_byte));
-  os.write(reinterpret_cast<const char*>(&num_values_), sizeof(num_values_));
+  write(os, flags_byte);
+  write(os, num_values_);
   const uint16_t seed_hash = this->get_seed_hash();
-  os.write(reinterpret_cast<const char*>(&seed_hash), sizeof(seed_hash));
-  os.write(reinterpret_cast<const char*>(&(this->theta_)), sizeof(uint64_t));
+  write(os, seed_hash);
+  write(os, this->theta_);
   if (this->get_num_retained() > 0) {
-    const uint32_t num_entries = this->entries_.size();
-    os.write(reinterpret_cast<const char*>(&num_entries), sizeof(num_entries));
+    const uint32_t num_entries = static_cast<uint32_t>(this->entries_.size());
+    write(os, num_entries);
     const uint32_t unused32 = 0;
-    os.write(reinterpret_cast<const char*>(&unused32), sizeof(unused32));
+    write(os, unused32);
     for (const auto& it: this->entries_) {
-      os.write(reinterpret_cast<const char*>(&it.first), sizeof(uint64_t));
+      write(os, it.first);
     }
     for (const auto& it: this->entries_) {
-      os.write(reinterpret_cast<const char*>(it.second.data()), it.second.size() * sizeof(double));
+      write(os, it.second.data(), it.second.size() * sizeof(double));
     }
   }
 }
@@ -110,30 +110,29 @@ auto compact_array_of_doubles_sketch_alloc<A>::serialize(unsigned header_size_by
   vector_bytes bytes(size, 0, this->entries_.get_allocator());
   uint8_t* ptr = bytes.data() + header_size_bytes;
 
-  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));
+  ptr += copy_to_mem(type, ptr);
   const uint8_t flags_byte(
     (this->is_empty() ? 1 << flags::IS_EMPTY : 0) |
     (this->get_num_retained() ? 1 << flags::HAS_ENTRIES : 0) |
     (this->is_ordered() ? 1 << flags::IS_ORDERED : 0)
   );
-  ptr += copy_to_mem(&flags_byte, ptr, sizeof(flags_byte));
-  ptr += copy_to_mem(&num_values_, ptr, sizeof(num_values_));
+  ptr += copy_to_mem(flags_byte, ptr);
+  ptr += copy_to_mem(num_values_, ptr);
   const uint16_t seed_hash = this->get_seed_hash();
-  ptr += copy_to_mem(&seed_hash, ptr, sizeof(seed_hash));
-  ptr += copy_to_mem(&(this->theta_), ptr, sizeof(uint64_t));
+  ptr += copy_to_mem(seed_hash, ptr);
+  ptr += copy_to_mem((this->theta_), ptr);
   if (this->get_num_retained() > 0) {
-    const uint32_t num_entries = this->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>(this->entries_.size());
+    ptr += copy_to_mem(num_entries, ptr);
+    ptr += sizeof(uint32_t); // unused
     for (const auto& it: this->entries_) {
-      ptr += copy_to_mem(&it.first, ptr, sizeof(uint64_t));
+      ptr += copy_to_mem(it.first, ptr);
     }
     for (const auto& it: this->entries_) {
       ptr += copy_to_mem(it.second.data(), ptr, it.second.size() * sizeof(double));
@@ -144,40 +143,30 @@ auto compact_array_of_doubles_sketch_alloc<A>::serialize(unsigned header_size_by
 
 template<typename A>
 compact_array_of_doubles_sketch_alloc<A> compact_array_of_doubles_sketch_alloc<A>::deserialize(std::istream& is, uint64_t seed, 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 flags_byte;
-  is.read(reinterpret_cast<char*>(&flags_byte), sizeof(flags_byte));
-  uint8_t num_values;
-  is.read(reinterpret_cast<char*>(&num_values), sizeof(num_values));
-  uint16_t seed_hash;
-  is.read(reinterpret_cast<char*>(&seed_hash), sizeof(seed_hash));
+  read<uint8_t>(is); // unused
+  const auto serial_version = read<uint8_t>(is);
+  const auto family = read<uint8_t>(is);
+  const auto type = read<uint8_t>(is);
+  const auto flags_byte = read<uint8_t>(is);
+  const auto num_values = 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);
   const bool has_entries = flags_byte & (1 << flags::HAS_ENTRIES);
   if (has_entries) checker<true>::check_seed_hash(seed_hash, compute_seed_hash(seed));
 
-  uint64_t theta;
-  is.read(reinterpret_cast<char*>(&theta), sizeof(theta));
+  const auto theta = read<uint64_t>(is);
   std::vector<Entry, AllocEntry> entries(allocator);
   if (has_entries) {
-    uint32_t num_entries;
-    is.read(reinterpret_cast<char*>(&num_entries), sizeof(num_entries));
-    uint32_t unused32;
-    is.read(reinterpret_cast<char*>(&unused32), sizeof(unused32));
+    const auto num_entries = read<uint32_t>(is);
+    read<uint32_t>(is); // unused
     entries.reserve(num_entries);
     std::vector<uint64_t, AllocU64> keys(num_entries, 0, allocator);
-    is.read(reinterpret_cast<char*>(keys.data()), num_entries * sizeof(uint64_t));
+    read(is, keys.data(), num_entries * sizeof(uint64_t));
     for (size_t i = 0; i < num_entries; ++i) {
       aod<A> summary(num_values, allocator);
-      is.read(reinterpret_cast<char*>(summary.data()), num_values * sizeof(double));
+      read(is, summary.data(), num_values * sizeof(double));
       entries.push_back(Entry(keys[i], std::move(summary)));
     }
   }
@@ -191,20 +180,19 @@ template<typename A>
 compact_array_of_doubles_sketch_alloc<A> compact_array_of_doubles_sketch_alloc<A>::deserialize(const void* bytes, size_t size, uint64_t seed, const A& allocator) {
   ensure_minimum_memory(size, 16);
   const char* ptr = static_cast<const char*>(bytes);
-  uint8_t preamble_longs;
-  ptr += copy_from_mem(ptr, &preamble_longs, sizeof(preamble_longs));
+  ptr += sizeof(uint8_t); // unused
   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));
+  ptr += copy_from_mem(ptr, type);
   uint8_t flags_byte;
-  ptr += copy_from_mem(ptr, &flags_byte, sizeof(flags_byte));
+  ptr += copy_from_mem(ptr, flags_byte);
   uint8_t num_values;
-  ptr += copy_from_mem(ptr, &num_values, sizeof(num_values));
+  ptr += copy_from_mem(ptr, num_values);
   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);
@@ -212,14 +200,13 @@ compact_array_of_doubles_sketch_alloc<A> compact_array_of_doubles_sketch_alloc<A
   if (has_entries) checker<true>::check_seed_hash(seed_hash, compute_seed_hash(seed));
 
   uint64_t theta;
-  ptr += copy_from_mem(ptr, &theta, sizeof(theta));
+  ptr += copy_from_mem(ptr, theta);
   std::vector<Entry, AllocEntry> entries(allocator);
   if (has_entries) {
     ensure_minimum_memory(size, 24);
     uint32_t num_entries;
-    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
     ensure_minimum_memory(size, 24 + (sizeof(uint64_t) + sizeof(double) * num_values) * num_entries);
     entries.reserve(num_entries);
     std::vector<uint64_t, AllocU64> keys(num_entries, 0, allocator);