WIP c++11

Author: geonove

CMakeLists.txt

@@ -43,7 +43,7 @@ set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
 #set(CMAKE_VERBOSE_MAKEFILE ON)
 set(CMAKE_MACOSX_RPATH ON)
 
-set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD 11)
 
 # enable compiler warnings globally
 # derived from https://foonathan.net/blog/2018/10/17/cmake-warnings.html

ddsketch/CMakeLists.txt

@@ -59,9 +59,6 @@ install(FILES
         include/logarithmic_mapping_impl.hpp
         include/quadratically_interpolated_mapping.hpp
         include/quadratically_interpolated_mapping_impl.hpp
-        include/sparse_store.hpp
-        include/sparse_store_impl.hpp
-        include/store.hpp
         include/store_factory.hpp
         include/unbounded_size_dense_store.hpp
         include/unbounded_size_dense_store_impl.hpp

ddsketch/include/ddsketch.hpp

@@ -23,7 +23,6 @@
 #include <utility>
 #include <type_traits>
 #include <variant>
-#include "store.hpp"
 #include "store_factory.hpp"
 #include "common_defs.hpp"
 #include "memory_operations.hpp"
@@ -41,7 +40,7 @@ namespace datasketches {
  * @tparam Store underlying data structure that keeps track of bin counts.
  * @tparam Mapping maps an index to its corresponding bin.
  */
-template<store_concept Store, class Mapping>
+template<class Store, class Mapping>
 class  DDSketch {
 public:
 
@@ -75,7 +74,7 @@ class  DDSketch {
   * @param other DDSketch; its counts are added into this store.
   * @tparam OtherStore type of the other store.
   */
-  template<store_concept OtherStore>
+  template<class OtherStore>
   void merge(const DDSketch<OtherStore, Mapping>& other);
 
   /**
@@ -166,17 +165,12 @@ class  DDSketch {
 
   void check_value_trackable(const double& value) const;
 
-  template<store_concept OtherStore>
+  template<class OtherStore>
   void check_mergeability(const DDSketch<OtherStore, Mapping>& other) const;
 
   double get_quantile(const double& rank, const double& count) const;
 };
 
-// CTA (class template argument deduction) deduction guides (so you can write `ddsketch sketch(s1);`)
-template<store_concept Store, class Mapping>
-DDSketch(Store, Mapping) -> DDSketch<Store, Mapping>;\
-
-
 } /* namespace datasketches */
 
 #include "ddsketch_impl.hpp"

ddsketch/include/ddsketch_impl.hpp

@@ -22,14 +22,16 @@
 
 #include <iomanip>
 #include <iostream>
+#include "bin.hpp"
+#include <sstream>
 #include "ddsketch.hpp"
 #include "store_factory.hpp"
 namespace datasketches {
 
-template<store_concept Store, class Mapping>
+template<class Store, class Mapping>
 DDSketch<Store, Mapping>::DDSketch(const double& relative_accuracy): DDSketch(Mapping(relative_accuracy)) {}
 
-template<store_concept Store, class Mapping>
+template<class Store, class Mapping>
 DDSketch<Store, Mapping>::DDSketch(const Mapping& index_mapping):
   index_mapping(index_mapping),
   zero_count(0),
@@ -38,7 +40,7 @@ DDSketch<Store, Mapping>::DDSketch(const Mapping& index_mapping):
 {}
 
 
-template<store_concept Store, class Mapping>
+template<class Store, class Mapping>
 DDSketch<Store, Mapping>::DDSketch(const Store& positive_store, const Store& negative_store, const Mapping& mapping, const double& zero_count, const double& min_indexed_value):
   positive_store(std::move(positive_store)),
   negative_store(std::move(negative_store)),
@@ -48,22 +50,22 @@ DDSketch<Store, Mapping>::DDSketch(const Store& positive_store, const Store& neg
   max_indexed_value(mapping.max_indexable_value()) {}
 
 
-template<store_concept Store, class Mapping>
+template<class Store, class Mapping>
 void DDSketch<Store, Mapping>::check_value_trackable(const double& value) const {
   if (value < -max_indexed_value || value > max_indexed_value) {
     throw std::invalid_argument("input value is outside the range that is tracked by the sketch.");
   }
 }
 
-template<store_concept Store, class Mapping>
-template<store_concept OtherStore>
+template<class Store, class Mapping>
+template<class OtherStore>
 void DDSketch<Store, Mapping>::check_mergeability(const DDSketch<OtherStore, Mapping>& other) const {
   if (index_mapping != other.index_mapping) {
     throw std::invalid_argument("sketches are not mergeable because they do not use the same index mappings.");
   }
 }
 
-template<store_concept Store, class Mapping>
+template<class Store, class Mapping>
 void DDSketch<Store, Mapping>::update(const double& value, const double& count) {
   check_value_trackable(value);
 
@@ -80,33 +82,33 @@ void DDSketch<Store, Mapping>::update(const double& value, const double& count)
   }
 }
 
-template<store_concept Store, class Mapping>
-template<store_concept OtherStore>
+template<class Store, class Mapping>
+template<class OtherStore>
 void DDSketch<Store, Mapping>::merge(const DDSketch<OtherStore, Mapping>& other) {
   check_mergeability<OtherStore>(other);
   negative_store.merge(other.negative_store);
   positive_store.merge(other.positive_store);
   zero_count += other.zero_count;
 }
 
-template<store_concept Store, class Mapping>
+template<class Store, class Mapping>
 bool DDSketch<Store, Mapping>::is_empty() const {
   return zero_count == 0.0 && positive_store.is_empty() && negative_store.is_empty();
 }
 
-template<store_concept Store, class Mapping>
+template<class Store, class Mapping>
 void DDSketch<Store, Mapping>::clear() {
   negative_store.clear();
   positive_store.clear();
   zero_count = 0.0;
 }
 
-template<store_concept Store, class Mapping>
+template<class Store, class Mapping>
 double DDSketch<Store, Mapping>::get_count() const {
   return zero_count + negative_store.get_total_count() + positive_store.get_total_count();
 }
 
-template<store_concept Store, class Mapping>
+template<class Store, class Mapping>
 double DDSketch<Store, Mapping>::get_sum() const {
   double sum = 0.0;
   for (const Bin& bin : negative_store) {
@@ -118,7 +120,7 @@ double DDSketch<Store, Mapping>::get_sum() const {
   return sum;
 }
 
-template<store_concept Store, class Mapping>
+template<class Store, class Mapping>
 double DDSketch<Store, Mapping>::get_min() const {
   if (!negative_store.is_empty()) {
     return -index_mapping.value(negative_store.get_max_index());
@@ -129,7 +131,7 @@ double DDSketch<Store, Mapping>::get_min() const {
   return index_mapping.value(positive_store.get_min_index());
 }
 
-template<store_concept Store, class Mapping>
+template<class Store, class Mapping>
 double DDSketch<Store, Mapping>::get_max() const {
   if (!positive_store.is_empty()) {
     return index_mapping.value(positive_store.get_max_index());
@@ -140,7 +142,7 @@ double DDSketch<Store, Mapping>::get_max() const {
   return -index_mapping.value(negative_store.get_min_index());
 }
 
-template<store_concept Store, class Mapping>
+template<class Store, class Mapping>
 double DDSketch<Store, Mapping>::get_rank(const double &item) const {
   double rank = 0.0;
 
@@ -161,12 +163,12 @@ double DDSketch<Store, Mapping>::get_rank(const double &item) const {
 }
 
 
-template<store_concept Store, class Mapping>
+template<class Store, class Mapping>
 double DDSketch<Store, Mapping>::get_quantile(const double& rank) const {
   return get_quantile(rank, get_count());
 }
 
-template<store_concept Store, class Mapping>
+template<class Store, class Mapping>
 double DDSketch<Store, Mapping>::get_quantile(const double& rank, const double& count) const {
   if (rank < 0.0 || rank > 1.0) {
     throw std::invalid_argument("rank must be in [0.0, 1.0]");
@@ -199,7 +201,7 @@ double DDSketch<Store, Mapping>::get_quantile(const double& rank, const double&
   throw std::invalid_argument("no such element");
 }
 
-template<store_concept Store, class Mapping>
+template<class Store, class Mapping>
 void DDSketch<Store, Mapping>::serialize(std::ostream& os) const {
   index_mapping.serialize(os);
 
@@ -215,21 +217,21 @@ void DDSketch<Store, Mapping>::serialize(std::ostream& os) const {
   negative_store.serialize(os);
 }
 
-template<store_concept Store, class Mapping>
+template<class Store, class Mapping>
 DDSketch<Store, Mapping> DDSketch<Store, Mapping>::deserialize(std::istream &is) {
   Mapping deserialized_index_mapping = Mapping::deserialize(is);
   const auto deserialized_zero_count = read<double>(is);
 
   const auto positive_store_serialized_size  = read<int>(is);
 
   std::string pos_buf(positive_store_serialized_size, '\0');
-  is.read(pos_buf.data(), pos_buf.size());
+  is.read(&pos_buf[0], pos_buf.size());
   std::stringstream pos_stream(pos_buf);
   Store deserialized_positive_store = Store::deserialize(pos_stream);
 
   const auto negative_store_serialized_size  = read<int>(is);
   std::string neg_buf(negative_store_serialized_size, '\0');
-  is.read(neg_buf.data(), neg_buf.size());
+  is.read(&neg_buf[0], neg_buf.size());
   std::stringstream neg_stream(neg_buf);
   Store deserialized_negative_store = Store::deserialize(neg_stream);
 
@@ -238,7 +240,7 @@ DDSketch<Store, Mapping> DDSketch<Store, Mapping>::deserialize(std::istream &is)
   return ddsketch;
 }
 
-template<store_concept Store, class Mapping>
+template<class Store, class Mapping>
 int DDSketch<Store, Mapping>::get_serialized_size_bytes() const {
   return index_mapping.get_serialized_size_bytes() +
     positive_store.get_serialized_size_bytes() +
@@ -247,7 +249,7 @@ int DDSketch<Store, Mapping>::get_serialized_size_bytes() const {
           2 * sizeof(double);
 }
 
-template<store_concept Store, class Mapping>
+template<class Store, class Mapping>
 template<class A>
 string<A> DDSketch<Store, Mapping>::to_string() const {
   std::ostringstream os;
@@ -267,7 +269,7 @@ string<A> DDSketch<Store, Mapping>::to_string() const {
 }
 
 
-template<store_concept Store, class Mapping>
+template<class Store, class Mapping>
 bool DDSketch<Store, Mapping>::operator==(const DDSketch<Store, Mapping>& other) const {
   return positive_store == other.positive_store &&
     negative_store == other.negative_store &&

ddsketch/include/dense_store.hpp

@@ -25,8 +25,6 @@
 #include "common_defs.hpp"
 
 namespace datasketches {
-// Forward declaration
-template<typename Allocator> class SparseStore;
 
 /**
  * @class DenseStore
@@ -109,12 +107,6 @@ class DenseStore {
   template<class Store>
   void merge(const DenseStore<Store, Allocator>& other);
 
-  /**
-   * @brief Merge a sparse store into this dense store.
-   * @param other SparseStore to accumulate from.
-   */
-  void merge(const SparseStore<Allocator>& other);
-
   /**
    * This method serializes the store into a given stream in a binary form
    * @param os output stream

ddsketch/include/dense_store_impl.hpp

@@ -128,13 +128,6 @@ void DenseStore<Derived, Allocator>::merge(const DenseStore<OtherDerived, Alloca
   }
 }
 
-template<class Derived, typename Allocator>
-void DenseStore<Derived, Allocator>::merge(const SparseStore<Allocator>& other) {
-  for (const Bin &bin : other) {
-    add(bin);
-  }
-}
-
 template<class Derived, typename Allocator>
 typename DenseStore<Derived, Allocator>::iterator DenseStore<Derived, Allocator>::begin() const {
   if (is_empty()) {

ddsketch/include/index_mapping_factory.hpp

@@ -30,7 +30,7 @@ class index_mapping_factory {
   template<typename... Args>
   static std::unique_ptr<IndexMapping> new_mapping(Args&&... args)
   {
-    return std::make_unique<IndexMapping>(std::forward<Args>(args)...);
+    return std::unique_ptr<IndexMapping>();
   }
 };
 }

ddsketch/include/linearly_interpolated_mapping.hpp

@@ -21,7 +21,6 @@
 #define LINEARLY_INTERPOLATED_MAPPING_HPP
 
 #include "log_like_index_mapping.hpp"
-#include <numbers>
 
 
 namespace datasketches {
@@ -57,7 +56,7 @@ class LinearlyInterpolatedMapping : public LogLikeIndexMapping<LinearlyInterpola
   IndexMappingLayout layout() const;
 
   static constexpr double BASE = 2.0;
-  static constexpr double CORRECTING_FACTOR = std::numbers::log2e;
+  static constexpr double CORRECTING_FACTOR = 1.44269504088896340735;
 
 private:
   static double index_offset_shift(const double& relative_accuracy);

ddsketch/include/linearly_interpolated_mapping_impl.hpp

@@ -22,6 +22,9 @@
 
 namespace datasketches {
 
+constexpr double LinearlyInterpolatedMapping::BASE;
+constexpr double LinearlyInterpolatedMapping::CORRECTING_FACTOR;
+
 inline LinearlyInterpolatedMapping::LinearlyInterpolatedMapping(const double& relative_accuracy):
   LogLikeIndexMapping<LinearlyInterpolatedMapping>(compute_gamma(require_valid_relative_accuracy(relative_accuracy), CORRECTING_FACTOR), index_offset_shift(relative_accuracy)) {}
 

ddsketch/include/log_like_index_mapping.hpp

@@ -101,6 +101,7 @@ class LogLikeIndexMapping : public IndexMapping<Derived> {
   string<A> to_string() const;
 
   bool operator==(const LogLikeIndexMapping<Derived>& other) const;
+  bool operator!=(const LogLikeIndexMapping<Derived>& other) const;
 
 private:
   static double compute_relative_accuracy(const double& gamma, const double& correcting_factor);