datasketches 0.2.0 → 0.2.4

data/vendor/datasketches-cpp/req/test/req_sketch_test.cpp

@@ -55,15 +55,15 @@ TEST_CASE("req sketch: empty", "[req_sketch]") {
 
 TEST_CASE("req sketch: single value, lra", "[req_sketch]") {
   req_sketch<float> sketch(12, false);
-  sketch.update(1);
+  sketch.update(1.0f);
   REQUIRE_FALSE(sketch.is_HRA());
   REQUIRE_FALSE(sketch.is_empty());
   REQUIRE_FALSE(sketch.is_estimation_mode());
   REQUIRE(sketch.get_n() == 1);
   REQUIRE(sketch.get_num_retained() == 1);
-  REQUIRE(sketch.get_rank(1) == 0);
-  REQUIRE(sketch.get_rank<true>(1) == 1);
-  REQUIRE(sketch.get_rank(1.1) == 1);
+  REQUIRE(sketch.get_rank(1.0f) == 0);
+  REQUIRE(sketch.get_rank<true>(1.0f) == 1);
+  REQUIRE(sketch.get_rank(1.1f) == 1);
   REQUIRE(sketch.get_rank(std::numeric_limits<float>::infinity()) == 1);
   REQUIRE(sketch.get_quantile(0) == 1);
   REQUIRE(sketch.get_quantile(0.5) == 1);
@@ -86,43 +86,43 @@ TEST_CASE("req sketch: single value, lra", "[req_sketch]") {
 
 TEST_CASE("req sketch: repeated values", "[req_sketch]") {
   req_sketch<float> sketch(12);
-  sketch.update(1);
-  sketch.update(1);
-  sketch.update(1);
-  sketch.update(2);
-  sketch.update(2);
-  sketch.update(2);
+  sketch.update(1.0f);
+  sketch.update(1.0f);
+  sketch.update(1.0f);
+  sketch.update(2.0f);
+  sketch.update(2.0f);
+  sketch.update(2.0f);
   REQUIRE_FALSE(sketch.is_empty());
   REQUIRE_FALSE(sketch.is_estimation_mode());
   REQUIRE(sketch.get_n() == 6);
   REQUIRE(sketch.get_num_retained() == 6);
-  REQUIRE(sketch.get_rank(1) == 0);
-  REQUIRE(sketch.get_rank<true>(1) == 0.5);
-  REQUIRE(sketch.get_rank(2) == 0.5);
-  REQUIRE(sketch.get_rank<true>(2) == 1);
+  REQUIRE(sketch.get_rank(1.0f) == 0);
+  REQUIRE(sketch.get_rank<true>(1.0f) == 0.5);
+  REQUIRE(sketch.get_rank(2.0f) == 0.5);
+  REQUIRE(sketch.get_rank<true>(2.0f) == 1);
 }
 
 TEST_CASE("req sketch: exact mode", "[req_sketch]") {
   req_sketch<float> sketch(12);
-  for (size_t i = 1; i <= 10; ++i) sketch.update(i);
+  for (size_t i = 1; i <= 10; ++i) sketch.update(static_cast<float>(i));
   REQUIRE_FALSE(sketch.is_empty());
   REQUIRE_FALSE(sketch.is_estimation_mode());
   REQUIRE(sketch.get_n() == 10);
   REQUIRE(sketch.get_num_retained() == 10);
 
   // like KLL
-  REQUIRE(sketch.get_rank(1) == 0);
-  REQUIRE(sketch.get_rank(2) == 0.1);
-  REQUIRE(sketch.get_rank(6) == 0.5);
-  REQUIRE(sketch.get_rank(9) == 0.8);
-  REQUIRE(sketch.get_rank(10) == 0.9);
+  REQUIRE(sketch.get_rank(1.0f) == 0);
+  REQUIRE(sketch.get_rank(2.0f) == 0.1);
+  REQUIRE(sketch.get_rank(6.0f) == 0.5);
+  REQUIRE(sketch.get_rank(9.0f) == 0.8);
+  REQUIRE(sketch.get_rank(10.0f) == 0.9);
 
   // inclusive
-  REQUIRE(sketch.get_rank<true>(1) == 0.1);
-  REQUIRE(sketch.get_rank<true>(2) == 0.2);
-  REQUIRE(sketch.get_rank<true>(5) == 0.5);
-  REQUIRE(sketch.get_rank<true>(9) == 0.9);
-  REQUIRE(sketch.get_rank<true>(10) == 1);
+  REQUIRE(sketch.get_rank<true>(1.0f) == 0.1);
+  REQUIRE(sketch.get_rank<true>(2.0f) == 0.2);
+  REQUIRE(sketch.get_rank<true>(5.0f) == 0.5);
+  REQUIRE(sketch.get_rank<true>(9.0f) == 0.9);
+  REQUIRE(sketch.get_rank<true>(10.0f) == 1);
 
   // like KLL
   REQUIRE(sketch.get_quantile(0) == 1);
@@ -164,16 +164,16 @@ TEST_CASE("req sketch: exact mode", "[req_sketch]") {
 TEST_CASE("req sketch: estimation mode", "[req_sketch]") {
   req_sketch<float> sketch(12);
   const size_t n = 100000;
-  for (size_t i = 0; i < n; ++i) sketch.update(i);
+  for (size_t i = 0; i < n; ++i) sketch.update(static_cast<float>(i));
   REQUIRE_FALSE(sketch.is_empty());
   REQUIRE(sketch.is_estimation_mode());
   REQUIRE(sketch.get_n() == n);
 //  std::cout << sketch.to_string(true);
   REQUIRE(sketch.get_num_retained() < n);
   REQUIRE(sketch.get_rank(0) == 0);
-  REQUIRE(sketch.get_rank(n) == 1);
-  REQUIRE(sketch.get_rank(n / 2) == Approx(0.5).margin(0.01));
-  REQUIRE(sketch.get_rank(n - 1) == Approx(1).margin(0.01));
+  REQUIRE(sketch.get_rank(static_cast<float>(n)) == 1);
+  REQUIRE(sketch.get_rank(n / 2.0f) == Approx(0.5).margin(0.01));
+  REQUIRE(sketch.get_rank(n - 1.0f) == Approx(1).margin(0.01));
   REQUIRE(sketch.get_min_value() == 0);
   REQUIRE(sketch.get_max_value() == n - 1);
   REQUIRE(sketch.get_rank_lower_bound(0.5, 1) < 0.5);
@@ -219,7 +219,7 @@ TEST_CASE("req sketch: byte serialize-deserialize empty", "[req_sketch]") {
 
 TEST_CASE("req sketch: stream serialize-deserialize single item", "[req_sketch]") {
   req_sketch<float> sketch(12);
-  sketch.update(1);
+  sketch.update(1.0f);
 
   std::stringstream s(std::ios::in | std::ios::out | std::ios::binary);
   sketch.serialize(s);
@@ -235,7 +235,7 @@ TEST_CASE("req sketch: stream serialize-deserialize single item", "[req_sketch]"
 
 TEST_CASE("req sketch: byte serialize-deserialize single item", "[req_sketch]") {
   req_sketch<float> sketch(12);
-  sketch.update(1);
+  sketch.update(1.0f);
 
   auto bytes = sketch.serialize();
   REQUIRE(bytes.size() == sketch.get_serialized_size_bytes());
@@ -253,7 +253,7 @@ TEST_CASE("req sketch: byte serialize-deserialize single item", "[req_sketch]")
 TEST_CASE("req sketch: stream serialize-deserialize exact mode", "[req_sketch]") {
   req_sketch<float> sketch(12);
   const size_t n = 50;
-  for (size_t i = 0; i < n; ++i) sketch.update(i);
+  for (size_t i = 0; i < n; ++i) sketch.update(static_cast<float>(i));
   REQUIRE_FALSE(sketch.is_estimation_mode());
 
   std::stringstream s(std::ios::in | std::ios::out | std::ios::binary);
@@ -271,7 +271,7 @@ TEST_CASE("req sketch: stream serialize-deserialize exact mode", "[req_sketch]")
 TEST_CASE("req sketch: byte serialize-deserialize exact mode", "[req_sketch]") {
   req_sketch<float> sketch(12);
   const size_t n = 50;
-  for (size_t i = 0; i < n; ++i) sketch.update(i);
+  for (size_t i = 0; i < n; ++i) sketch.update(static_cast<float>(i));
   REQUIRE_FALSE(sketch.is_estimation_mode());
 
   auto bytes = sketch.serialize();
@@ -290,7 +290,7 @@ TEST_CASE("req sketch: byte serialize-deserialize exact mode", "[req_sketch]") {
 TEST_CASE("req sketch: stream serialize-deserialize estimation mode", "[req_sketch]") {
   req_sketch<float> sketch(12);
   const size_t n = 100000;
-  for (size_t i = 0; i < n; ++i) sketch.update(i);
+  for (size_t i = 0; i < n; ++i) sketch.update(static_cast<float>(i));
   REQUIRE(sketch.is_estimation_mode());
 
   std::stringstream s(std::ios::in | std::ios::out | std::ios::binary);
@@ -308,7 +308,7 @@ TEST_CASE("req sketch: stream serialize-deserialize estimation mode", "[req_sket
 TEST_CASE("req sketch: byte serialize-deserialize estimation mode", "[req_sketch]") {
   req_sketch<float> sketch(12);
   const size_t n = 100000;
-  for (size_t i = 0; i < n; ++i) sketch.update(i);
+  for (size_t i = 0; i < n; ++i) sketch.update(static_cast<float>(i));
   REQUIRE(sketch.is_estimation_mode());
 
   auto bytes = sketch.serialize();
@@ -326,7 +326,7 @@ TEST_CASE("req sketch: byte serialize-deserialize estimation mode", "[req_sketch
 TEST_CASE("req sketch: serialize deserialize stream and bytes equivalence", "[req_sketch]") {
   req_sketch<float> sketch(12);
   const size_t n = 100000;
-  for (size_t i = 0; i < n; ++i) sketch.update(i);
+  for (size_t i = 0; i < n; ++i) sketch.update(static_cast<float>(i));
   REQUIRE(sketch.is_estimation_mode());
 
   std::stringstream s(std::ios::in | std::ios::out | std::ios::binary);
@@ -373,8 +373,8 @@ TEST_CASE("req sketch: stream deserialize from Java - single item", "[req_sketch
   REQUIRE(sketch.get_num_retained() == 1);
   REQUIRE(sketch.get_min_value() == 1);
   REQUIRE(sketch.get_max_value() == 1);
-  REQUIRE(sketch.get_rank(1) == 0);
-  REQUIRE(sketch.get_rank<true>(1) == 1);
+  REQUIRE(sketch.get_rank(1.0f) == 0);
+  REQUIRE(sketch.get_rank<true>(1.0f) == 1);
 }
 
 TEST_CASE("req sketch: stream deserialize from Java - raw items", "[req_sketch]") {
@@ -388,7 +388,7 @@ TEST_CASE("req sketch: stream deserialize from Java - raw items", "[req_sketch]"
   REQUIRE(sketch.get_num_retained() == 4);
   REQUIRE(sketch.get_min_value() == 0);
   REQUIRE(sketch.get_max_value() == 3);
-  REQUIRE(sketch.get_rank(2) == 0.5);
+  REQUIRE(sketch.get_rank(2.0f) == 0.5);
 }
 
 TEST_CASE("req sketch: stream deserialize from Java - exact mode", "[req_sketch]") {
@@ -402,7 +402,7 @@ TEST_CASE("req sketch: stream deserialize from Java - exact mode", "[req_sketch]
   REQUIRE(sketch.get_num_retained() == 100);
   REQUIRE(sketch.get_min_value() == 0);
   REQUIRE(sketch.get_max_value() == 99);
-  REQUIRE(sketch.get_rank(50) == 0.5);
+  REQUIRE(sketch.get_rank(50.0f) == 0.5);
 }
 
 TEST_CASE("req sketch: stream deserialize from Java - estimation mode", "[req_sketch]") {
@@ -416,14 +416,14 @@ TEST_CASE("req sketch: stream deserialize from Java - estimation mode", "[req_sk
   REQUIRE(sketch.get_num_retained() == 2942);
   REQUIRE(sketch.get_min_value() == 0);
   REQUIRE(sketch.get_max_value() == 9999);
-  REQUIRE(sketch.get_rank(5000) == 0.5);
+  REQUIRE(sketch.get_rank(5000.0f) == 0.5);
 }
 
 TEST_CASE("req sketch: merge into empty", "[req_sketch]") {
   req_sketch<float> sketch1(40);
 
   req_sketch<float> sketch2(40);
-  for (size_t i = 0; i < 1000; ++i) sketch2.update(i);
+  for (size_t i = 0; i < 1000; ++i) sketch2.update(static_cast<float>(i));
 
   sketch1.merge(sketch2);
   REQUIRE(sketch1.get_min_value() == 0);
@@ -431,15 +431,15 @@ TEST_CASE("req sketch: merge into empty", "[req_sketch]") {
   REQUIRE(sketch1.get_quantile(0.25) == Approx(250).margin(3));
   REQUIRE(sketch1.get_quantile(0.5) == Approx(500).margin(3));
   REQUIRE(sketch1.get_quantile(0.75) == Approx(750).margin(3));
-  REQUIRE(sketch1.get_rank(500) == Approx(0.5).margin(0.01));
+  REQUIRE(sketch1.get_rank(500.0f) == Approx(0.5).margin(0.01));
 }
 
 TEST_CASE("req sketch: merge", "[req_sketch]") {
   req_sketch<float> sketch1(100);
-  for (size_t i = 0; i < 1000; ++i) sketch1.update(i);
+  for (size_t i = 0; i < 1000; ++i) sketch1.update(static_cast<float>(i));
 
   req_sketch<float> sketch2(100);
-  for (size_t i = 1000; i < 2000; ++i) sketch2.update(i);
+  for (size_t i = 1000; i < 2000; ++i) sketch2.update(static_cast<float>(i));
 
   sketch1.merge(sketch2);
   REQUIRE(sketch1.get_min_value() == 0);
@@ -447,18 +447,18 @@ TEST_CASE("req sketch: merge", "[req_sketch]") {
   REQUIRE(sketch1.get_quantile(0.25) == Approx(500).margin(3));
   REQUIRE(sketch1.get_quantile(0.5) == Approx(1000).margin(1));
   REQUIRE(sketch1.get_quantile(0.75) == Approx(1500).margin(1));
-  REQUIRE(sketch1.get_rank(1000) == Approx(0.5).margin(0.01));
+  REQUIRE(sketch1.get_rank(1000.0f) == Approx(0.5).margin(0.01));
 }
 
 TEST_CASE("req sketch: merge multiple", "[req_sketch]") {
   req_sketch<float> sketch1(12);
-  for (size_t i = 0; i < 40; ++i) sketch1.update(i);
+  for (size_t i = 0; i < 40; ++i) sketch1.update(static_cast<float>(i));
 
   req_sketch<float> sketch2(12);
-  for (size_t i = 40; i < 80; ++i) sketch2.update(i);
+  for (size_t i = 40; i < 80; ++i) sketch2.update(static_cast<float>(i));
 
   req_sketch<float> sketch3(12);
-  for (size_t i = 80; i < 120; ++i) sketch3.update(i);
+  for (size_t i = 80; i < 120; ++i) sketch3.update(static_cast<float>(i));
 
   req_sketch<float> sketch(12);
   sketch.merge(sketch1);
@@ -467,15 +467,15 @@ TEST_CASE("req sketch: merge multiple", "[req_sketch]") {
   REQUIRE(sketch.get_min_value() == 0);
   REQUIRE(sketch.get_max_value() == 119);
   REQUIRE(sketch.get_quantile(0.5) == Approx(60).margin(3));
-  REQUIRE(sketch.get_rank(60) == Approx(0.5).margin(0.01));
+  REQUIRE(sketch.get_rank(60.0f) == Approx(0.5).margin(0.01));
 }
 
 TEST_CASE("req sketch: merge incompatible HRA and LRA", "[req_sketch]") {
   req_sketch<float> sketch1(12);
-  sketch1.update(1);
+  sketch1.update(1.0f);
 
   req_sketch<float> sketch2(12, false);
-  sketch2.update(1);
+  sketch2.update(1.0f);
 
   REQUIRE_THROWS_AS(sketch1.merge(sketch2), std::invalid_argument);
 }

data/vendor/datasketches-cpp/sampling/CMakeLists.txt

@@ -32,17 +32,13 @@ target_include_directories(sampling
 target_link_libraries(sampling INTERFACE common)
 target_compile_features(sampling INTERFACE cxx_std_11)
 
-set(sampling_HEADERS "include/var_opt_sketch.hpp;include/var_opt_sketch_impl.hpp")
-
 install(TARGETS sampling
   EXPORT ${PROJECT_NAME}
 )
 
-install(FILES ${sampling_HEADERS}
+install(FILES 
+		include/var_opt_sketch.hpp
+		include/var_opt_sketch_impl.hpp
+		include/var_opt_union.hpp
+		include/var_opt_union_impl.hpp
   DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/DataSketches")
-
-target_sources(sampling
-  INTERFACE
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/var_opt_sketch.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/var_opt_sketch_impl.hpp
-)

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

@@ -51,18 +51,23 @@ struct subset_summary {
   double total_sketch_weight;
 };
 
-enum resize_factor { X1 = 0, X2, X4, X8 };
-
 template <typename T, typename S, typename A> class var_opt_union; // forward declaration
 
+namespace var_opt_constants {
+    const resize_factor DEFAULT_RESIZE_FACTOR = resize_factor::X8;
+    const uint32_t MAX_K = ((uint32_t) 1 << 31) - 2; 
+}
+
 template <typename T, typename S = serde<T>, typename A = std::allocator<T>>
 class var_opt_sketch {
 
   public:
-    static const resize_factor DEFAULT_RESIZE_FACTOR = X8;
-    static const uint32_t MAX_K = ((uint32_t) 1 << 31) - 2;
+    static const resize_factor DEFAULT_RESIZE_FACTOR = var_opt_constants::DEFAULT_RESIZE_FACTOR;
+    static const uint32_t MAX_K = var_opt_constants::MAX_K;
 
-    explicit var_opt_sketch(uint32_t k, resize_factor rf = DEFAULT_RESIZE_FACTOR, const A& allocator = A());
+    explicit var_opt_sketch(uint32_t k,
+      resize_factor rf = var_opt_constants::DEFAULT_RESIZE_FACTOR,
+      const A& allocator = A());
     var_opt_sketch(const var_opt_sketch& other);
     var_opt_sketch(var_opt_sketch&& other) noexcept;
 

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

@@ -128,7 +128,7 @@ var_opt_sketch<T,S,A>::var_opt_sketch(T* data, double* weights, size_t len,
   r_(r_count),
   n_(n),
   total_wt_r_(total_wt_r),
-  rf_(DEFAULT_RESIZE_FACTOR),
+  rf_(var_opt_constants::DEFAULT_RESIZE_FACTOR),
   curr_items_alloc_(len),
   filled_data_(n > k),
   allocator_(allocator),
@@ -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);
@@ -740,8 +731,10 @@ void var_opt_sketch<T,S,A>::update(T&& item, double weight) {
 
 template<typename T, typename S, typename A>
 string<A> var_opt_sketch<T,S,A>::to_string() const {
-  std::basic_ostringstream<char, std::char_traits<char>, AllocChar<A>> os;
-  os << "### VarOpt SUMMARY: " << std::endl;
+  // Using a temporary stream for implementation here does not comply with AllocatorAwareContainer requirements.
+  // The stream does not support passing an allocator instance, and alternatives are complicated.
+  std::ostringstream os;
+  os << "### VarOpt SUMMARY:" << std::endl;
   os << "   k            : " << k_ << std::endl;
   os << "   h            : " << h_ << std::endl;
   os << "   r            : " << r_ << std::endl;
@@ -749,24 +742,28 @@ string<A> var_opt_sketch<T,S,A>::to_string() const {
   os << "   Current size : " << curr_items_alloc_ << std::endl;
   os << "   Resize factor: " << (1 << rf_) << std::endl;
   os << "### END SKETCH SUMMARY" << std::endl;
-  return os.str();
+  return string<A>(os.str().c_str(), allocator_);
 }
 
 template<typename T, typename S, typename A>
 string<A> var_opt_sketch<T,S,A>::items_to_string() const {
-  std::basic_ostringstream<char, std::char_traits<char>, AllocChar<A>> os;
+  // Using a temporary stream for implementation here does not comply with AllocatorAwareContainer requirements.
+  // The stream does not support passing an allocator instance, and alternatives are complicated.
+  std::ostringstream os;
   os << "### Sketch Items" << std::endl;
   int idx = 0;
   for (auto record : *this) {
     os << idx << ": " << record.first << "\twt = " << record.second << std::endl;
     ++idx;
   }
-  return os.str();
+  return string<A>(os.str().c_str(), allocator_);
 }
 
 template<typename T, typename S, typename A>
 string<A> var_opt_sketch<T,S,A>::items_to_string(bool print_gap) const {
-  std::basic_ostringstream<char, std::char_traits<char>, AllocChar<A>> os;
+  // Using a temporary stream for implementation here does not comply with AllocatorAwareContainer requirements.
+  // The stream does not support passing an allocator instance, and alternatives are complicated.
+  std::ostringstream os;
   os << "### Sketch Items" << std::endl;
   const uint32_t array_length = (n_ < k_ ? n_ : k_ + 1);
   for (uint32_t i = 0, display_idx = 0; i < array_length; ++i) {
@@ -783,7 +780,7 @@ string<A> var_opt_sketch<T,S,A>::items_to_string(bool print_gap) const {
       ++display_idx;
     }
   }
-  return os.str();
+  return string<A>(os.str().c_str(), allocator_);
 }
 
 template<typename T, typename S, typename A>
@@ -1420,7 +1417,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])) {