Use c++11 features only

geonove · geonove · commit b0c18de91870 · 2025-11-29T15:24:42.000+01:00
diff --git a/Doxyfile b/Doxyfile
@@ -955,6 +955,7 @@ INPUT                  = common/include \
                          fi/include \
                          count/include \
                          req/include \
+                         ddsketch/include \
                          README.md
 
 # This tag can be used to specify the character encoding of the source files
diff --git a/ddsketch/include/dense_store_impl.hpp b/ddsketch/include/dense_store_impl.hpp
@@ -27,6 +27,9 @@
 
 namespace datasketches {
 
+template<typename Store, typename Allocator>
+constexpr int DenseStore<Store, Allocator>::DEFAULT_ARRAY_LENGTH_GROWTH_INCREMENT;
+
 template<class Derived, typename Allocator>
 DenseStore<Derived, Allocator>::DenseStore() :
   DenseStore(DEFAULT_ARRAY_LENGTH_GROWTH_INCREMENT)
diff --git a/ddsketch/include/index_mapping_factory.hpp b/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::unique_ptr<IndexMapping>();
+    return std::unique_ptr<IndexMapping>(new IndexMapping(std::forward<Args>(args)...));
   }
 };
 }
diff --git a/ddsketch/include/linearly_interpolated_mapping.hpp b/ddsketch/include/linearly_interpolated_mapping.hpp
@@ -55,8 +55,8 @@ class LinearlyInterpolatedMapping : public LogLikeIndexMapping<LinearlyInterpola
 
   IndexMappingLayout layout() const;
 
-  static constexpr double BASE = 2.0;
-  static constexpr double CORRECTING_FACTOR = 1.44269504088896340735;
+  static constexpr double BASE() { return 2.0; }
+  static constexpr double CORRECTING_FACTOR() { return 1.44269504088896340735; }
 
 private:
   static double index_offset_shift(const double& relative_accuracy);
diff --git a/ddsketch/include/linearly_interpolated_mapping_impl.hpp b/ddsketch/include/linearly_interpolated_mapping_impl.hpp
@@ -22,11 +22,8 @@
 
 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)) {}
+  LogLikeIndexMapping<LinearlyInterpolatedMapping>(compute_gamma(require_valid_relative_accuracy(relative_accuracy), CORRECTING_FACTOR()), index_offset_shift(relative_accuracy)) {}
 
 inline LinearlyInterpolatedMapping::LinearlyInterpolatedMapping(const double& gamma, const double& index_offset):
   LogLikeIndexMapping<LinearlyInterpolatedMapping>(gamma, index_offset) {}
diff --git a/ddsketch/include/log_like_index_mapping.hpp b/ddsketch/include/log_like_index_mapping.hpp
@@ -104,7 +104,7 @@ class LogLikeIndexMapping : public IndexMapping<Derived> {
   bool operator!=(const LogLikeIndexMapping<Derived>& other) const;
 
 private:
-  static double compute_relative_accuracy(const double& gamma, const double& correcting_factor);
+  static double compute_relative_accuracy(const double gamma, const double correcting_factor);
   static double require_valid_gamma(const double& gamma);
   IndexMappingLayout layout() const;
 
diff --git a/ddsketch/include/log_like_index_mapping_impl.hpp b/ddsketch/include/log_like_index_mapping_impl.hpp
@@ -29,11 +29,11 @@ template<class Derived>
 LogLikeIndexMapping<Derived>::LogLikeIndexMapping(const double& gamma, const double& index_offset):
   gamma(require_valid_gamma(gamma)),
   index_offset(index_offset),
-  relative_accuracy(compute_relative_accuracy(gamma, Derived::CORRECTING_FACTOR)),
-  multiplier(std::log(Derived::BASE) / std::log1p(gamma - 1)) {}
+  relative_accuracy(compute_relative_accuracy(gamma, Derived::CORRECTING_FACTOR())),
+  multiplier(std::log(Derived::BASE()) / std::log1p(gamma - 1)) {}
 
 template<class Derived>
-double LogLikeIndexMapping<Derived>::compute_relative_accuracy(const double& gamma, const double& correcting_factor) {
+double LogLikeIndexMapping<Derived>::compute_relative_accuracy(const double gamma, const double correcting_factor) {
   const double exact_log_gamma = std::pow(gamma, correcting_factor);
   return (exact_log_gamma - 1) / (exact_log_gamma + 1);
 }
@@ -89,14 +89,14 @@ double LogLikeIndexMapping<Derived>::get_relative_accuracy() const {
 
 template<class Derived>
 double LogLikeIndexMapping<Derived>::min_indexable_value() const {
-  const double& a = std::pow(Derived::BASE, (static_cast<double>(std::numeric_limits<int>::min()) - index_offset) / multiplier + 1);
+  const double& a = std::pow(Derived::BASE(), (static_cast<double>(std::numeric_limits<int>::min()) - index_offset) / multiplier + 1);
   const double& b = std::numeric_limits<double>::min() * (1 + relative_accuracy) / (1 - relative_accuracy);
   return std::max(a, b);
 }
 
 template<class Derived>
 double LogLikeIndexMapping<Derived>::max_indexable_value() const {
-  const double& a = std::pow(Derived::BASE, (static_cast<double>(std::numeric_limits<int>::max()) - index_offset) / multiplier - 1);
+  const double& a = std::pow(Derived::BASE(), (static_cast<double>(std::numeric_limits<int>::max()) - index_offset) / multiplier - 1);
   const double& b = std::numeric_limits<double>::max() / (1 + relative_accuracy);
   return std::min(a, b);
 }
diff --git a/ddsketch/include/logarithmic_mapping.hpp b/ddsketch/include/logarithmic_mapping.hpp
@@ -55,8 +55,8 @@ class LogarithmicMapping : public LogLikeIndexMapping<LogarithmicMapping> {
 
   IndexMappingLayout layout() const;
 
-  static constexpr double BASE = 2.71828182845904523536;
-  static constexpr double CORRECTING_FACTOR = 1.0;
+  static constexpr double BASE() { return 2.71828182845904523536; }
+  static constexpr double CORRECTING_FACTOR() { return 1.0; }
 };
 }
 
diff --git a/ddsketch/include/logarithmic_mapping_impl.hpp b/ddsketch/include/logarithmic_mapping_impl.hpp
@@ -22,8 +22,6 @@
 #include "logarithmic_mapping.hpp"
 
 namespace datasketches {
-constexpr double LogarithmicMapping::BASE;
-constexpr double LogarithmicMapping::CORRECTING_FACTOR;
 
 inline LogarithmicMapping::LogarithmicMapping(const double& relative_accuracy) :
   LogLikeIndexMapping<LogarithmicMapping>(compute_gamma(require_valid_relative_accuracy(relative_accuracy), 1.0), 0.0) {}
diff --git a/ddsketch/include/quadratically_interpolated_mapping.hpp b/ddsketch/include/quadratically_interpolated_mapping.hpp
@@ -54,11 +54,11 @@ class QuadraticallyInterpolatedMapping : public LogLikeIndexMapping<Quadraticall
 
   IndexMappingLayout layout() const;
 
-  static constexpr double BASE = 2.0;
-  static constexpr double CORRECTING_FACTOR = 3.0 / (4.0 * 0.69314718055994530941);
+  static constexpr double BASE() { return 2.0; }
+  static constexpr double CORRECTING_FACTOR() { return 3.0 / (4.0 * 0.69314718055994530941); }
 
 private:
-  static constexpr double ONE_THIRD = 1.0 / 3.0;
+  static constexpr double ONE_THIRD() { return 1.0 / 3.0; }
 };
 }
 #endif //QUADRATICALLY_INTERPOLATED_MAPPING_HPP
diff --git a/ddsketch/include/quadratically_interpolated_mapping_impl.hpp b/ddsketch/include/quadratically_interpolated_mapping_impl.hpp
@@ -24,12 +24,8 @@
 
 namespace datasketches {
 
-constexpr double QuadraticallyInterpolatedMapping::BASE;
-constexpr double QuadraticallyInterpolatedMapping::CORRECTING_FACTOR;
-constexpr double QuadraticallyInterpolatedMapping::ONE_THIRD;
-
 inline QuadraticallyInterpolatedMapping::QuadraticallyInterpolatedMapping(const double& relative_accuracy) :
-  LogLikeIndexMapping<QuadraticallyInterpolatedMapping>(compute_gamma(require_valid_relative_accuracy(relative_accuracy), CORRECTING_FACTOR), 0.0) {}
+  LogLikeIndexMapping<QuadraticallyInterpolatedMapping>(compute_gamma(require_valid_relative_accuracy(relative_accuracy), CORRECTING_FACTOR()), 0.0) {}
 
 inline QuadraticallyInterpolatedMapping::QuadraticallyInterpolatedMapping(const double& gamma, const double& index_offset) :
   LogLikeIndexMapping<QuadraticallyInterpolatedMapping>(gamma, index_offset) {}
@@ -48,7 +44,7 @@ inline double QuadraticallyInterpolatedMapping::log(const double& value) const {
   int exponent = 0;
   const double mantissa = 2 * std::frexp(value, &exponent);
 
-  return exponent - 1 - (mantissa - 5.0) * (mantissa- 1) * ONE_THIRD;
+  return exponent - 1 - (mantissa - 5.0) * (mantissa- 1) * ONE_THIRD();
 }
 
 inline double QuadraticallyInterpolatedMapping::log_inverse(const double& index) const {
diff --git a/ddsketch/include/store_factory.hpp b/ddsketch/include/store_factory.hpp
@@ -28,7 +28,7 @@ class store_factory {
 public:
   static std::unique_ptr<StoreType> new_store()
   {
-    return std::unique_ptr<StoreType>();
+    return std::unique_ptr<StoreType>(new StoreType());
   }
 };
 }
diff --git a/ddsketch/test/DDSketchTest.cpp b/ddsketch/test/DDSketchTest.cpp

Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ class index_mapping_factory {`
`30`	`30`	`template<typename... Args>`
`31`	`31`	`static std::unique_ptr<IndexMapping> new_mapping(Args&&... args)`
`32`	`32`	`{`
`33`		`- return std::unique_ptr<IndexMapping>();`
	`33`	`+ return std::unique_ptr<IndexMapping>(new IndexMapping(std::forward<Args>(args)...));`
`34`	`34`	`}`
`35`	`35`	`};`
`36`	`36`	`}`
Original file line number	Diff line number	Diff line change
`@@ -55,8 +55,8 @@ class LogarithmicMapping : public LogLikeIndexMapping<LogarithmicMapping> {`
`55`	`55`
`56`	`56`	`IndexMappingLayout layout() const;`
`57`	`57`
`58`		`- static constexpr double BASE = 2.71828182845904523536;`
`59`		`- static constexpr double CORRECTING_FACTOR = 1.0;`
	`58`	`+ static constexpr double BASE() { return 2.71828182845904523536; }`
	`59`	`+ static constexpr double CORRECTING_FACTOR() { return 1.0; }`
`60`	`60`	`};`
`61`	`61`	`}`
`62`	`62`