datasketches 0.1.2 → 0.2.3

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);

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

@@ -0,0 +1,38 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#ifndef TUPLE_JACCARD_SIMILARITY_HPP_
+#define TUPLE_JACCARD_SIMILARITY_HPP_
+
+#include "theta_jaccard_similarity_base.hpp"
+#include "tuple_union.hpp"
+#include "tuple_intersection.hpp"
+
+namespace datasketches {
+
+template<
+  typename Summary,
+  typename IntersectionPolicy,
+  typename UnionPolicy = default_union_policy<Summary>,
+  typename Allocator = std::allocator<Summary>>
+using tuple_jaccard_similarity = jaccard_similarity_base<tuple_union<Summary, UnionPolicy, Allocator>, tuple_intersection<Summary, IntersectionPolicy, Allocator>, pair_extract_key<uint64_t, Summary>>;
+
+} /* namespace datasketches */
+
+# endif

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

@@ -31,7 +31,17 @@ namespace datasketches {
 template<typename S, typename A> class tuple_sketch;
 template<typename S, typename U, typename P, typename A> class update_tuple_sketch;
 template<typename S, typename A> class compact_tuple_sketch;
-template<typename A> class theta_sketch_experimental;
+template<typename A> class theta_sketch_alloc;
+
+template<typename K, typename V>
+struct pair_extract_key {
+  K& operator()(std::pair<K, V>& entry) const {
+    return entry.first;
+  }
+  const K& operator()(const std::pair<K, V>& entry) const {
+    return entry.first;
+  }
+};
 
 template<
   typename Summary,
@@ -143,7 +153,8 @@ public:
   virtual const_iterator end() const = 0;
 
 protected:
-  virtual void print_specifics(std::basic_ostream<char>& os) const = 0;
+  using ostrstream = std::basic_ostringstream<char, std::char_traits<char>, AllocChar<Allocator>>;
+  virtual void print_specifics(ostrstream& os) const = 0;
 
   static uint16_t get_seed_hash(uint64_t seed);
 
@@ -333,7 +344,8 @@ protected:
   // for builder
   update_tuple_sketch(uint8_t lg_cur_size, uint8_t lg_nom_size, resize_factor rf, uint64_t theta, uint64_t seed, const Policy& policy, const Allocator& allocator);
 
-  virtual void print_specifics(std::basic_ostream<char>& os) const;
+  using ostrstream = typename Base::ostrstream;
+  virtual void print_specifics(ostrstream& os) const;
 };
 
 // compact sketch
@@ -372,7 +384,7 @@ public:
   compact_tuple_sketch& operator=(const compact_tuple_sketch&) = default;
   compact_tuple_sketch& operator=(compact_tuple_sketch&&) = default;
 
-  compact_tuple_sketch(const theta_sketch_experimental<AllocU64>& other, const Summary& summary, bool ordered = true);
+  compact_tuple_sketch(const theta_sketch_alloc<AllocU64>& other, const Summary& summary, bool ordered = true);
 
   virtual Allocator get_allocator() const;
   virtual bool is_empty() const;
@@ -444,22 +456,25 @@ protected:
   // for deserialize
   class deleter_of_summaries {
   public:
-    deleter_of_summaries(uint32_t num, bool destroy): num(num), destroy(destroy) {}
-    void set_destroy(bool destroy) { this->destroy = destroy; }
-    void operator() (Summary* ptr) const {
+    deleter_of_summaries(uint32_t num, bool destroy, const Allocator& allocator):
+      allocator_(allocator), num_(num), destroy_(destroy) {}
+    void set_destroy(bool destroy) { destroy_ = destroy; }
+    void operator() (Summary* ptr) {
       if (ptr != nullptr) {
-        if (destroy) {
-          for (uint32_t i = 0; i < num; ++i) ptr[i].~Summary();
+        if (destroy_) {
+          for (uint32_t i = 0; i < num_; ++i) ptr[i].~Summary();
         }
-        Allocator().deallocate(ptr, num);
+        allocator_.deallocate(ptr, num_);
       }
     }
   private:
-    uint32_t num;
-    bool destroy;
+    Allocator allocator_;
+    uint32_t num_;
+    bool destroy_;
   };
 
-  virtual void print_specifics(std::basic_ostream<char>& os) const;
+  using ostrstream = typename Base::ostrstream;
+  virtual void print_specifics(ostrstream& os) const;
 
 };
 

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

@@ -53,7 +53,7 @@ double tuple_sketch<S, A>::get_upper_bound(uint8_t num_std_devs) const {
 
 template<typename S, typename A>
 string<A> tuple_sketch<S, A>::to_string(bool detail) const {
-  std::basic_ostringstream<char, std::char_traits<char>, AllocChar<A>> os;
+  ostrstream os;
   os << "### Tuple sketch summary:" << std::endl;
   os << "   num retained entries : " << get_num_retained() << std::endl;
   os << "   seed hash            : " << get_seed_hash() << std::endl;
@@ -238,7 +238,7 @@ compact_tuple_sketch<S, A> update_tuple_sketch<S, U, P, A>::compact(bool ordered
 }
 
 template<typename S, typename U, typename P, typename A>
-void update_tuple_sketch<S, U, P, A>::print_specifics(std::basic_ostream<char>& os) const {
+void update_tuple_sketch<S, U, P, A>::print_specifics(ostrstream& os) const {
   os << "   lg nominal size      : " << (int) map_.lg_nom_size_ << std::endl;
   os << "   lg current size      : " << (int) map_.lg_cur_size_ << std::endl;
   os << "   resize factor        : " << (1 << map_.rf_) << std::endl;
@@ -279,7 +279,7 @@ entries_(std::move(other.entries_))
 {}
 
 template<typename S, typename A>
-compact_tuple_sketch<S, A>::compact_tuple_sketch(const theta_sketch_experimental<AllocU64>& other, const S& summary, bool ordered):
+compact_tuple_sketch<S, A>::compact_tuple_sketch(const theta_sketch_alloc<AllocU64>& other, const S& summary, bool ordered):
 is_empty_(other.is_empty()),
 is_ordered_(other.is_ordered() || ordered),
 seed_hash_(other.get_seed_hash()),
@@ -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);
       }
     }
   }
@@ -470,10 +460,9 @@ compact_tuple_sketch<S, A> compact_tuple_sketch<S, A>::deserialize(std::istream&
   std::vector<Entry, AllocEntry> entries(alloc);
   if (!is_empty) {
     entries.reserve(num_entries);
-    std::unique_ptr<S, deleter_of_summaries> summary(alloc.allocate(1), deleter_of_summaries(1, false));
+    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);
       }
     }
   }
@@ -533,10 +520,10 @@ compact_tuple_sketch<S, A> compact_tuple_sketch<S, A>::deserialize(const void* b
   std::vector<Entry, AllocEntry> entries(alloc);
   if (!is_empty) {
     entries.reserve(num_entries);
-    std::unique_ptr<S, deleter_of_summaries> summary(alloc.allocate(1), deleter_of_summaries(1, false));
+    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,26 +535,26 @@ 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>
-void compact_tuple_sketch<S, A>::print_specifics(std::basic_ostream<char>&) const {}
+void compact_tuple_sketch<S, A>::print_specifics(ostrstream&) const {}
 
 // builder
 

data/vendor/datasketches-cpp/tuple/test/CMakeLists.txt

@@ -43,11 +43,6 @@ target_sources(tuple_test
     tuple_union_test.cpp
     tuple_intersection_test.cpp
     tuple_a_not_b_test.cpp
-    array_of_doubles_sketch_test.cpp
-    theta_sketch_experimental_test.cpp
-    theta_union_experimental_test.cpp
-    theta_intersection_experimental_test.cpp
-    theta_a_not_b_experimental_test.cpp
-    theta_jaccard_similarity_test.cpp
     tuple_jaccard_similarity_test.cpp
+    array_of_doubles_sketch_test.cpp
 )

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());