datasketches 0.3.2 → 0.4.1

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

@@ -29,6 +29,7 @@
 namespace datasketches {
 
 /**
+ * Bounds on ratios in sampled sets.
  * This class is used to compute the bounds on the estimate of the ratio <i>|B| / |A|</i>, where:
  * <ul>
  * <li><i>|A|</i> is the unknown size of a set <i>A</i> of unique identifiers.</li>

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

@@ -28,6 +28,7 @@
 namespace datasketches {
 
 /**
+ * Bounds on ratios in Theta sketched sets.
  * This is to compute the bounds on the estimate of the ratio <i>B / A</i>, where:
  * <ul>
  * <li><i>A</i> is a Theta Sketch of population <i>PopA</i>.</li>
@@ -50,8 +51,8 @@ class bounds_on_ratios_in_theta_sketched_sets {
 public:
   /**
    * Gets the approximate lower bound for B over A based on a 95% confidence interval
-   * @param sketchA the sketch A
-   * @param sketchB the sketch B
+   * @param sketch_a the sketch A
+   * @param sketch_b the sketch B
    * @return the approximate lower bound for B over A
    */
   template<typename SketchA, typename SketchB>
@@ -72,8 +73,8 @@ public:
 
   /**
    * Gets the approximate upper bound for B over A based on a 95% confidence interval
-   * @param sketchA the sketch A
-   * @param sketchB the sketch B
+   * @param sketch_a the sketch A
+   * @param sketch_b the sketch B
    * @return the approximate upper bound for B over A
    */
   template<typename SketchA, typename SketchB>
@@ -94,8 +95,8 @@ public:
 
   /**
    * Gets the estimate for B over A
-   * @param sketchA the sketch A
-   * @param sketchB the sketch B
+   * @param sketch_a the sketch A
+   * @param sketch_b the sketch B
    * @return the estimate for B over A
    */
   template<typename SketchA, typename SketchB>

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

@@ -25,6 +25,16 @@
 
 namespace datasketches {
 
+// forward declaration
+template<typename A> class theta_a_not_b_alloc;
+
+// alias with default allocator for convenience
+using theta_a_not_b = theta_a_not_b_alloc<std::allocator<uint64_t>>;
+
+/**
+ * Theta A-not-B (set difference).
+ * Computes set difference of Theta sketches.
+ */
 template<typename Allocator = std::allocator<uint64_t>>
 class theta_a_not_b_alloc {
 public:
@@ -33,11 +43,19 @@ public:
   using CompactSketch = compact_theta_sketch_alloc<Allocator>;
   using State = theta_set_difference_base<Entry, ExtractKey, CompactSketch, Allocator>;
 
+  /**
+   * Constructor
+   * @param seed for the hash function that was used to create the sketch
+   * @param allocator to use for allocating and deallocating memory
+   */
   explicit theta_a_not_b_alloc(uint64_t seed = DEFAULT_SEED, const Allocator& allocator = Allocator());
 
   /**
-   * Computes the a-not-b set operation given two sketches.
-   * @return the result of a-not-b
+   * Computes the A-not-B set operation given two sketches.
+   * @param a sketch A
+   * @param b sketch B
+   * @param ordered optional flag to specify if an ordered sketch should be produced
+   * @return the result of A-not-B as a compact sketch
    */
   template<typename FwdSketch, typename Sketch>
   CompactSketch compute(FwdSketch&& a, const Sketch& b, bool ordered = true) const;
@@ -46,9 +64,6 @@ private:
   State state_;
 };
 
-// alias with default allocator for convenience
-using theta_a_not_b = theta_a_not_b_alloc<std::allocator<uint64_t>>;
-
 } /* namespace datasketches */
 
 #include "theta_a_not_b_impl.hpp"

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

@@ -25,15 +25,21 @@
 
 namespace datasketches {
 
+/// Theta constants
 namespace theta_constants {
+  /// hash table resize factor
   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
+  /// default resize factor
+  const resize_factor DEFAULT_RESIZE_FACTOR = resize_factor::X8;
+
+  /// max theta - signed max for compatibility with Java
+  const uint64_t MAX_THETA = LLONG_MAX;
+  /// min log2 of K
   const uint8_t MIN_LG_K = 5;
+  /// max log2 of K
   const uint8_t MAX_LG_K = 26;
-
+  /// default log2 of K
   const uint8_t DEFAULT_LG_K = 12;
-  const resize_factor DEFAULT_RESIZE_FACTOR = resize_factor::X8;
 }
 
 } /* namespace datasketches */

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

@@ -57,7 +57,7 @@ public:
   // consistent way of initializing theta from p
   // avoids multiplication if p == 1 since it might not yield MAX_THETA exactly
   static uint64_t starting_theta_from_p(float p) {
-    if (p < 1) return static_cast<float>(theta_constants::MAX_THETA) * p;
+    if (p < 1) return static_cast<uint64_t>(theta_constants::MAX_THETA * p);
     return theta_constants::MAX_THETA;
   }
 

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

@@ -25,6 +25,16 @@
 
 namespace datasketches {
 
+// forward declaration
+template<typename A> class theta_intersection_alloc;
+
+// alias with default allocator for convenience
+using theta_intersection = theta_intersection_alloc<std::allocator<uint64_t>>;
+
+/**
+ * Theta intersection.
+ * Computes intersection of Theta sketches.
+ */
 template<typename Allocator = std::allocator<uint64_t>>
 class theta_intersection_alloc {
 public:
@@ -33,6 +43,7 @@ public:
   using Sketch = theta_sketch_alloc<Allocator>;
   using CompactSketch = compact_theta_sketch_alloc<Allocator>;
 
+  // there is no payload in Theta sketch entry
   struct nop_policy {
     void operator()(uint64_t internal_entry, uint64_t incoming_entry) const {
       unused(incoming_entry);
@@ -41,7 +52,7 @@ public:
   };
   using State = theta_intersection_base<Entry, ExtractKey, nop_policy, Sketch, CompactSketch, Allocator>;
 
-  /*
+  /**
    * Constructor
    * @param seed for the hash function that was used to create the sketch
    * @param allocator to use for allocating and deallocating memory
@@ -61,7 +72,7 @@ public:
    * Produces a copy of the current state of the intersection.
    * If update() was not called, the state is the infinite "universe",
    * which is considered an undefined state, and throws an exception.
-   * @param ordered optional flag to specify if ordered sketch should be produced
+   * @param ordered optional flag to specify if an ordered sketch should be produced
    * @return the result of the intersection
    */
   CompactSketch get_result(bool ordered = true) const;
@@ -76,9 +87,6 @@ private:
   State state_;
 };
 
-// alias with default allocator for convenience
-using theta_intersection = theta_intersection_alloc<std::allocator<uint64_t>>;
-
 } /* namespace datasketches */
 
 #include "theta_intersection_impl.hpp"

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

@@ -49,8 +49,8 @@ void theta_intersection_base<EN, EK, P, S, CS, A>::update(SS&& sketch) {
   if (!is_valid_) { // first update, copy or move incoming sketch
     is_valid_ = true;
     const uint8_t lg_size = lg_size_from_count(sketch.get_num_retained(), theta_update_sketch_base<EN, EK, A>::REBUILD_THRESHOLD);
-    table_ = hash_table(lg_size, lg_size, resize_factor::X1, 1, table_.theta_, table_.seed_, table_.allocator_, table_.is_empty_);
-    for (auto& entry: sketch) {
+    table_ = hash_table(lg_size, lg_size - 1, resize_factor::X1, 1, table_.theta_, table_.seed_, table_.allocator_, table_.is_empty_);
+    for (auto&& entry: sketch) {
       auto result = table_.find(EK()(entry));
       if (result.second) {
         throw std::invalid_argument("duplicate key, possibly corrupted input sketch");
@@ -64,7 +64,7 @@ void theta_intersection_base<EN, EK, P, S, CS, A>::update(SS&& sketch) {
     matched_entries.reserve(max_matches);
     uint32_t match_count = 0;
     uint32_t count = 0;
-    for (auto& entry: sketch) {
+    for (auto&& entry: sketch) {
       if (EK()(entry) < table_.theta_) {
         auto result = table_.find(EK()(entry));
         if (result.second) {
@@ -88,8 +88,8 @@ void theta_intersection_base<EN, EK, P, S, CS, A>::update(SS&& sketch) {
       if (table_.theta_ == theta_constants::MAX_THETA) table_.is_empty_ = true;
     } else {
       const uint8_t lg_size = lg_size_from_count(match_count, theta_update_sketch_base<EN, EK, A>::REBUILD_THRESHOLD);
-      table_ = hash_table(lg_size, lg_size, resize_factor::X1, 1, table_.theta_, table_.seed_, table_.allocator_, table_.is_empty_);
-      for (uint32_t i = 0; i < match_count; i++) {
+      table_ = hash_table(lg_size, lg_size - 1, resize_factor::X1, 1, table_.theta_, table_.seed_, table_.allocator_, table_.is_empty_);
+      for (uint32_t i = 0; i < match_count; ++i) {
         auto result = table_.find(EK()(matched_entries[i]));
         table_.insert(result.first, std::move(matched_entries[i]));
       }

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

@@ -28,9 +28,9 @@ state_(seed, nop_policy(), allocator)
 {}
 
 template<typename A>
-template<typename SS>
-void theta_intersection_alloc<A>::update(SS&& sketch) {
-  state_.update(std::forward<SS>(sketch));
+template<typename FwdSketch>
+void theta_intersection_alloc<A>::update(FwdSketch&& sketch) {
+  state_.update(std::forward<FwdSketch>(sketch));
 }
 
 template<typename A>

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

@@ -26,10 +26,11 @@
 
 namespace datasketches {
 
+/// Theta Jaccard similarity alias
 template<typename Allocator = std::allocator<uint64_t>>
 using theta_jaccard_similarity_alloc = jaccard_similarity_base<theta_union_alloc<Allocator>, theta_intersection_alloc<Allocator>, trivial_extract_key>;
 
-// alias with default allocator for convenience
+/// Theta Jaccard similarity alias with default allocator
 using theta_jaccard_similarity = theta_jaccard_similarity_alloc<std::allocator<uint64_t>>;
 
 } /* namespace datasketches */

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

@@ -30,6 +30,7 @@
 
 namespace datasketches {
 
+/// Base class for Jaccard similarity
 template<typename Union, typename Intersection, typename ExtractKey>
 class jaccard_similarity_base {
 public:

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

@@ -65,7 +65,7 @@ CS theta_set_difference_base<EN, EK, CS, A>::compute(FwdSketch&& a, const Sketch
       }
 
       // scan A lookup B
-      for (auto& entry: a) {
+      for (auto&& entry: a) {
         const uint64_t hash = EK()(entry);
         if (hash < theta) {
           auto result = table.find(hash);

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

@@ -25,6 +25,22 @@
 
 namespace datasketches {
 
+// forward declarations
+template<typename A> class theta_sketch_alloc;
+template<typename A> class update_theta_sketch_alloc;
+template<typename A> class compact_theta_sketch_alloc;
+template<typename A> class wrapped_compact_theta_sketch_alloc;
+
+/// Theta sketch alias with default allocator
+using theta_sketch = theta_sketch_alloc<std::allocator<uint64_t>>;
+/// Update Theta sketch alias with default allocator
+using update_theta_sketch = update_theta_sketch_alloc<std::allocator<uint64_t>>;
+/// Compact Theta sketch alias with default allocator
+using compact_theta_sketch = compact_theta_sketch_alloc<std::allocator<uint64_t>>;
+/// Wrapped Compact Theta sketch alias with default allocator
+using wrapped_compact_theta_sketch = wrapped_compact_theta_sketch_alloc<std::allocator<uint64_t>>;
+
+/// Abstract base class for Theta sketch
 template<typename Allocator = std::allocator<uint64_t>>
 class base_theta_sketch_alloc {
 public:
@@ -106,6 +122,7 @@ protected:
   virtual void print_items(std::ostringstream& os) const = 0;
 };
 
+/// Base class for the Theta Sketch, a generalization of the Kth Minimum Value (KMV) sketch.
 template<typename Allocator = std::allocator<uint64_t>>
 class theta_sketch_alloc: public base_theta_sketch_alloc<Allocator> {
 public:
@@ -149,6 +166,11 @@ protected:
 // forward declaration
 template<typename A> class compact_theta_sketch_alloc;
 
+/**
+ * Update Theta sketch.
+ * The purpose of this class is to build a Theta sketch from input data via the update() methods.
+ * There is no constructor. Use builder instead.
+ */
 template<typename Allocator = std::allocator<uint64_t>>
 class update_theta_sketch_alloc: public theta_sketch_alloc<Allocator> {
 public:
@@ -163,11 +185,33 @@ public:
   // No constructor here. Use builder instead.
   class builder;
 
-  update_theta_sketch_alloc(const update_theta_sketch_alloc&) = default;
-  update_theta_sketch_alloc(update_theta_sketch_alloc&&) noexcept = default;
+  /**
+   * Copy constructor
+   * @param other sketch to be copied
+   */
+  update_theta_sketch_alloc(const update_theta_sketch_alloc& other) = default;
+
+  /**
+   * Move constructor
+   * @param other sketch to be moved
+   */
+  update_theta_sketch_alloc(update_theta_sketch_alloc&& other) noexcept = default;
+
   virtual ~update_theta_sketch_alloc() = default;
-  update_theta_sketch_alloc& operator=(const update_theta_sketch_alloc&) = default;
-  update_theta_sketch_alloc& operator=(update_theta_sketch_alloc&&) = default;
+
+  /**
+   * Copy assignment
+   * @param other sketch to be copied
+   * @return reference to this sketch
+   */
+  update_theta_sketch_alloc& operator=(const update_theta_sketch_alloc& other) = default;
+
+  /**
+   * Move assignment
+   * @param other sketch to be moved
+   * @return reference to this sketch
+   */
+  update_theta_sketch_alloc& operator=(update_theta_sketch_alloc&& other) = default;
 
   virtual Allocator get_allocator() const;
   virtual bool is_empty() const;
@@ -287,7 +331,7 @@ public:
 
   /**
    * Converts this sketch to a compact sketch (ordered or unordered).
-   * @param ordered optional flag to specify if ordered sketch should be produced
+   * @param ordered optional flag to specify if an ordered sketch should be produced
    * @return compact sketch
    */
   compact_theta_sketch_alloc<Allocator> compact(bool ordered = true) const;
@@ -307,8 +351,10 @@ private:
   virtual void print_specifics(std::ostringstream& os) const;
 };
 
-// compact sketch
-
+/**
+ * Compact Theta sketch.
+ * This is an immutable form of the Theta sketch, the form that can be serialized and deserialized.
+ */
 template<typename Allocator = std::allocator<uint64_t>>
 class compact_theta_sketch_alloc: public theta_sketch_alloc<Allocator> {
 public:
@@ -327,13 +373,42 @@ public:
   // - as a result of a set operation
   // - by deserializing a previously serialized compact sketch
 
+  /**
+   * Copy constructor.
+   * Constructs a compact sketch from any other type of Theta sketch
+   * @param other sketch to be constructed from
+   * @param ordered if true make the resulting sketch ordered
+   */
   template<typename Other>
   compact_theta_sketch_alloc(const Other& other, bool ordered);
-  compact_theta_sketch_alloc(const compact_theta_sketch_alloc&) = default;
-  compact_theta_sketch_alloc(compact_theta_sketch_alloc&&) noexcept = default;
+
+  /**
+   * Copy constructor
+   * @param other sketch to be copied
+   */
+  compact_theta_sketch_alloc(const compact_theta_sketch_alloc& other) = default;
+
+  /**
+   * Move constructor
+   * @param other sketch to be moved
+   */
+  compact_theta_sketch_alloc(compact_theta_sketch_alloc&& other) noexcept = default;
+
   virtual ~compact_theta_sketch_alloc() = default;
-  compact_theta_sketch_alloc& operator=(const compact_theta_sketch_alloc&) = default;
-  compact_theta_sketch_alloc& operator=(compact_theta_sketch_alloc&&) = default;
+
+  /**
+   * Copy assignment
+   * @param other sketch to be copied
+   * @return reference to this sketch
+   */
+  compact_theta_sketch_alloc& operator=(const compact_theta_sketch_alloc& other) = default;
+
+  /**
+   * Move assignment
+   * @param other sketch to be moved
+   * @return reference to this sketch
+   */
+  compact_theta_sketch_alloc& operator=(compact_theta_sketch_alloc&& other) = default;
 
   virtual Allocator get_allocator() const;
   virtual bool is_empty() const;
@@ -385,6 +460,7 @@ public:
    * This method deserializes a sketch from a given stream.
    * @param is input stream
    * @param seed the seed for the hash function that was used to create the sketch
+   * @param allocator instance of an Allocator
    * @return an instance of the sketch
    */
   static compact_theta_sketch_alloc deserialize(std::istream& is,
@@ -395,14 +471,12 @@ public:
    * @param bytes pointer to the array of bytes
    * @param size the size of the array
    * @param seed the seed for the hash function that was used to create the sketch
+   * @param allocator instance of an Allocator
    * @return an instance of the sketch
    */
   static compact_theta_sketch_alloc deserialize(const void* bytes, size_t size,
       uint64_t seed = DEFAULT_SEED, const Allocator& allocator = Allocator());
 
-  // for internal use
-  compact_theta_sketch_alloc(bool is_empty, bool is_ordered, uint16_t seed_hash, uint64_t theta, std::vector<uint64_t, Allocator>&& entries);
-
 private:
   enum flags { IS_BIG_ENDIAN, IS_READ_ONLY, IS_EMPTY, IS_COMPACT, IS_ORDERED };
 
@@ -423,20 +497,33 @@ private:
   static compact_theta_sketch_alloc deserialize_v4(uint8_t preamble_longs, std::istream& is, uint64_t seed, const Allocator& allocator);
 
   virtual void print_specifics(std::ostringstream& os) const;
+
+  template<typename E, typename EK, typename P, typename S, typename CS, typename A> friend class theta_union_base;
+  template<typename E, typename EK, typename P, typename S, typename CS, typename A> friend class theta_intersection_base;
+  template<typename E, typename EK, typename CS, typename A> friend class theta_set_difference_base;
+  compact_theta_sketch_alloc(bool is_empty, bool is_ordered, uint16_t seed_hash, uint64_t theta, std::vector<uint64_t, Allocator>&& entries);
 };
 
+/// Update Theta sketch builder
 template<typename Allocator>
 class update_theta_sketch_alloc<Allocator>::builder: public theta_base_builder<builder, Allocator> {
 public:
+    /**
+     * Constructor
+     * @param allocator
+     */
     builder(const Allocator& allocator = Allocator());
+    /// @return instance of Update Theta sketch
     update_theta_sketch_alloc build() const;
 };
 
-// This is to wrap a buffer containing a serialized compact sketch and use it in a set operation avoiding some cost of deserialization.
-// It does not take the ownership of the buffer.
-
+/**
+ * Wrapped Compact Theta sketch.
+ * This is to wrap a buffer containing a serialized compact sketch and use it in a set operation avoiding some cost of deserialization.
+ * It does not take the ownership of the buffer.
+ */
 template<typename Allocator = std::allocator<uint64_t>>
-class wrapped_compact_theta_sketch_alloc : public base_theta_sketch_alloc<Allocator> {
+class wrapped_compact_theta_sketch_alloc: public base_theta_sketch_alloc<Allocator> {
 public:
   class const_iterator;
 
@@ -447,7 +534,17 @@ public:
   uint32_t get_num_retained() const;
   uint16_t get_seed_hash() const;
 
+  /**
+   * Const iterator over hash values in this sketch.
+   * @return begin iterator
+   */
   const_iterator begin() const;
+
+  /**
+   * Const iterator pointing past the valid range.
+   * Not to be incremented or dereferenced.
+   * @return end iterator
+   */
   const_iterator end() const;
 
   /**
@@ -455,6 +552,7 @@ public:
    * @param bytes pointer to the array of bytes
    * @param size the size of the array
    * @param seed the seed for the hash function that was used to create the sketch
+   * @param dump_on_error if true prints hex dump of the input
    * @return an instance of the sketch
    */
   static const wrapped_compact_theta_sketch_alloc wrap(const void* bytes, size_t size, uint64_t seed = DEFAULT_SEED, bool dump_on_error = false);
@@ -471,15 +569,22 @@ private:
 };
 
 template<typename Allocator>
-class wrapped_compact_theta_sketch_alloc<Allocator>::const_iterator: public std::iterator<std::input_iterator_tag, uint64_t> {
+class wrapped_compact_theta_sketch_alloc<Allocator>::const_iterator {
 public:
+  using iterator_category = std::input_iterator_tag;
+  using value_type = const uint64_t;
+  using difference_type = void;
+  using pointer = value_type*;
+  using reference = uint64_t;
+
   const_iterator(const void* ptr, uint8_t entry_bits, uint32_t num_entries, uint32_t index);
   const_iterator& operator++();
   const_iterator operator++(int);
   bool operator==(const const_iterator& other) const;
   bool operator!=(const const_iterator& other) const;
-  const uint64_t& operator*() const;
-  const uint64_t* operator->() const;
+  reference operator*() const;
+  pointer operator->() const;
+
 private:
   const void* ptr_;
   uint8_t entry_bits_;
@@ -492,12 +597,6 @@ private:
   uint64_t buffer_[8];
 };
 
-// aliases with default allocator for convenience
-using theta_sketch = theta_sketch_alloc<std::allocator<uint64_t>>;
-using update_theta_sketch = update_theta_sketch_alloc<std::allocator<uint64_t>>;
-using compact_theta_sketch = compact_theta_sketch_alloc<std::allocator<uint64_t>>;
-using wrapped_compact_theta_sketch = wrapped_compact_theta_sketch_alloc<std::allocator<uint64_t>>;
-
 } /* namespace datasketches */
 
 #include "theta_sketch_impl.hpp"

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

@@ -357,7 +357,7 @@ void compact_theta_sketch_alloc<A>::serialize(std::ostream& os) const {
   write(os, flags_byte);
   write(os, get_seed_hash());
   if (preamble_longs > 1) {
-    write<uint32_t>(os, entries_.size());
+    write(os, static_cast<uint32_t>(entries_.size()));
     write<uint32_t>(os, 0); // unused
   }
   if (this->is_estimation_mode()) write(os, this->theta_);
@@ -385,7 +385,7 @@ auto compact_theta_sketch_alloc<A>::serialize(unsigned header_size_bytes) const
   *ptr++ = flags_byte;
   ptr += copy_to_mem(get_seed_hash(), ptr);
   if (preamble_longs > 1) {
-    ptr += copy_to_mem<uint32_t>(entries_.size(), ptr);
+    ptr += copy_to_mem(static_cast<uint32_t>(entries_.size()), ptr);
     ptr += sizeof(uint32_t); // unused
   }
   if (this->is_estimation_mode()) ptr += copy_to_mem(theta_, ptr);
@@ -432,7 +432,7 @@ void compact_theta_sketch_alloc<A>::serialize_version_4(std::ostream& os) const
   const uint8_t entry_bits = 64 - compute_min_leading_zeros();
 
   // store num_entries as whole bytes since whole-byte blocks will follow (most probably)
-  const uint8_t num_entries_bytes = whole_bytes_to_hold_bits<uint8_t>(32 - count_leading_zeros_in_u32(entries_.size()));
+  const uint8_t num_entries_bytes = whole_bytes_to_hold_bits<uint8_t>(32 - count_leading_zeros_in_u32(static_cast<uint32_t>(entries_.size())));
 
   write(os, preamble_longs);
   write(os, COMPRESSED_SERIAL_VERSION);
@@ -447,7 +447,7 @@ void compact_theta_sketch_alloc<A>::serialize_version_4(std::ostream& os) const
   write(os, flags_byte);
   write(os, get_seed_hash());
   if (this->is_estimation_mode()) write(os, this->theta_);
-  uint32_t num_entries = entries_.size();
+  uint32_t num_entries = static_cast<uint32_t>(entries_.size());
   for (unsigned i = 0; i < num_entries_bytes; ++i) {
     write<uint8_t>(os, num_entries & 0xff);
     num_entries >>= 8;
@@ -488,7 +488,7 @@ auto compact_theta_sketch_alloc<A>::serialize_version_4(unsigned header_size_byt
   const size_t compressed_bits = entry_bits * entries_.size();
 
   // store num_entries as whole bytes since whole-byte blocks will follow (most probably)
-  const uint8_t num_entries_bytes = whole_bytes_to_hold_bits<uint8_t>(32 - count_leading_zeros_in_u32(entries_.size()));
+  const uint8_t num_entries_bytes = whole_bytes_to_hold_bits<uint8_t>(32 - count_leading_zeros_in_u32(static_cast<uint32_t>(entries_.size())));
 
   const size_t size = header_size_bytes + sizeof(uint64_t) * preamble_longs + num_entries_bytes
       + whole_bytes_to_hold_bits(compressed_bits);
@@ -510,7 +510,7 @@ auto compact_theta_sketch_alloc<A>::serialize_version_4(unsigned header_size_byt
   if (this->is_estimation_mode()) {
     ptr += copy_to_mem(theta_, ptr);
   }
-  uint32_t num_entries = entries_.size();
+  uint32_t num_entries = static_cast<uint32_t>(entries_.size());
   for (unsigned i = 0; i < num_entries_bytes; ++i) {
     *ptr++ = num_entries & 0xff;
     num_entries >>= 8;
@@ -869,13 +869,13 @@ bool wrapped_compact_theta_sketch_alloc<Allocator>::const_iterator::operator==(c
 }
 
 template<typename Allocator>
-const uint64_t& wrapped_compact_theta_sketch_alloc<Allocator>::const_iterator::operator*() const {
+auto wrapped_compact_theta_sketch_alloc<Allocator>::const_iterator::operator*() const -> reference {
   if (entry_bits_ == 64) return *reinterpret_cast<const uint64_t*>(ptr_);
   return buffer_[buf_i_];
 }
 
 template<typename Allocator>
-const uint64_t* wrapped_compact_theta_sketch_alloc<Allocator>::const_iterator::operator->() const {
+auto wrapped_compact_theta_sketch_alloc<Allocator>::const_iterator::operator->() const -> pointer {
   if (entry_bits_ == 64) return reinterpret_cast<const uint64_t*>(ptr_);
   return buffer_ + buf_i_;
 }