datasketches 0.3.2 → 0.4.0

data/vendor/datasketches-cpp/tuple/include/{array_of_doubles_sketch_impl.hpp → array_tuple_sketch_impl.hpp}

@@ -19,56 +19,55 @@
 
 namespace datasketches {
 
-template<typename A>
-update_array_of_doubles_sketch_alloc<A>::update_array_of_doubles_sketch_alloc(uint8_t lg_cur_size, uint8_t lg_nom_size, resize_factor rf,
-    float p, uint64_t theta, uint64_t seed, const array_of_doubles_update_policy<A>& policy, const A& allocator):
+template<typename Array, typename Policy, typename Allocator>
+update_array_tuple_sketch<Array, Policy, Allocator>::update_array_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):
 Base(lg_cur_size, lg_nom_size, rf, p, theta, seed, policy, allocator) {}
 
-
-template<typename A>
-uint8_t update_array_of_doubles_sketch_alloc<A>::get_num_values() const {
+template<typename Array, typename Policy, typename Allocator>
+uint8_t update_array_tuple_sketch<Array, Policy, Allocator>::get_num_values() const {
   return this->policy_.get_num_values();
 }
 
-template<typename A>
-compact_array_of_doubles_sketch_alloc<A> update_array_of_doubles_sketch_alloc<A>::compact(bool ordered) const {
-  return compact_array_of_doubles_sketch_alloc<A>(*this, ordered);
+template<typename Array, typename Policy, typename Allocator>
+compact_array_tuple_sketch<Array, Allocator> update_array_tuple_sketch<Array, Policy, Allocator>::compact(bool ordered) const {
+  return compact_array_tuple_sketch<Array, Allocator>(*this, ordered);
 }
 
 // builder
 
-template<typename A>
-update_array_of_doubles_sketch_alloc<A>::builder::builder(const array_of_doubles_update_policy<A>& policy, const A& allocator):
-tuple_base_builder<builder, array_of_doubles_update_policy<A>, A>(policy, allocator) {}
+template<typename Array, typename Policy, typename Allocator>
+update_array_tuple_sketch<Array, Policy, Allocator>::builder::builder(const Policy& policy, const Allocator& allocator):
+tuple_base_builder<builder, Policy, Allocator>(policy, allocator) {}
 
-template<typename A>
-update_array_of_doubles_sketch_alloc<A> update_array_of_doubles_sketch_alloc<A>::builder::build() const {
-  return update_array_of_doubles_sketch_alloc<A>(this->starting_lg_size(), this->lg_k_, this->rf_, this->p_, this->starting_theta(), this->seed_, this->policy_, this->allocator_);
+template<typename Array, typename Policy, typename Allocator>
+auto update_array_tuple_sketch<Array, Policy, Allocator>::builder::build() const -> update_array_tuple_sketch {
+  return update_array_tuple_sketch(this->starting_lg_size(), this->lg_k_, this->rf_, this->p_, this->starting_theta(), this->seed_, this->policy_, this->allocator_);
 }
 
 // compact sketch
 
-template<typename A>
+template<typename Array, typename Allocator>
 template<typename S>
-compact_array_of_doubles_sketch_alloc<A>::compact_array_of_doubles_sketch_alloc(const S& other, bool ordered):
+compact_array_tuple_sketch<Array, Allocator>::compact_array_tuple_sketch(const S& other, bool ordered):
 Base(other, ordered), num_values_(other.get_num_values()) {}
 
-template<typename A>
-compact_array_of_doubles_sketch_alloc<A>::compact_array_of_doubles_sketch_alloc(bool is_empty, bool is_ordered,
+template<typename Array, typename Allocator>
+compact_array_tuple_sketch<Array, Allocator>::compact_array_tuple_sketch(bool is_empty, bool is_ordered,
     uint16_t seed_hash, uint64_t theta, std::vector<Entry, AllocEntry>&& entries, uint8_t num_values):
 Base(is_empty, is_ordered, seed_hash, theta, std::move(entries)), num_values_(num_values) {}
 
-template<typename A>
-compact_array_of_doubles_sketch_alloc<A>::compact_array_of_doubles_sketch_alloc(uint8_t num_values, Base&& base):
+template<typename Array, typename Allocator>
+compact_array_tuple_sketch<Array, Allocator>::compact_array_tuple_sketch(uint8_t num_values, Base&& base):
 Base(std::move(base)), num_values_(num_values) {}
 
-template<typename A>
-uint8_t compact_array_of_doubles_sketch_alloc<A>::get_num_values() const {
+template<typename Array, typename Allocator>
+uint8_t compact_array_tuple_sketch<Array, Allocator>::get_num_values() const {
   return num_values_;
 }
 
-template<typename A>
-void compact_array_of_doubles_sketch_alloc<A>::serialize(std::ostream& os) const {
+template<typename Array, typename Allocator>
+void compact_array_tuple_sketch<Array, Allocator>::serialize(std::ostream& os) const {
   const uint8_t preamble_longs = 1;
   write(os, preamble_longs);
   const uint8_t serial_version = SERIAL_VERSION;
@@ -96,17 +95,17 @@ void compact_array_of_doubles_sketch_alloc<A>::serialize(std::ostream& os) const
       write(os, it.first);
     }
     for (const auto& it: this->entries_) {
-      write(os, it.second.data(), it.second.size() * sizeof(double));
+      write(os, it.second.data(), it.second.size() * sizeof(typename Array::value_type));
     }
   }
 }
 
-template<typename A>
-auto compact_array_of_doubles_sketch_alloc<A>::serialize(unsigned header_size_bytes) const -> vector_bytes {
+template<typename Array, typename Allocator>
+auto compact_array_tuple_sketch<Array, Allocator>::serialize(unsigned header_size_bytes) const -> vector_bytes {
   const uint8_t preamble_longs = 1;
   const size_t size = header_size_bytes + 16 // preamble and theta
       + (this->entries_.size() > 0 ? 8 : 0)
-      + (sizeof(uint64_t) + sizeof(double) * num_values_) * this->entries_.size();
+      + (sizeof(uint64_t) + sizeof(typename Array::value_type) * num_values_) * this->entries_.size();
   vector_bytes bytes(size, 0, this->entries_.get_allocator());
   uint8_t* ptr = bytes.data() + header_size_bytes;
 
@@ -135,14 +134,14 @@ auto compact_array_of_doubles_sketch_alloc<A>::serialize(unsigned header_size_by
       ptr += copy_to_mem(it.first, ptr);
     }
     for (const auto& it: this->entries_) {
-      ptr += copy_to_mem(it.second.data(), ptr, it.second.size() * sizeof(double));
+      ptr += copy_to_mem(it.second.data(), ptr, it.second.size() * sizeof(typename Array::value_type));
     }
   }
   return bytes;
 }
 
-template<typename A>
-compact_array_of_doubles_sketch_alloc<A> compact_array_of_doubles_sketch_alloc<A>::deserialize(std::istream& is, uint64_t seed, const A& allocator) {
+template<typename Array, typename Allocator>
+compact_array_tuple_sketch<Array, Allocator> compact_array_tuple_sketch<Array, Allocator>::deserialize(std::istream& is, uint64_t seed, const Allocator& allocator) {
   read<uint8_t>(is); // unused
   const auto serial_version = read<uint8_t>(is);
   const auto family = read<uint8_t>(is);
@@ -165,19 +164,19 @@ compact_array_of_doubles_sketch_alloc<A> compact_array_of_doubles_sketch_alloc<A
     std::vector<uint64_t, AllocU64> keys(num_entries, 0, allocator);
     read(is, keys.data(), num_entries * sizeof(uint64_t));
     for (size_t i = 0; i < num_entries; ++i) {
-      aod<A> summary(num_values, allocator);
-      read(is, summary.data(), num_values * sizeof(double));
+      Array summary(num_values, 0, allocator);
+      read(is, summary.data(), num_values * sizeof(typename Array::value_type));
       entries.push_back(Entry(keys[i], std::move(summary)));
     }
   }
   if (!is.good()) throw std::runtime_error("error reading from std::istream");
   const bool is_empty = flags_byte & (1 << flags::IS_EMPTY);
   const bool is_ordered = flags_byte & (1 << flags::IS_ORDERED);
-  return compact_array_of_doubles_sketch_alloc(is_empty, is_ordered, seed_hash, theta, std::move(entries), num_values);
+  return compact_array_tuple_sketch<Array, Allocator>(is_empty, is_ordered, seed_hash, theta, std::move(entries), num_values);
 }
 
-template<typename A>
-compact_array_of_doubles_sketch_alloc<A> compact_array_of_doubles_sketch_alloc<A>::deserialize(const void* bytes, size_t size, uint64_t seed, const A& allocator) {
+template<typename Array, typename Allocator>
+compact_array_tuple_sketch<Array, Allocator> compact_array_tuple_sketch<Array, Allocator>::deserialize(const void* bytes, size_t size, uint64_t seed, const Allocator& allocator) {
   ensure_minimum_memory(size, 16);
   const char* ptr = static_cast<const char*>(bytes);
   ptr += sizeof(uint8_t); // unused
@@ -207,19 +206,19 @@ compact_array_of_doubles_sketch_alloc<A> compact_array_of_doubles_sketch_alloc<A
     uint32_t num_entries;
     ptr += copy_from_mem(ptr, num_entries);
     ptr += sizeof(uint32_t); // unused
-    ensure_minimum_memory(size, 24 + (sizeof(uint64_t) + sizeof(double) * num_values) * num_entries);
+    ensure_minimum_memory(size, 24 + (sizeof(uint64_t) + sizeof(typename Array::value_type) * num_values) * num_entries);
     entries.reserve(num_entries);
     std::vector<uint64_t, AllocU64> keys(num_entries, 0, allocator);
     ptr += copy_from_mem(ptr, keys.data(), sizeof(uint64_t) * num_entries);
     for (size_t i = 0; i < num_entries; ++i) {
-      aod<A> summary(num_values, allocator);
-      ptr += copy_from_mem(ptr, summary.data(), num_values * sizeof(double));
+      Array summary(num_values, 0, allocator);
+      ptr += copy_from_mem(ptr, summary.data(), num_values * sizeof(typename Array::value_type));
       entries.push_back(Entry(keys[i], std::move(summary)));
     }
   }
   const bool is_empty = flags_byte & (1 << flags::IS_EMPTY);
   const bool is_ordered = flags_byte & (1 << flags::IS_ORDERED);
-  return compact_array_of_doubles_sketch_alloc(is_empty, is_ordered, seed_hash, theta, std::move(entries), num_values);
+  return compact_array_tuple_sketch<Array, Allocator>(is_empty, is_ordered, seed_hash, theta, std::move(entries), num_values);
 }
 
 } /* namespace datasketches */

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

@@ -0,0 +1,81 @@
+/*
+ * 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 ARRAY_TUPLE_UNION_HPP_
+#define ARRAY_TUPLE_UNION_HPP_
+
+#include <vector>
+#include <memory>
+#include "array_tuple_sketch.hpp"
+
+#include "tuple_union.hpp"
+
+namespace datasketches {
+
+/// default array tuple union policy
+template<typename Array>
+struct default_array_tuple_union_policy {
+  default_array_tuple_union_policy(uint8_t num_values = 1): num_values_(num_values) {}
+
+  void operator()(Array& array, const Array& other) const {
+    for (uint8_t i = 0; i < num_values_; ++i) {
+      array[i] += other[i];
+    }
+  }
+  uint8_t get_num_values() const {
+    return num_values_;
+  }
+private:
+  uint8_t num_values_;
+};
+
+/// array tuple union
+template<
+  typename Array,
+  typename Policy = default_array_tuple_union_policy<Array>,
+  typename Allocator = typename Array::allocator_type
+>
+class array_tuple_union: public tuple_union<Array, Policy, Allocator> {
+public:
+  using value_type = typename Array::value_type;
+  using Base = tuple_union<Array, Policy, Allocator>;
+  using CompactSketch = compact_array_tuple_sketch<Array, Allocator>;
+  using resize_factor = theta_constants::resize_factor;
+
+  class builder;
+
+  CompactSketch get_result(bool ordered = true) const;
+
+private:
+  // for builder
+  array_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 Array, typename Policy, typename Allocator>
+class array_tuple_union<Array, Policy, Allocator>::builder: public tuple_base_builder<builder, Policy, Allocator> {
+public:
+  builder(const Policy& policy = Policy(), const Allocator& allocator = Allocator());
+  array_tuple_union build() const;
+};
+
+} /* namespace datasketches */
+
+#include "array_tuple_union_impl.hpp"
+
+#endif

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

@@ -0,0 +1,43 @@
+/*
+ * 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.
+ */
+
+namespace datasketches {
+
+template<typename Array, typename Policy, typename Allocator>
+array_tuple_union<Array, Policy, Allocator>::array_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):
+Base(lg_cur_size, lg_nom_size, rf, p, theta, seed, policy, allocator)
+{}
+
+template<typename Array, typename Policy, typename Allocator>
+auto array_tuple_union<Array, Policy, Allocator>::get_result(bool ordered) const -> CompactSketch {
+  return CompactSketch(this->state_.get_policy().get_external_policy().get_num_values(), Base::get_result(ordered));
+}
+
+// builder
+
+template<typename Array, typename Policy, typename Allocator>
+array_tuple_union<Array, Policy, Allocator>::builder::builder(const Policy& policy, const Allocator& allocator):
+tuple_base_builder<builder, Policy, typename Array::allocator_type>(policy, allocator) {}
+
+template<typename Array, typename Policy, typename Allocator>
+auto array_tuple_union<Array, Policy, Allocator>::builder::build() const -> array_tuple_union {
+  return array_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/include/tuple_a_not_b.hpp

@@ -25,6 +25,7 @@
 
 namespace datasketches {
 
+/// tuple A-not-B
 template<
   typename Summary,
   typename Allocator = std::allocator<Summary>
@@ -37,11 +38,19 @@ public:
   using AllocEntry = typename std::allocator_traits<Allocator>::template rebind_alloc<Entry>;
   using State = theta_set_difference_base<Entry, ExtractKey, CompactSketch, AllocEntry>;
 
+  /**
+   * Constructor
+   * @param seed for the hash function that was used to create the sketch
+   * @param allocator to use for allocating and deallocating memory
+   */
   explicit tuple_a_not_b(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;

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

@@ -28,16 +28,17 @@ namespace datasketches {
 /*
 // for types with defined + operation
 template<typename Summary>
-struct example_intersection_policy {
+struct example_tuple_intersection_policy {
   void operator()(Summary& summary, const Summary& other) const {
     summary += other;
   }
-  void operator()(Summary& summary, Summary&& other) const {
-    summary += other;
-  }
 };
 */
 
+/**
+ * Tuple intersection.
+ * Computes intersection of Tuple sketches.
+ */
 template<
   typename Summary,
   typename Policy,
@@ -54,19 +55,25 @@ public:
   // reformulate the external policy that operates on Summary
   // in terms of operations on Entry
   struct internal_policy {
-    internal_policy(const Policy& policy): policy_(policy) {}
+    internal_policy(const Policy& external_policy): external_policy_(external_policy) {}
     void operator()(Entry& internal_entry, const Entry& incoming_entry) const {
-      policy_(internal_entry.second, incoming_entry.second);
+      external_policy_(internal_entry.second, incoming_entry.second);
     }
     void operator()(Entry& internal_entry, Entry&& incoming_entry) const {
-      policy_(internal_entry.second, std::move(incoming_entry.second));
+      external_policy_(internal_entry.second, std::move(incoming_entry.second));
     }
-    const Policy& get_policy() const { return policy_; }
-    Policy policy_;
+    const Policy& get_external_policy() const { return external_policy_; }
+    Policy external_policy_;
   };
 
   using State = theta_intersection_base<Entry, ExtractKey, internal_policy, Sketch, CompactSketch, AllocEntry>;
 
+  /**
+   * Constructor
+   * @param seed for the hash function that was used to create the sketch
+   * @param policy user-defined way of combining Summary during intersection
+   * @param allocator to use for allocating and deallocating memory
+   */
   explicit tuple_intersection(uint64_t seed = DEFAULT_SEED, const Policy& policy = Policy(), const Allocator& allocator = Allocator());
 
   /**
@@ -82,7 +89,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;

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

@@ -26,10 +26,11 @@
 
 namespace datasketches {
 
+/// Tuple Jaccard similarity alias
 template<
   typename Summary,
   typename IntersectionPolicy,
-  typename UnionPolicy = default_union_policy<Summary>,
+  typename UnionPolicy = default_tuple_union_policy<Summary>,
   typename Allocator = std::allocator<Summary>>
 using tuple_jaccard_similarity = jaccard_similarity_base<tuple_union<Summary, UnionPolicy, Allocator>, tuple_intersection<Summary, IntersectionPolicy, Allocator>, pair_extract_key<uint64_t, Summary>>;