datasketches 0.2.3 → 0.2.4

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

@@ -20,8 +20,8 @@
 namespace datasketches {
 
 template<typename A>
-array_of_doubles_union_alloc<A>::array_of_doubles_union_alloc(uint8_t lg_cur_size, uint8_t lg_nom_size, resize_factor rf, uint64_t theta, uint64_t seed, const Policy& policy, const A& allocator):
-Base(lg_cur_size, lg_nom_size, rf, theta, seed, policy, allocator)
+array_of_doubles_union_alloc<A>::array_of_doubles_union_alloc(uint8_t lg_cur_size, uint8_t lg_nom_size, resize_factor rf, float p, uint64_t theta, uint64_t seed, const Policy& policy, const A& allocator):
+Base(lg_cur_size, lg_nom_size, rf, p, theta, seed, policy, allocator)
 {}
 
 template<typename A>
@@ -37,7 +37,7 @@ tuple_base_builder<builder, Policy, A>(policy, allocator) {}
 
 template<typename A>
 array_of_doubles_union_alloc<A> array_of_doubles_union_alloc<A>::builder::build() const {
-  return array_of_doubles_union_alloc<A>(this->starting_lg_size(), this->lg_k_, this->rf_, this->starting_theta(), this->seed_, this->policy_, this->allocator_);
+  return array_of_doubles_union_alloc<A>(this->starting_lg_size(), this->lg_k_, this->rf_, this->p_, this->starting_theta(), this->seed_, this->policy_, this->allocator_);
 }
 
 } /* namespace datasketches */

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

@@ -153,8 +153,7 @@ public:
   virtual const_iterator end() const = 0;
 
 protected:
-  using ostrstream = std::basic_ostringstream<char, std::char_traits<char>, AllocChar<Allocator>>;
-  virtual void print_specifics(ostrstream& os) const = 0;
+  virtual void print_specifics(std::ostringstream& os) const = 0;
 
   static uint16_t get_seed_hash(uint64_t seed);
 
@@ -325,6 +324,11 @@ public:
    */
   void trim();
 
+  /**
+   * Reset the sketch to the initial empty state
+   */
+  void reset();
+
   /**
    * Converts this sketch to a compact sketch (ordered or unordered).
    * @param ordered optional flag to specify if ordered sketch should be produced
@@ -342,10 +346,9 @@ protected:
   tuple_map map_;
 
   // 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);
+  update_tuple_sketch(uint8_t lg_cur_size, uint8_t lg_nom_size, resize_factor rf, float p, uint64_t theta, uint64_t seed, const Policy& policy, const Allocator& allocator);
 
-  using ostrstream = typename Base::ostrstream;
-  virtual void print_specifics(ostrstream& os) const;
+  virtual void print_specifics(std::ostringstream& os) const;
 };
 
 // compact sketch
@@ -367,9 +370,11 @@ public:
   using vector_bytes = std::vector<uint8_t, AllocBytes>;
   using comparator = compare_by_key<ExtractKey>;
 
-  static const uint8_t SERIAL_VERSION = 1;
+  static const uint8_t SERIAL_VERSION_LEGACY = 1;
+  static const uint8_t SERIAL_VERSION = 3;
   static const uint8_t SKETCH_FAMILY = 9;
-  static const uint8_t SKETCH_TYPE = 5;
+  static const uint8_t SKETCH_TYPE = 1;
+  static const uint8_t SKETCH_TYPE_LEGACY = 5;
   enum flags { IS_BIG_ENDIAN, IS_READ_ONLY, IS_EMPTY, IS_COMPACT, IS_ORDERED };
 
   // Instances of this type can be obtained:
@@ -473,8 +478,7 @@ protected:
     bool destroy_;
   };
 
-  using ostrstream = typename Base::ostrstream;
-  virtual void print_specifics(ostrstream& os) const;
+  virtual void print_specifics(std::ostringstream& os) const;
 
 };
 

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

@@ -53,7 +53,9 @@ 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 {
-  ostrstream 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 << "### Tuple sketch summary:" << std::endl;
   os << "   num retained entries : " << get_num_retained() << std::endl;
   os << "   seed hash            : " << get_seed_hash() << std::endl;
@@ -74,15 +76,15 @@ string<A> tuple_sketch<S, A>::to_string(bool detail) const {
     }
     os << "### End retained entries" << std::endl;
   }
-  return os.str();
+  return string<A>(os.str().c_str(), get_allocator());
 }
 
 // update sketch
 
 template<typename S, typename U, typename P, typename A>
-update_tuple_sketch<S, U, P, A>::update_tuple_sketch(uint8_t lg_cur_size, uint8_t lg_nom_size, resize_factor rf, uint64_t theta, uint64_t seed, const P& policy, const A& allocator):
+update_tuple_sketch<S, U, P, A>::update_tuple_sketch(uint8_t lg_cur_size, uint8_t lg_nom_size, resize_factor rf, float p, uint64_t theta, uint64_t seed, const P& policy, const A& allocator):
 policy_(policy),
-map_(lg_cur_size, lg_nom_size, rf, theta, seed, allocator)
+map_(lg_cur_size, lg_nom_size, rf, p, theta, seed, allocator)
 {}
 
 template<typename S, typename U, typename P, typename A>
@@ -97,12 +99,12 @@ bool update_tuple_sketch<S, U, P, A>::is_empty() const {
 
 template<typename S, typename U, typename P, typename A>
 bool update_tuple_sketch<S, U, P, A>::is_ordered() const {
-  return false;
+  return map_.num_entries_ > 1 ? false : true;;
 }
 
 template<typename S, typename U, typename P, typename A>
 uint64_t update_tuple_sketch<S, U, P, A>::get_theta64() const {
-  return map_.theta_;
+  return is_empty() ? theta_constants::MAX_THETA : map_.theta_;
 }
 
 template<typename S, typename U, typename P, typename A>
@@ -212,6 +214,11 @@ void update_tuple_sketch<S, U, P, A>::trim() {
   map_.trim();
 }
 
+template<typename S, typename U, typename P, typename A>
+void update_tuple_sketch<S, U, P, A>::reset() {
+  map_.reset();
+}
+
 template<typename S, typename U, typename P, typename A>
 auto update_tuple_sketch<S, U, P, A>::begin() -> iterator {
   return iterator(map_.entries_, 1 << map_.lg_cur_size_, 0);
@@ -238,7 +245,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(ostrstream& os) const {
+void update_tuple_sketch<S, U, P, A>::print_specifics(std::ostringstream& 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;
@@ -250,7 +257,7 @@ template<typename S, typename A>
 compact_tuple_sketch<S, A>::compact_tuple_sketch(bool is_empty, bool is_ordered, uint16_t seed_hash, uint64_t theta,
     std::vector<Entry, AllocEntry>&& entries):
 is_empty_(is_empty),
-is_ordered_(is_ordered),
+is_ordered_(is_ordered || (entries.size() <= 1ULL)),
 seed_hash_(seed_hash),
 theta_(theta),
 entries_(std::move(entries))
@@ -437,9 +444,15 @@ compact_tuple_sketch<S, A> compact_tuple_sketch<S, A>::deserialize(std::istream&
   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);
+  if (serial_version != SERIAL_VERSION && serial_version != SERIAL_VERSION_LEGACY) {
+    throw std::invalid_argument("serial version mismatch: expected " + std::to_string(SERIAL_VERSION) + " or "
+        + std::to_string(SERIAL_VERSION_LEGACY) + ", actual " + std::to_string(serial_version));
+  }
   checker<true>::check_sketch_family(family, SKETCH_FAMILY);
-  checker<true>::check_sketch_type(type, SKETCH_TYPE);
+  if (type != SKETCH_TYPE && type != SKETCH_TYPE_LEGACY) {
+    throw std::invalid_argument("sketch type mismatch: expected " + std::to_string(SKETCH_TYPE) + " or "
+        + std::to_string(SKETCH_TYPE_LEGACY) + ", actual " + std::to_string(type));
+  }
   const bool is_empty = flags_byte & (1 << flags::IS_EMPTY);
   if (!is_empty) checker<true>::check_seed_hash(seed_hash, compute_seed_hash(seed));
 
@@ -492,9 +505,15 @@ compact_tuple_sketch<S, A> compact_tuple_sketch<S, A>::deserialize(const void* b
   ptr += copy_from_mem(ptr, flags_byte);
   uint16_t seed_hash;
   ptr += copy_from_mem(ptr, seed_hash);
-  checker<true>::check_serial_version(serial_version, SERIAL_VERSION);
+  if (serial_version != SERIAL_VERSION && serial_version != SERIAL_VERSION_LEGACY) {
+    throw std::invalid_argument("serial version mismatch: expected " + std::to_string(SERIAL_VERSION) + " or "
+        + std::to_string(SERIAL_VERSION_LEGACY) + ", actual " + std::to_string(serial_version));
+  }
   checker<true>::check_sketch_family(family, SKETCH_FAMILY);
-  checker<true>::check_sketch_type(type, SKETCH_TYPE);
+  if (type != SKETCH_TYPE && type != SKETCH_TYPE_LEGACY) {
+    throw std::invalid_argument("sketch type mismatch: expected " + std::to_string(SKETCH_TYPE) + " or "
+        + std::to_string(SKETCH_TYPE_LEGACY) + ", actual " + std::to_string(type));
+  }
   const bool is_empty = flags_byte & (1 << flags::IS_EMPTY);
   if (!is_empty) checker<true>::check_seed_hash(seed_hash, compute_seed_hash(seed));
 
@@ -554,7 +573,7 @@ auto compact_tuple_sketch<S, A>::end() const -> const_iterator {
 }
 
 template<typename S, typename A>
-void compact_tuple_sketch<S, A>::print_specifics(ostrstream&) const {}
+void compact_tuple_sketch<S, A>::print_specifics(std::ostringstream&) const {}
 
 // builder
 
@@ -568,7 +587,7 @@ tuple_base_builder<builder, P, A>(policy, allocator) {}
 
 template<typename S, typename U, typename P, typename A>
 auto update_tuple_sketch<S, U, P, A>::builder::build() const -> update_tuple_sketch {
-  return update_tuple_sketch(this->starting_lg_size(), this->lg_k_, this->rf_, this->starting_theta(), this->seed_, this->policy_, this->allocator_);
+  return update_tuple_sketch(this->starting_lg_size(), this->lg_k_, this->rf_, this->p_, this->starting_theta(), this->seed_, this->policy_, this->allocator_);
 }
 
 } /* namespace datasketches */

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

@@ -80,11 +80,16 @@ public:
    */
   CompactSketch get_result(bool ordered = true) const;
 
+  /**
+   * Reset the union to the initial empty state
+   */
+  void reset();
+
 protected:
   State state_;
 
   // for builder
-  tuple_union(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);
+  tuple_union(uint8_t lg_cur_size, uint8_t lg_nom_size, resize_factor rf, float p, uint64_t theta, uint64_t seed, const Policy& policy, const Allocator& allocator);
 };
 
 template<typename S, typename P, typename A>

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

@@ -20,8 +20,8 @@
 namespace datasketches {
 
 template<typename S, typename P, typename A>
-tuple_union<S, P, A>::tuple_union(uint8_t lg_cur_size, uint8_t lg_nom_size, resize_factor rf, uint64_t theta, uint64_t seed, const P& policy, const A& allocator):
-state_(lg_cur_size, lg_nom_size, rf, theta, seed, internal_policy(policy), allocator)
+tuple_union<S, P, A>::tuple_union(uint8_t lg_cur_size, uint8_t lg_nom_size, resize_factor rf, float p, uint64_t theta, uint64_t seed, const P& policy, const A& allocator):
+state_(lg_cur_size, lg_nom_size, rf, p, theta, seed, internal_policy(policy), allocator)
 {}
 
 template<typename S, typename P, typename A>
@@ -35,13 +35,18 @@ auto tuple_union<S, P, A>::get_result(bool ordered) const -> CompactSketch {
   return state_.get_result(ordered);
 }
 
+template<typename S, typename P, typename A>
+void tuple_union<S, P, A>::reset() {
+  return state_.reset();
+}
+
 template<typename S, typename P, typename A>
 tuple_union<S, P, A>::builder::builder(const P& policy, const A& allocator):
 tuple_base_builder<builder, P, A>(policy, allocator) {}
 
 template<typename S, typename P, typename A>
 auto tuple_union<S, P, A>::builder::build() const -> tuple_union {
-  return tuple_union(this->starting_lg_size(), this->lg_k_, this->rf_, this->starting_theta(), this->seed_, this->policy_, this->allocator_);
+  return tuple_union(this->starting_lg_size(), this->lg_k_, this->rf_, this->p_, this->starting_theta(), this->seed_, this->policy_, this->allocator_);
 }
 
 } /* namespace datasketches */

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

@@ -36,6 +36,17 @@ const std::string inputPath = TEST_BINARY_INPUT_PATH;
 const std::string inputPath = "test/";
 #endif
 
+TEST_CASE("aod sketch: reset", "[tuple_sketch]") {
+  auto update_sketch = update_array_of_doubles_sketch::builder().build();
+  std::vector<double> a = {1};
+  update_sketch.update(1, a);
+  REQUIRE(!update_sketch.is_empty());
+  REQUIRE(update_sketch.get_num_retained() == 1);
+  update_sketch.reset();
+  REQUIRE(update_sketch.is_empty());
+  REQUIRE(update_sketch.get_num_retained() == 0);
+}
+
 TEST_CASE("aod sketch: serialization compatibility with java - empty", "[tuple_sketch]") {
   auto update_sketch = update_array_of_doubles_sketch::builder().build();
   REQUIRE(update_sketch.is_empty());
@@ -263,6 +274,11 @@ TEST_CASE("aod union: half overlap", "[tuple_sketch]") {
   u.update(update_sketch2);
   auto result = u.get_result();
   REQUIRE(result.get_estimate() == Approx(1500).margin(0.01));
+
+  u.reset();
+  result = u.get_result();
+  REQUIRE(result.is_empty());
+  REQUIRE(result.get_num_retained() == 0);
 }
 
 TEST_CASE("aod intersection: half overlap", "[tuple_sketch]") {

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

@@ -34,7 +34,6 @@ std::ostream& operator<<(std::ostream& os, const three_doubles& tuple) {
 
 #include <catch.hpp>
 #include <tuple_sketch.hpp>
-//#include <test_type.hpp>
 
 namespace datasketches {
 
@@ -43,9 +42,11 @@ TEST_CASE("tuple sketch float: builder", "[tuple_sketch]") {
   builder.set_lg_k(10).set_p(0.5f).set_resize_factor(theta_constants::resize_factor::X2).set_seed(123);
   auto sketch = builder.build();
   REQUIRE(sketch.get_lg_k() == 10);
-  REQUIRE(sketch.get_theta() == 0.5);
+  REQUIRE(sketch.get_theta() == 1.0); // empty sketch should have theta 1.0
   REQUIRE(sketch.get_rf() == theta_constants::resize_factor::X2);
   REQUIRE(sketch.get_seed_hash() == compute_seed_hash(123));
+  sketch.update(1, 0);
+  REQUIRE(sketch.get_theta() == 0.5); // theta = p
 }
 
 TEST_CASE("tuple sketch float: empty", "[tuple_sketch]") {
@@ -58,7 +59,7 @@ TEST_CASE("tuple sketch float: empty", "[tuple_sketch]") {
   REQUIRE(update_sketch.get_upper_bound(1) == 0);
   REQUIRE(update_sketch.get_theta() == 1);
   REQUIRE(update_sketch.get_num_retained() == 0);
-  REQUIRE(!update_sketch.is_ordered());
+  REQUIRE(update_sketch.is_ordered());
 
   auto compact_sketch = update_sketch.compact();
   std::cout << "sizeof(compact_tuple_sketch<float>)=" << sizeof(compact_sketch) << std::endl;
@@ -70,6 +71,33 @@ TEST_CASE("tuple sketch float: empty", "[tuple_sketch]") {
   REQUIRE(compact_sketch.get_theta() == 1);
   REQUIRE(compact_sketch.get_num_retained() == 0);
   REQUIRE(compact_sketch.is_ordered());
+
+  // empty is forced to be ordered
+  REQUIRE(update_sketch.compact(false).is_ordered());
+}
+
+TEST_CASE("tuple sketch: single item", "[theta_sketch]") {
+  auto update_sketch = update_tuple_sketch<float>::builder().build();
+  update_sketch.update(1, 1.0f);
+  REQUIRE_FALSE(update_sketch.is_empty());
+  REQUIRE_FALSE(update_sketch.is_estimation_mode());
+  REQUIRE(update_sketch.get_theta() == 1.0);
+  REQUIRE(update_sketch.get_estimate() == 1.0);
+  REQUIRE(update_sketch.get_lower_bound(1) == 1.0);
+  REQUIRE(update_sketch.get_upper_bound(1) == 1.0);
+  REQUIRE(update_sketch.is_ordered()); // one item is ordered
+
+  auto compact_sketch = update_sketch.compact();
+  REQUIRE_FALSE(compact_sketch.is_empty());
+  REQUIRE_FALSE(compact_sketch.is_estimation_mode());
+  REQUIRE(compact_sketch.get_theta() == 1.0);
+  REQUIRE(compact_sketch.get_estimate() == 1.0);
+  REQUIRE(compact_sketch.get_lower_bound(1) == 1.0);
+  REQUIRE(compact_sketch.get_upper_bound(1) == 1.0);
+  REQUIRE(compact_sketch.is_ordered());
+
+  // single item is forced to be ordered
+  REQUIRE(update_sketch.compact(false).is_ordered());
 }
 
 TEST_CASE("tuple sketch float: exact mode", "[tuple_sketch]") {
@@ -78,14 +106,14 @@ TEST_CASE("tuple sketch float: exact mode", "[tuple_sketch]") {
   update_sketch.update(2, 2.0f);
   update_sketch.update(1, 1.0f);
 //  std::cout << update_sketch.to_string(true);
-  REQUIRE(!update_sketch.is_empty());
-  REQUIRE(!update_sketch.is_estimation_mode());
+  REQUIRE_FALSE(update_sketch.is_empty());
+  REQUIRE_FALSE(update_sketch.is_estimation_mode());
   REQUIRE(update_sketch.get_estimate() == 2);
   REQUIRE(update_sketch.get_lower_bound(1) == 2);
   REQUIRE(update_sketch.get_upper_bound(1) == 2);
   REQUIRE(update_sketch.get_theta() == 1);
   REQUIRE(update_sketch.get_num_retained() == 2);
-  REQUIRE(!update_sketch.is_ordered());
+  REQUIRE_FALSE(update_sketch.is_ordered());
   int count = 0;
   for (const auto& entry: update_sketch) {
     REQUIRE(entry.second == 2);
@@ -95,8 +123,8 @@ TEST_CASE("tuple sketch float: exact mode", "[tuple_sketch]") {
 
   auto compact_sketch = update_sketch.compact();
 //  std::cout << compact_sketch.to_string(true);
-  REQUIRE(!compact_sketch.is_empty());
-  REQUIRE(!compact_sketch.is_estimation_mode());
+  REQUIRE_FALSE(compact_sketch.is_empty());
+  REQUIRE_FALSE(compact_sketch.is_estimation_mode());
   REQUIRE(compact_sketch.get_estimate() == 2);
   REQUIRE(compact_sketch.get_lower_bound(1) == 2);
   REQUIRE(compact_sketch.get_upper_bound(1) == 2);
@@ -151,6 +179,16 @@ TEST_CASE("tuple sketch float: exact mode", "[tuple_sketch]") {
       ++it;
     }
   }
+
+  update_sketch.reset();
+  REQUIRE(update_sketch.is_empty());
+  REQUIRE_FALSE(update_sketch.is_estimation_mode());
+  REQUIRE(update_sketch.get_estimate() == 0);
+  REQUIRE(update_sketch.get_lower_bound(1) == 0);
+  REQUIRE(update_sketch.get_upper_bound(1) == 0);
+  REQUIRE(update_sketch.get_theta() == 1);
+  REQUIRE(update_sketch.get_num_retained() == 0);
+  REQUIRE(update_sketch.is_ordered());
 }
 
 template<typename T>

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

@@ -81,6 +81,13 @@ TEST_CASE("tuple_union float: simple case", "[tuple union]") {
   u.update(update_sketch2);
   auto result = u.get_result();
   REQUIRE(result.get_num_retained() == 3);
+
+  u.reset();
+  result = u.get_result();
+  REQUIRE(result.is_empty());
+  REQUIRE(result.get_num_retained() == 0);
+  REQUIRE(!result.is_estimation_mode());
+  REQUIRE(result.get_estimate() == 0);
 }
 
 TEST_CASE("tuple_union float: exact mode half overlap", "[tuple union]") {

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: datasketches
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
 platform: ruby
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-09-29 00:00:00.000000000 Z
+date: 2021-12-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rice
@@ -51,6 +51,7 @@ files:
 - vendor/datasketches-cpp/MANIFEST.in
 - vendor/datasketches-cpp/NOTICE
 - vendor/datasketches-cpp/README.md
+- vendor/datasketches-cpp/cmake/DataSketchesConfig.cmake.in
 - vendor/datasketches-cpp/common/CMakeLists.txt
 - vendor/datasketches-cpp/common/include/MurmurHash3.h
 - vendor/datasketches-cpp/common/include/binomial_bounds.hpp
@@ -256,14 +257,18 @@ files:
 - vendor/datasketches-cpp/theta/test/CMakeLists.txt
 - vendor/datasketches-cpp/theta/test/theta_a_not_b_test.cpp
 - vendor/datasketches-cpp/theta/test/theta_compact_empty_from_java.sk
+- vendor/datasketches-cpp/theta/test/theta_compact_empty_from_java_v1.sk
+- vendor/datasketches-cpp/theta/test/theta_compact_empty_from_java_v2.sk
 - vendor/datasketches-cpp/theta/test/theta_compact_estimation_from_java.sk
+- vendor/datasketches-cpp/theta/test/theta_compact_estimation_from_java_v1.sk
+- vendor/datasketches-cpp/theta/test/theta_compact_estimation_from_java_v2.sk
+- vendor/datasketches-cpp/theta/test/theta_compact_exact_from_java.sk
 - vendor/datasketches-cpp/theta/test/theta_compact_single_item_from_java.sk
 - vendor/datasketches-cpp/theta/test/theta_intersection_test.cpp
 - vendor/datasketches-cpp/theta/test/theta_jaccard_similarity_test.cpp
+- vendor/datasketches-cpp/theta/test/theta_setop_test.cpp
 - vendor/datasketches-cpp/theta/test/theta_sketch_test.cpp
 - vendor/datasketches-cpp/theta/test/theta_union_test.cpp
-- vendor/datasketches-cpp/theta/test/theta_update_empty_from_java.sk
-- vendor/datasketches-cpp/theta/test/theta_update_estimation_from_java.sk
 - vendor/datasketches-cpp/tuple/CMakeLists.txt
 - vendor/datasketches-cpp/tuple/include/array_of_doubles_a_not_b.hpp
 - vendor/datasketches-cpp/tuple/include/array_of_doubles_a_not_b_impl.hpp
@@ -295,7 +300,7 @@ files:
 - vendor/datasketches-cpp/tuple/test/tuple_sketch_allocation_test.cpp
 - vendor/datasketches-cpp/tuple/test/tuple_sketch_test.cpp
 - vendor/datasketches-cpp/tuple/test/tuple_union_test.cpp
-homepage: https://github.com/ankane/datasketches
+homepage: https://github.com/ankane/datasketches-ruby
 licenses:
 - Apache-2.0
 metadata: {}
@@ -314,7 +319,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.3.3
 signing_key:
 specification_version: 4
 summary: Sketch data structures for Ruby