datasketches 0.2.0 → 0.2.4

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

@@ -30,8 +30,8 @@ namespace datasketches {
 template<typename T, typename S, typename A>
 var_opt_union<T,S,A>::var_opt_union(uint32_t max_k, const A& allocator) :
   n_(0),
-  outer_tau_numer_(0),
-  outer_tau_denom_(0.0),
+  outer_tau_numer_(0.0),
+  outer_tau_denom_(0),
   max_k_(max_k),
   gadget_(max_k, var_opt_sketch<T,S,A>::DEFAULT_RESIZE_FACTOR, true, allocator)
 {}
@@ -129,16 +129,11 @@ var_opt_union<T,S,A>& var_opt_union<T,S,A>::operator=(var_opt_union&& other) {
 
 template<typename T, typename S, typename A>
 var_opt_union<T,S,A> var_opt_union<T,S,A>::deserialize(std::istream& is, const A& allocator) {
-  uint8_t preamble_longs;
-  is.read((char*)&preamble_longs, sizeof(preamble_longs));
-  uint8_t serial_version;
-  is.read((char*)&serial_version, sizeof(serial_version));
-  uint8_t family_id;
-  is.read((char*)&family_id, sizeof(family_id));
-  uint8_t flags;
-  is.read((char*)&flags, sizeof(flags));
-  uint32_t max_k;
-  is.read((char*)&max_k, sizeof(max_k));
+  const auto preamble_longs = read<uint8_t>(is);
+  const auto serial_version = read<uint8_t>(is);
+  const auto family_id = read<uint8_t>(is);
+  const auto flags = read<uint8_t>(is);
+  const auto max_k = read<uint32_t>(is);
 
   check_preamble_longs(preamble_longs, flags);
   check_family_and_serialization_version(family_id, serial_version);
@@ -156,12 +151,9 @@ var_opt_union<T,S,A> var_opt_union<T,S,A>::deserialize(std::istream& is, const A
       return var_opt_union<T,S,A>(max_k);
   }
 
-  uint64_t items_seen;
-  is.read((char*)&items_seen, sizeof(items_seen));
-  double outer_tau_numer;
-  is.read((char*)&outer_tau_numer, sizeof(outer_tau_numer));
-  uint64_t outer_tau_denom;
-  is.read((char*)&outer_tau_denom, sizeof(outer_tau_denom));
+  const auto items_seen = read<uint64_t>(is);
+  const auto outer_tau_numer = read<double>(is);
+  const auto outer_tau_denom = read<uint64_t>(is);
 
   var_opt_sketch<T,S,A> gadget = var_opt_sketch<T,S,A>::deserialize(is, allocator);
 
@@ -176,15 +168,15 @@ var_opt_union<T,S,A> var_opt_union<T,S,A>::deserialize(const void* bytes, size_t
   ensure_minimum_memory(size, 8);
   const char* ptr = static_cast<const char*>(bytes);
   uint8_t preamble_longs;
-  ptr += copy_from_mem(ptr, &preamble_longs, sizeof(preamble_longs));
+  ptr += copy_from_mem(ptr, preamble_longs);
   uint8_t serial_version;
-  ptr += copy_from_mem(ptr, &serial_version, sizeof(serial_version));
+  ptr += copy_from_mem(ptr, serial_version);
   uint8_t family_id;
-  ptr += copy_from_mem(ptr, &family_id, sizeof(family_id));
+  ptr += copy_from_mem(ptr, family_id);
   uint8_t flags;
-  ptr += copy_from_mem(ptr, &flags, sizeof(flags));
+  ptr += copy_from_mem(ptr, flags);
   uint32_t max_k;
-  ptr += copy_from_mem(ptr, &max_k, sizeof(max_k));
+  ptr += copy_from_mem(ptr, max_k);
 
   check_preamble_longs(preamble_longs, flags);
   check_family_and_serialization_version(family_id, serial_version);
@@ -200,11 +192,11 @@ var_opt_union<T,S,A> var_opt_union<T,S,A>::deserialize(const void* bytes, size_t
   }
 
   uint64_t items_seen;
-  ptr += copy_from_mem(ptr, &items_seen, sizeof(items_seen));
+  ptr += copy_from_mem(ptr, items_seen);
   double outer_tau_numer;
-  ptr += copy_from_mem(ptr, &outer_tau_numer, sizeof(outer_tau_numer));
+  ptr += copy_from_mem(ptr, outer_tau_numer);
   uint64_t outer_tau_denom;
-  ptr += copy_from_mem(ptr, &outer_tau_denom, sizeof(outer_tau_denom));
+  ptr += copy_from_mem(ptr, outer_tau_denom);
 
   const size_t gadget_size = size - (PREAMBLE_LONGS_NON_EMPTY << 3);
   var_opt_sketch<T,S,A> gadget = var_opt_sketch<T,S,A>::deserialize(ptr, gadget_size, allocator);
@@ -238,16 +230,16 @@ void var_opt_union<T,S,A>::serialize(std::ostream& os) const {
     flags = 0;
   }
 
-  os.write((char*) &preamble_longs, sizeof(uint8_t));
-  os.write((char*) &serialization_version, sizeof(uint8_t));
-  os.write((char*) &family_id, sizeof(uint8_t));
-  os.write((char*) &flags, sizeof(uint8_t));
-  os.write((char*) &max_k_, sizeof(uint32_t));
+  write(os, preamble_longs);
+  write(os, serialization_version);
+  write(os, family_id);
+  write(os, flags);
+  write(os, max_k_);
 
   if (!empty) {
-    os.write((char*) &n_, sizeof(uint64_t));
-    os.write((char*) &outer_tau_numer_, sizeof(double));
-    os.write((char*) &outer_tau_denom_, sizeof(uint64_t));
+    write(os, n_);
+    write(os, outer_tau_numer_);
+    write(os, outer_tau_denom_);
     gadget_.serialize(os);
   }
 }
@@ -275,16 +267,16 @@ std::vector<uint8_t, AllocU8<A>> var_opt_union<T,S,A>::serialize(unsigned header
   }
 
   // first prelong
-  ptr += copy_to_mem(&preamble_longs, ptr, sizeof(uint8_t));
-  ptr += copy_to_mem(&serialization_version, ptr, sizeof(uint8_t));
-  ptr += copy_to_mem(&family_id, ptr, sizeof(uint8_t));
-  ptr += copy_to_mem(&flags, ptr, sizeof(uint8_t));
-  ptr += copy_to_mem(&max_k_, ptr, sizeof(uint32_t));
+  ptr += copy_to_mem(preamble_longs, ptr);
+  ptr += copy_to_mem(serialization_version, ptr);
+  ptr += copy_to_mem(family_id, ptr);
+  ptr += copy_to_mem(flags, ptr);
+  ptr += copy_to_mem(max_k_, ptr);
 
   if (!empty) {
-    ptr += copy_to_mem(&n_, ptr, sizeof(uint64_t));
-    ptr += copy_to_mem(&outer_tau_numer_, ptr, sizeof(double));
-    ptr += copy_to_mem(&outer_tau_denom_, ptr, sizeof(uint64_t));
+    ptr += copy_to_mem(n_, ptr);
+    ptr += copy_to_mem(outer_tau_numer_, ptr);
+    ptr += copy_to_mem(outer_tau_denom_, ptr);
 
     auto gadget_bytes = gadget_.serialize();
     ptr += copy_to_mem(gadget_bytes.data(), ptr, gadget_bytes.size() * sizeof(uint8_t));
@@ -303,14 +295,16 @@ void var_opt_union<T,S,A>::reset() {
 
 template<typename T, typename S, typename A>
 string<A> var_opt_union<T,S,A>::to_string() const {
-  std::basic_ostringstream<char, std::char_traits<char>, AllocChar<A>> os;
-  os << "### VarOpt Union SUMMARY: " << std::endl;
-  os << " . n             : " << n_ << 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 Union SUMMARY:" << std::endl;
+  os << "   n             : " << n_ << std::endl;
   os << "   Max k         : " << max_k_ << std::endl;
-  os << "   Gadget Summary: " << std::endl;
+  os << "   Gadget Summary:" << std::endl;
   os << gadget_.to_string();
-  os << "### END VarOpt Union SUMMARY: " << std::endl;
-  return os.str();
+  os << "### END VarOpt Union SUMMARY" << std::endl;
+  return string<A>(os.str().c_str(), gadget_.allocator_);
 }
 
 template<typename T, typename S, typename A>

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

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

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

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

data/vendor/datasketches-cpp/setup.py

@@ -49,8 +49,9 @@ class CMakeBuild(build_ext):
             os.path.dirname(self.get_ext_fullpath(ext.name)))
         cmake_args =  ['-DCMAKE_LIBRARY_OUTPUT_DIRECTORY=' + extdir]
         cmake_args += ['-DWITH_PYTHON=True']
+        cmake_args += ['-DCMAKE_CXX_STANDARD=11']
         # ensure we use a consistent python version
-        cmake_args += ['-DPYTHON_EXECUTABLE=' + sys.executable]
+        cmake_args += ['-DPython3_EXECUTABLE=' + sys.executable]
         cfg = 'Debug' if self.debug else 'Release'
         build_args = ['--config', cfg]
 
@@ -59,7 +60,8 @@ class CMakeBuild(build_ext):
                            cfg.upper(),
                            extdir)]
             if sys.maxsize > 2**32:
-                cmake_args += ['-A', 'x64']
+                cmake_args += ['-T', 'host=x64']
+                cmake_args += ['-DCMAKE_GENERATOR_PLATFORM=x64']
                 build_args += ['--', '/m']
         else:
             cmake_args += ['-DCMAKE_BUILD_TYPE=' + cfg]
@@ -74,23 +76,24 @@ class CMakeBuild(build_ext):
         subprocess.check_call(['cmake', ext.sourcedir] + cmake_args,
                               cwd=self.build_temp, env=env)
         subprocess.check_call(['cmake', '--build', '.', '--target', 'python'] + build_args,
-                              cwd=self.build_temp)
+                              cwd=self.build_temp, env=env)
         print() # add an empty line to pretty print
 
 setup(
     name='datasketches',
-    version='3.0.0',
-    author='Apache DataSketches Developers',
+    version='3.3.0',
+    author='Apache Software Foundation',
     author_email='dev@datasketches.apache.org',
-    description='A wrapper for the C++ Apache DataSketches library',
+    description='The Apache DataSketches Library for Python',
     license='Apache License 2.0',
     url='http://datasketches.apache.org',
     long_description=open('python/README.md').read(),
+    long_description_content_type='text/markdown',
     packages=find_packages('python'), # python pacakges only in this dir
     package_dir={'':'python'},
     # may need to add all source paths for sdist packages w/o MANIFEST.in
     ext_modules=[CMakeExtension('datasketches')],
     cmdclass={'build_ext': CMakeBuild},
-    setup_requires=['setuptools_scm','tox-setuptools'],
+    install_requires=['numpy'],
     zip_safe=False
 )

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

@@ -32,53 +32,34 @@ target_include_directories(theta
 target_link_libraries(theta INTERFACE common)
 target_compile_features(theta INTERFACE cxx_std_11)
 
-set(theta_HEADERS "")
-list(APPEND theta_HEADERS "include/theta_sketch.hpp;include/theta_sketch_impl.hpp")
-list(APPEND theta_HEADERS "include/theta_union.hpp;include/theta_union_impl.hpp")
-list(APPEND theta_HEADERS "include/theta_intersection.hpp;include/theta_intersection_impl.hpp")
-list(APPEND theta_HEADERS "include/theta_a_not_b.hpp;include/theta_a_not_b_impl.hpp")
-list(APPEND theta_HEADERS "include/theta_jaccard_similarity.hpp")
-list(APPEND theta_HEADERS "include/theta_comparators.hpp")
-list(APPEND theta_HEADERS "include/theta_constants.hpp")
-list(APPEND theta_HEADERS "include/theta_helpers.hpp")
-list(APPEND theta_HEADERS "include/theta_update_sketch_base.hpp;include/theta_update_sketch_base_impl.hpp")
-list(APPEND theta_HEADERS "include/theta_union_base.hpp;include/theta_union_base_impl.hpp")
-list(APPEND theta_HEADERS "include/theta_intersection_base.hpp;include/theta_intersection_base_impl.hpp")
-list(APPEND theta_HEADERS "include/theta_set_difference_base.hpp;include/theta_set_difference_base_impl.hpp")
-list(APPEND theta_HEADERS "include/theta_jaccard_similarity_base.hpp")
-list(APPEND theta_HEADERS "include/bounds_on_ratios_in_sampled_sets.hpp")
-list(APPEND theta_HEADERS "include/bounds_on_ratios_in_theta_sketched_sets.hpp")
-
 install(TARGETS theta
   EXPORT ${PROJECT_NAME}
 )
 
-install(FILES ${theta_HEADERS}
+install(FILES 
+			include/theta_sketch.hpp
+			include/theta_sketch_impl.hpp
+			include/theta_union.hpp
+			include/theta_union_impl.hpp
+			include/theta_intersection.hpp
+			include/theta_intersection_impl.hpp
+			include/theta_a_not_b.hpp
+			include/theta_a_not_b_impl.hpp
+			include/theta_jaccard_similarity.hpp
+			include/theta_comparators.hpp
+			include/theta_constants.hpp
+			include/theta_helpers.hpp
+			include/theta_update_sketch_base.hpp
+			include/theta_update_sketch_base_impl.hpp
+			include/theta_union_base.hpp
+			include/theta_union_base_impl.hpp
+			include/theta_intersection_base.hpp
+			include/theta_intersection_base_impl.hpp
+			include/theta_set_difference_base.hpp
+			include/theta_set_difference_base_impl.hpp
+			include/theta_jaccard_similarity_base.hpp
+			include/bounds_on_ratios_in_sampled_sets.hpp
+			include/bounds_on_ratios_in_theta_sketched_sets.hpp
+			include/compact_theta_sketch_parser.hpp
+			include/compact_theta_sketch_parser_impl.hpp
   DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/DataSketches")
-
-target_sources(theta
-  INTERFACE
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/theta_sketch.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/theta_union.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/theta_intersection.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/theta_a_not_b.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/theta_sketch_impl.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/theta_union_impl.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/theta_intersection_impl.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/theta_a_not_b_impl.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/theta_jaccard_similarity.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/theta_comparators.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/theta_constants.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/theta_helpers.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/theta_update_sketch_base.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/theta_update_sketch_base_impl.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/theta_union_base.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/theta_union_base_impl.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/theta_intersection_base.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/theta_intersection_base_impl.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/theta_set_difference_base.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/theta_set_difference_base_impl.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/theta_jaccard_similarity_base.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/bounds_on_ratios_in_sampled_sets.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/bounds_on_ratios_in_theta_sketched_sets.hpp
-)

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

@@ -90,7 +90,7 @@ public:
    * @param f the inclusion probability used to produce the set with size <i>a</i>.
    * @return the approximate lower bound
    */
-  static double estimate_of_a(uint64_t a, uint64_t f) {
+  static double estimate_of_a(uint64_t a, double f) {
     check_inputs(a, 1, f);
     return a / f;
   }

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

@@ -0,0 +1,67 @@
+/*
+ * 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 COMPACT_THETA_SKETCH_PARSER_HPP_
+#define COMPACT_THETA_SKETCH_PARSER_HPP_
+
+#include <stdint.h>
+
+namespace datasketches {
+
+template<bool dummy>
+class compact_theta_sketch_parser {
+public:
+  struct compact_theta_sketch_data {
+    bool is_empty;
+    bool is_ordered;
+    uint16_t seed_hash;
+    uint32_t num_entries;
+    uint64_t theta;
+    const uint64_t* entries;
+  };
+
+  static compact_theta_sketch_data parse(const void* ptr, size_t size, uint64_t seed, bool dump_on_error = false);
+
+private:
+  // offsets are in sizeof(type)
+  static const size_t COMPACT_SKETCH_PRE_LONGS_BYTE = 0;
+  static const size_t COMPACT_SKETCH_SERIAL_VERSION_BYTE = 1;
+  static const size_t COMPACT_SKETCH_TYPE_BYTE = 2;
+  static const size_t COMPACT_SKETCH_FLAGS_BYTE = 5;
+  static const size_t COMPACT_SKETCH_SEED_HASH_U16 = 3;
+  static const size_t COMPACT_SKETCH_NUM_ENTRIES_U32 = 2;
+  static const size_t COMPACT_SKETCH_SINGLE_ENTRY_U64 = 1;
+  static const size_t COMPACT_SKETCH_ENTRIES_EXACT_U64 = 2;
+  static const size_t COMPACT_SKETCH_THETA_U64 = 2;
+  static const size_t COMPACT_SKETCH_ENTRIES_ESTIMATION_U64 = 3;
+
+  static const uint8_t COMPACT_SKETCH_IS_EMPTY_FLAG = 2;
+  static const uint8_t COMPACT_SKETCH_IS_ORDERED_FLAG = 4;
+
+  static const uint8_t COMPACT_SKETCH_SERIAL_VERSION = 3;
+  static const uint8_t COMPACT_SKETCH_TYPE = 3;
+
+  static std::string hex_dump(const uint8_t* ptr, size_t size);
+};
+
+} /* namespace datasketches */
+
+#include "compact_theta_sketch_parser_impl.hpp"
+
+#endif

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

@@ -0,0 +1,137 @@
+/*
+ * 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 COMPACT_THETA_SKETCH_PARSER_IMPL_HPP_
+#define COMPACT_THETA_SKETCH_PARSER_IMPL_HPP_
+
+#include <iostream>
+#include <iomanip>
+
+namespace datasketches {
+
+template<bool dummy>
+auto compact_theta_sketch_parser<dummy>::parse(const void* ptr, size_t size, uint64_t seed, bool dump_on_error) -> compact_theta_sketch_data {
+  if (size < 8) throw std::invalid_argument("at least 8 bytes expected, actual " + std::to_string(size)
+      + (dump_on_error ? (", sketch dump: " + hex_dump(reinterpret_cast<const uint8_t*>(ptr), size)) : ""));
+
+  uint8_t serial_version = reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_SERIAL_VERSION_BYTE];
+
+  switch(serial_version) {
+  case COMPACT_SKETCH_SERIAL_VERSION: {
+      checker<true>::check_sketch_type(reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_TYPE_BYTE], COMPACT_SKETCH_TYPE);
+      uint64_t theta = theta_constants::MAX_THETA;
+      const uint16_t seed_hash = reinterpret_cast<const uint16_t*>(ptr)[COMPACT_SKETCH_SEED_HASH_U16];
+      if (reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_FLAGS_BYTE] & (1 << COMPACT_SKETCH_IS_EMPTY_FLAG)) {
+        return {true, true, seed_hash, 0, theta, nullptr};
+      }
+      checker<true>::check_seed_hash(seed_hash, compute_seed_hash(seed));
+      const bool has_theta = reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_PRE_LONGS_BYTE] > 2;
+      if (has_theta) {
+        if (size < 16) throw std::invalid_argument("at least 16 bytes expected, actual " + std::to_string(size));
+        theta = reinterpret_cast<const uint64_t*>(ptr)[COMPACT_SKETCH_THETA_U64];
+      }
+      if (reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_PRE_LONGS_BYTE] == 1) {
+        return {false, true, seed_hash, 1, theta, reinterpret_cast<const uint64_t*>(ptr) + COMPACT_SKETCH_SINGLE_ENTRY_U64};
+      }
+      const uint32_t num_entries = reinterpret_cast<const uint32_t*>(ptr)[COMPACT_SKETCH_NUM_ENTRIES_U32];
+      const size_t entries_start_u64 = has_theta ? COMPACT_SKETCH_ENTRIES_ESTIMATION_U64 : COMPACT_SKETCH_ENTRIES_EXACT_U64;
+      const uint64_t* entries = reinterpret_cast<const uint64_t*>(ptr) + entries_start_u64;
+      const size_t expected_size_bytes = (entries_start_u64 + num_entries) * sizeof(uint64_t);
+      if (size < expected_size_bytes) {
+        throw std::invalid_argument(std::to_string(expected_size_bytes) + " bytes expected, actual " + std::to_string(size)
+            + (dump_on_error ? (", sketch dump: " + hex_dump(reinterpret_cast<const uint8_t*>(ptr), size)) : ""));
+      }
+      const bool is_ordered = reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_FLAGS_BYTE] & (1 << COMPACT_SKETCH_IS_ORDERED_FLAG);
+      return {false, is_ordered, seed_hash, num_entries, theta, entries};
+  }
+  case 1:  {
+      uint16_t seed_hash = compute_seed_hash(seed);
+      checker<true>::check_sketch_type(reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_TYPE_BYTE], COMPACT_SKETCH_TYPE);
+      const uint32_t num_entries = reinterpret_cast<const uint32_t*>(ptr)[COMPACT_SKETCH_NUM_ENTRIES_U32];
+      uint64_t theta = reinterpret_cast<const uint64_t*>(ptr)[COMPACT_SKETCH_THETA_U64];
+      bool is_empty = (num_entries == 0) && (theta == theta_constants::MAX_THETA);
+      if (is_empty) {
+          return {true, true, seed_hash, 0, theta, nullptr};
+      }
+      const uint64_t* entries = reinterpret_cast<const uint64_t*>(ptr) + COMPACT_SKETCH_ENTRIES_ESTIMATION_U64;
+      const size_t expected_size_bytes = (COMPACT_SKETCH_ENTRIES_ESTIMATION_U64 + num_entries) * sizeof(uint64_t);
+      if (size < expected_size_bytes) {
+        throw std::invalid_argument(std::to_string(expected_size_bytes) + " bytes expected, actual " + std::to_string(size)
+            + (dump_on_error ? (", sketch dump: " + hex_dump(reinterpret_cast<const uint8_t*>(ptr), size)) : ""));
+      }
+      return {false, true, seed_hash, num_entries, theta, entries};
+  }
+  case 2:  {
+      uint8_t preamble_size =  reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_PRE_LONGS_BYTE];
+      checker<true>::check_sketch_type(reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_TYPE_BYTE], COMPACT_SKETCH_TYPE);
+      const uint16_t seed_hash = reinterpret_cast<const uint16_t*>(ptr)[COMPACT_SKETCH_SEED_HASH_U16];
+      checker<true>::check_seed_hash(seed_hash, compute_seed_hash(seed));
+      if (preamble_size == 1) {
+          return {true, true, seed_hash, 0, theta_constants::MAX_THETA, nullptr};
+      } else if (preamble_size == 2) {
+          const uint32_t num_entries = reinterpret_cast<const uint32_t*>(ptr)[COMPACT_SKETCH_NUM_ENTRIES_U32];
+          if (num_entries == 0) {
+              return {true, true, seed_hash, 0, theta_constants::MAX_THETA, nullptr};
+          } else {
+              const size_t expected_size_bytes = (preamble_size + num_entries) << 3;
+              if (size < expected_size_bytes) {
+                  throw std::invalid_argument(std::to_string(expected_size_bytes) + " bytes expected, actual " + std::to_string(size)
+                      + (dump_on_error ? (", sketch dump: " + hex_dump(reinterpret_cast<const uint8_t*>(ptr), size)) : ""));
+              }
+              const uint64_t* entries = reinterpret_cast<const uint64_t*>(ptr) + COMPACT_SKETCH_ENTRIES_EXACT_U64;
+              return {false, true, seed_hash, num_entries, theta_constants::MAX_THETA, entries};
+          }
+      } else if (preamble_size == 3) {
+          const uint32_t num_entries = reinterpret_cast<const uint32_t*>(ptr)[COMPACT_SKETCH_NUM_ENTRIES_U32];
+          uint64_t theta = reinterpret_cast<const uint64_t*>(ptr)[COMPACT_SKETCH_THETA_U64];
+          bool is_empty = (num_entries == 0) && (theta == theta_constants::MAX_THETA);
+          if (is_empty) {
+              return {true, true, seed_hash, 0, theta, nullptr};
+          }
+          const uint64_t* entries = reinterpret_cast<const uint64_t*>(ptr) + COMPACT_SKETCH_ENTRIES_ESTIMATION_U64;
+          const size_t expected_size_bytes = (COMPACT_SKETCH_ENTRIES_ESTIMATION_U64 + num_entries) * sizeof(uint64_t);
+          if (size < expected_size_bytes) {
+            throw std::invalid_argument(std::to_string(expected_size_bytes) + " bytes expected, actual " + std::to_string(size)
+                + (dump_on_error ? (", sketch dump: " + hex_dump(reinterpret_cast<const uint8_t*>(ptr), size)) : ""));
+          }
+          return {false, true, seed_hash, num_entries, theta, entries};
+      } else {
+          throw std::invalid_argument(std::to_string(preamble_size) + " longs of premable, but expected 1, 2, or 3");
+      }
+  }
+  default:
+      // this should always fail since the valid cases are handled above
+      checker<true>::check_serial_version(reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_SERIAL_VERSION_BYTE], COMPACT_SKETCH_SERIAL_VERSION);
+      // this throw is never reached, because check_serial_version will throw an informative exception.
+      // This is only here to avoid a compiler warning about a path without a return value.
+      throw std::invalid_argument("unexpected sketch serialization version");
+  }
+}
+
+template<bool dummy>
+std::string compact_theta_sketch_parser<dummy>::hex_dump(const uint8_t* ptr, size_t size) {
+  std::stringstream s;
+  s << std::hex << std::setfill('0') << std::uppercase;
+  for (size_t i = 0; i < size; ++i) s << std::setw(2) << (ptr[i] & 0xff);
+  return s.str();
+}
+
+} /* namespace datasketches */
+
+#endif

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

@@ -21,14 +21,19 @@
 #define THETA_CONSTANTS_HPP_
 
 #include <climits>
+#include "common_defs.hpp"
 
 namespace datasketches {
 
 namespace theta_constants {
-  enum resize_factor { X1, X2, X4, X8 };
-  static const uint64_t MAX_THETA = LLONG_MAX; // signed max for compatibility with Java
-  static const uint8_t MIN_LG_K = 5;
-  static const uint8_t MAX_LG_K = 26;
+  using resize_factor = datasketches::resize_factor;
+  //enum resize_factor { X1, X2, X4, X8 };
+  const uint64_t MAX_THETA = LLONG_MAX; // signed max for compatibility with Java
+  const uint8_t MIN_LG_K = 5;
+  const uint8_t MAX_LG_K = 26;
+
+  const uint8_t DEFAULT_LG_K = 12;
+  const resize_factor DEFAULT_RESIZE_FACTOR = resize_factor::X8;
 }
 
 } /* namespace datasketches */