datasketches 0.3.1 → 0.3.2

data/vendor/datasketches-cpp/python/include/quantile_conditional.hpp

@@ -0,0 +1,104 @@
+/*
+ * 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 _QUANTILE_CONDITIONAL_HPP_
+#define _QUANTILE_CONDITIONAL_HPP_
+
+/*
+  This header defines conditionally compiled functions shared
+  across the set of quantile family sketches.
+*/
+
+#include "common_defs.hpp"
+#include "py_serde.hpp"
+
+#include <pybind11/pybind11.h>
+#include <pybind11/numpy.h>
+
+namespace py = pybind11;
+
+// Serialization
+// std::string and arithmetic types, where we don't need a separate serde
+template<typename T, typename SK, typename std::enable_if<std::is_arithmetic<T>::value || std::is_same<std::string, T>::value, bool>::type = 0>
+void add_serialization(py::class_<SK>& clazz) {
+  clazz.def(
+        "serialize",
+        [](const SK& sk) {
+          auto bytes = sk.serialize();
+          return py::bytes(reinterpret_cast<const char*>(bytes.data()), bytes.size());
+        },
+        "Serializes the sketch into a bytes object."
+    )
+    .def_static(
+        "deserialize",
+        [](const std::string& bytes) { return SK::deserialize(bytes.data(), bytes.size()); },
+        py::arg("bytes"),
+        "Deserializes the sketch from a bytes object."
+    );
+}
+
+// py::object and other types where the caller must provide a serde
+template<typename T, typename SK, typename std::enable_if<!std::is_arithmetic<T>::value && !std::is_same<std::string, T>::value, bool>::type = 0>
+void add_serialization(py::class_<SK>& clazz) {
+  clazz.def(
+        "serialize",
+        [](const SK& sk, datasketches::py_object_serde& serde) {
+          auto bytes = sk.serialize(0, serde);
+          return py::bytes(reinterpret_cast<const char*>(bytes.data()), bytes.size());
+        }, py::arg("serde"),
+        "Serializes the sketch into a bytes object using the provided serde."
+    )
+    .def_static(
+        "deserialize",
+        [](const std::string& bytes, datasketches::py_object_serde& serde) {
+            return SK::deserialize(bytes.data(), bytes.size(), serde);
+        }, py::arg("bytes"), py::arg("serde"),
+        "Deserializes the sketch from a bytes object using the provided serde."
+    );
+}
+
+// Vector Updates
+// * Only allowed for POD types based on numpy restriction, which
+//   is equivalent to both std::is_trivial and std::is_standard_layout.
+// * Nothing is added to types that are not PODs.
+// POD type
+template<typename T, typename SK, typename std::enable_if<std::is_trivial<T>::value && std::is_standard_layout<T>::value, bool>::type = 0>
+void add_vector_update(py::class_<SK>& clazz) {
+  clazz.def(
+    "update",
+    [](SK& sk, py::array_t<T, py::array::c_style | py::array::forcecast> items) {
+      if (items.ndim() != 1) {
+        throw std::invalid_argument("input data must have only one dimension. Found: "
+          + std::to_string(items.ndim()));
+      }
+      auto array = items.template unchecked<1>();
+      for (uint32_t i = 0; i < array.size(); ++i) sk.update(array(i));
+    },
+    py::arg("array"),
+    "Updates the sketch with the values in the given array"
+  );
+}
+
+// non-POD type
+template<typename T, typename SK, typename std::enable_if<!std::is_trivial<T>::value || !std::is_standard_layout<T>::value, bool>::type = 0>
+void add_vector_update(py::class_<SK>& clazz) {
+  unused(clazz);
+}
+
+#endif // _QUANTILE_CONDITIONAL_HPP_

data/vendor/datasketches-cpp/python/include/tuple_policy.hpp

@@ -0,0 +1,136 @@
+/*
+ * 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.
+ */
+
+#include <memory>
+#include <pybind11/pybind11.h>
+
+#ifndef _TUPLE_POLICY_HPP_
+#define _TUPLE_POLICY_HPP_
+
+namespace py = pybind11;
+
+namespace datasketches {
+
+/**
+ * @brief tuple_policy provides the underlying base class from
+ *        which native Python policies ultimately inherit. The actual
+ *        policies implement TuplePolicy, as shown in TuplePolicy.py
+ */
+struct tuple_policy {
+  virtual py::object create_summary() const = 0;
+  virtual py::object update_summary(py::object& summary, const py::object& update) const = 0;
+  virtual py::object operator()(py::object& summary, const py::object& update) const = 0;
+  virtual ~tuple_policy() = default;
+};
+
+/**
+ * @brief TuplePolicy provides the "trampoline" class for pybind11
+ *        that allows for a native Python implementation of tuple
+ *        sketch policies.
+ */
+struct TuplePolicy : public tuple_policy {
+  using tuple_policy::tuple_policy;
+
+  /**
+   * @brief Create a summary object
+   * 
+   * @return py::object representing a new summary
+   */
+  py::object create_summary() const override {
+    PYBIND11_OVERRIDE_PURE(
+      py::object,          // Return type
+      tuple_policy,        // Parent class
+      create_summary,      // Name of function in C++ (must match Python name)
+                           // Argument(s) -- if any
+    );
+  }
+
+  /**
+   * @brief Update a summary object using this policy
+   * 
+   * @param summary The current summary to update
+   * @param update The new value with which to update the summary
+   * @return py::object The updated summary
+   */
+  py::object update_summary(py::object& summary, const py::object& update) const override {
+    PYBIND11_OVERRIDE_PURE(
+      py::object,          // Return type
+      tuple_policy,        // Parent class
+      update_summary,      // Name of function in C++ (must match Python name)
+      summary, update      // Arguments
+    );
+  }
+
+  /**
+   * @brief Applies this policy to summary with the provided update
+   * 
+   * @param summary The current summary on which to apply the policy
+   * @param update An update to apply to the current summary
+   * @return py::object The potentially modified summary
+   */
+  py::object operator()(py::object& summary, const py::object& update) const override {
+    PYBIND11_OVERRIDE_PURE_NAME(
+      py::object,          // Return type
+      tuple_policy,        // Parent class
+      "__call__",          // Name of function in python
+      operator(),          // Name of function in C++
+      summary, update      // Arguemnts
+    );
+  }
+};
+
+/* The tuple_policy_holder provides a concrete class that dispatches calls
+ * from the sketch to the tuple_policy. This class is needed to provide a
+ * concrete object to produce a compiled library, but library users should
+ * never need to use this directly.
+ */
+struct tuple_policy_holder {
+  explicit tuple_policy_holder(std::shared_ptr<tuple_policy> policy) : _policy(policy) {}
+  tuple_policy_holder(const tuple_policy_holder& other) : _policy(other._policy) {}
+  tuple_policy_holder(tuple_policy_holder&& other) : _policy(std::move(other._policy)) {}
+  tuple_policy_holder& operator=(const tuple_policy_holder& other) { _policy = other._policy; return *this; }
+  tuple_policy_holder& operator=(tuple_policy_holder&& other) { std::swap(_policy, other._policy); return *this; }
+
+  py::object create() const { return _policy->create_summary(); }
+  
+  void update(py::object& summary, const py::object& update) const {
+    summary = _policy->update_summary(summary, update);
+  }
+
+  void operator()(py::object& summary, const py::object& update) const {
+    summary = _policy->operator()(summary, update);
+  }
+
+  private:
+    std::shared_ptr<tuple_policy> _policy;
+};
+
+/* A degenerate policy used to enable Jaccard Similarity on tuple sketches,
+ * where the computation requires a union and intersection over the keys but
+ * does not need to observe the summaries.
+ */
+struct dummy_jaccard_policy {
+  void operator()(py::object&, const py::object&) const {
+    return;
+  }
+};
+
+}
+
+#endif // _TUPLE_POLICY_HPP_

data/vendor/datasketches-cpp/python/src/count_wrapper.cpp

@@ -0,0 +1,101 @@
+/*
+ * 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.
+ */
+
+#include <pybind11/pybind11.h>
+
+#include "count_min.hpp"
+#include "common_defs.hpp"
+
+namespace py = pybind11;
+
+template<typename W>
+void bind_count_min_sketch(py::module &m, const char* name) {
+  using namespace datasketches;
+
+  py::class_<count_min_sketch<W>>(m, name)
+    .def(py::init<uint8_t, uint32_t, uint64_t>(), py::arg("num_hashes"), py::arg("num_buckets"), py::arg("seed")=DEFAULT_SEED)
+    .def(py::init<const count_min_sketch<W>&>())
+    .def_static("suggest_num_buckets", &count_min_sketch<W>::suggest_num_buckets, py::arg("relative_error"),
+                "Suggests the number of buckets needed to achieve an accuracy within the provided "
+                "relative_error. For example, when relative_error = 0.05, the returned frequency estimates "
+                "satisfy the 'relative_error' guarantee that never overestimates the weights but may "
+                "underestimate the weights by 5% of the total weight in the sketch. "
+                "Returns the number of hash buckets at every level of the sketch required in order to obtain "
+                "the specified relative error.")
+    .def_static("suggest_num_hashes", &count_min_sketch<W>::suggest_num_hashes, py::arg("confidence"),
+                "Suggests the number of hashes needed to achieve the provided confidence. For example, "
+                "with 95% confidence, frequency estimates satisfy the 'relative_error' guarantee. "
+                "Returns the number of hash functions that are required in order to achieve the specified "
+                "confidence of the sketch. confidence = 1 - delta, with delta denoting the sketch failure probability.")
+    .def("__str__", &count_min_sketch<W>::to_string,
+         "Produces a string summary of the sketch")
+    .def("to_string", &count_min_sketch<W>::to_string,
+         "Produces a string summary of the sketch")
+    .def("is_empty", &count_min_sketch<W>::is_empty,
+         "Returns True if the sketch has seen no items, otherwise False")
+    .def("get_num_hashes", &count_min_sketch<W>::get_num_hashes,
+         "Returns the configured number of hashes for the sketch")
+    .def("get_num_buckets", &count_min_sketch<W>::get_num_buckets,
+         "Returns the configured number of buckets for the sketch")
+    .def("get_seed", &count_min_sketch<W>::get_seed,
+         "Returns the base hash seed for the sketch")
+    .def("get_relative_error", &count_min_sketch<W>::get_relative_error,
+         "Returns the maximum permissible error for any frequency estimate query")
+    .def("get_total_weight", &count_min_sketch<W>::get_total_weight,
+         "Returns the total weight currently inserted into the stream")
+    .def("update", static_cast<void (count_min_sketch<W>::*)(int64_t, W)>(&count_min_sketch<W>::update), py::arg("item"), py::arg("weight")=1.0,
+         "Updates the sketch with the given 64-bit integer value")
+    .def("update", static_cast<void (count_min_sketch<W>::*)(const std::string&, W)>(&count_min_sketch<W>::update), py::arg("item"), py::arg("weight")=1.0,
+         "Updates the sketch with the given string")
+    .def("get_estimate", static_cast<W (count_min_sketch<W>::*)(int64_t) const>(&count_min_sketch<W>::get_estimate), py::arg("item"),
+         "Returns an estimate of the frequency of the provided 64-bit integer value")
+    .def("get_estimate", static_cast<W (count_min_sketch<W>::*)(const std::string&) const>(&count_min_sketch<W>::get_estimate), py::arg("item"),
+         "Returns an estimate of the frequency of the provided string")
+    .def("get_upper_bound", static_cast<W (count_min_sketch<W>::*)(int64_t) const>(&count_min_sketch<W>::get_upper_bound), py::arg("item"),
+         "Returns an upper bound on the estimate for the given 64-bit integer value")
+    .def("get_upper_bound", static_cast<W (count_min_sketch<W>::*)(const std::string&) const>(&count_min_sketch<W>::get_upper_bound), py::arg("item"),
+         "Returns an upper bound on the estimate for the provided string")
+    .def("get_lower_bound", static_cast<W (count_min_sketch<W>::*)(int64_t) const>(&count_min_sketch<W>::get_lower_bound), py::arg("item"),
+         "Returns an lower bound on the estimate for the given 64-bit integer value")
+    .def("get_lower_bound", static_cast<W (count_min_sketch<W>::*)(const std::string&) const>(&count_min_sketch<W>::get_lower_bound), py::arg("item"),
+         "Returns an lower bound on the estimate for the provided string")
+    .def("merge", &count_min_sketch<W>::merge, py::arg("other"),
+         "Merges the provided other sketch into this one")
+    .def("get_serialized_size_bytes", &count_min_sketch<W>::get_serialized_size_bytes,
+         "Returns the size in bytes of the serialized image of the sketch")
+    .def(
+        "serialize",
+        [](const count_min_sketch<W>& sk) {
+          auto bytes = sk.serialize();
+          return py::bytes(reinterpret_cast<const char*>(bytes.data()), bytes.size());
+        },
+        "Serializes the sketch into a bytes object"
+    )
+    .def_static(
+        "deserialize",
+        [](const std::string& bytes) { return count_min_sketch<W>::deserialize(bytes.data(), bytes.size()); },
+        py::arg("bytes"),
+        "Reads a bytes object and returns the corresponding count_min_sketch"
+    );
+}
+
+void init_count_min(py::module &m) {
+  bind_count_min_sketch<double>(m, "count_min_sketch");
+}
+

data/vendor/datasketches-cpp/python/src/cpc_wrapper.cpp

@@ -17,7 +17,6 @@
  * under the License.
  */
 
-#include <sstream>
 #include <pybind11/pybind11.h>
 
 #include "cpc_sketch.hpp"
@@ -27,28 +26,6 @@
 
 namespace py = pybind11;
 
-namespace datasketches {
-namespace python {
-
-cpc_sketch* cpc_sketch_deserialize(py::bytes skBytes) {
-  std::string skStr = skBytes; // implicit cast
-  return new cpc_sketch(cpc_sketch::deserialize(skStr.c_str(), skStr.length()));
-}
-
-py::object cpc_sketch_serialize(const cpc_sketch& sk) {
-  auto serResult = sk.serialize();
-  return py::bytes((char*)serResult.data(), serResult.size());
-}
-
-cpc_sketch* cpc_union_get_result(const cpc_union& u) {
-  return new cpc_sketch(u.get_result());
-}
-
-}
-}
-
-namespace dspy = datasketches::python;
-
 void init_cpc(py::module &m) {
   using namespace datasketches;
 
@@ -59,10 +36,6 @@ void init_cpc(py::module &m) {
          "Produces a string summary of the sketch")
     .def("to_string", &cpc_sketch::to_string,
          "Produces a string summary of the sketch")
-    .def("serialize", &dspy::cpc_sketch_serialize,
-         "Serializes the sketch into a bytes object")
-    .def_static("deserialize", &dspy::cpc_sketch_deserialize,
-         "Reads a bytes object and returns the corresponding cpc_sketch")
     .def<void (cpc_sketch::*)(uint64_t)>("update", &cpc_sketch::update, py::arg("datum"),
          "Updates the sketch with the given 64-bit integer value")
     .def<void (cpc_sketch::*)(double)>("update", &cpc_sketch::update, py::arg("datum"),
@@ -70,21 +43,34 @@ void init_cpc(py::module &m) {
     .def<void (cpc_sketch::*)(const std::string&)>("update", &cpc_sketch::update, py::arg("datum"),
          "Updates the sketch with the given string")
     .def("is_empty", &cpc_sketch::is_empty,
-         "Returns True if the sketch is empty, otherwise Dalse")
+         "Returns True if the sketch is empty, otherwise False")
     .def("get_estimate", &cpc_sketch::get_estimate,
          "Estimate of the distinct count of the input stream")
     .def("get_lower_bound", &cpc_sketch::get_lower_bound, py::arg("kappa"),
          "Returns an approximate lower bound on the estimate for kappa values in {1, 2, 3}, roughly corresponding to standard deviations")
     .def("get_upper_bound", &cpc_sketch::get_upper_bound, py::arg("kappa"),
          "Returns an approximate upper bound on the estimate for kappa values in {1, 2, 3}, roughly corresponding to standard deviations")
-    ;
+    .def(
+        "serialize",
+        [](const cpc_sketch& sk) {
+          auto bytes = sk.serialize();
+          return py::bytes(reinterpret_cast<const char*>(bytes.data()), bytes.size());
+        },
+        "Serializes the sketch into a bytes object"
+    )
+    .def_static(
+        "deserialize",
+        [](const std::string& bytes) { return cpc_sketch::deserialize(bytes.data(), bytes.size()); },
+        py::arg("bytes"),
+        "Reads a bytes object and returns the corresponding cpc_sketch"
+    );
 
   py::class_<cpc_union>(m, "cpc_union")
     .def(py::init<uint8_t, uint64_t>(), py::arg("lg_k"), py::arg("seed")=DEFAULT_SEED)
     .def(py::init<const cpc_union&>())
     .def("update", (void (cpc_union::*)(const cpc_sketch&)) &cpc_union::update, py::arg("sketch"),
          "Updates the union with the provided CPC sketch")
-    .def("get_result", &dspy::cpc_union_get_result,
+    .def("get_result", &cpc_union::get_result,
          "Returns a CPC sketch with the result of the union")
     ;
 }

data/vendor/datasketches-cpp/python/src/datasketches.cpp

@@ -27,9 +27,12 @@ void init_kll(py::module& m);
 void init_fi(py::module& m);
 void init_cpc(py::module& m);
 void init_theta(py::module& m);
+void init_tuple(py::module& m);
 void init_vo(py::module& m);
 void init_req(py::module& m);
 void init_quantiles(py::module& m);
+void init_count_min(py::module& m);
+void init_density(py::module& m);
 void init_vector_of_kll(py::module& m);
 
 // supporting objects
@@ -42,9 +45,12 @@ PYBIND11_MODULE(_datasketches, m) {
   init_fi(m);
   init_cpc(m);
   init_theta(m);
+  init_tuple(m);
   init_vo(m);
   init_req(m);
   init_quantiles(m);
+  init_count_min(m);
+  init_density(m);
   init_vector_of_kll(m);
 
   init_kolmogorov_smirnov(m);

data/vendor/datasketches-cpp/python/src/density_wrapper.cpp

@@ -0,0 +1,95 @@
+/*
+ * 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.
+ */
+
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/numpy.h>
+#include <vector>
+
+#include "kernel_function.hpp"
+#include "density_sketch.hpp"
+
+namespace py = pybind11;
+
+template<typename T, typename K>
+void bind_density_sketch(py::module &m, const char* name) {
+  using namespace datasketches;
+
+  py::class_<density_sketch<T, K>>(m, name)
+    .def(
+        py::init([](uint16_t k, uint32_t dim, std::shared_ptr<kernel_function> kernel) {
+          kernel_function_holder holder(kernel);
+          return density_sketch<T, K>(k, dim, holder);
+        }),
+        py::arg("k"), py::arg("dim"), py::arg("kernel"))
+    .def("update", static_cast<void (density_sketch<T, K>::*)(const std::vector<T>&)>(&density_sketch<T, K>::update),
+        "Updates the sketch with the given vector")
+    .def("merge", static_cast<void (density_sketch<T, K>::*)(const density_sketch<T, K>&)>(&density_sketch<T, K>::merge), py::arg("sketch"),
+        "Merges the provided sketch into this one")
+    .def("is_empty", &density_sketch<T, K>::is_empty,
+        "Returns True if the sketch is empty, otherwise False")
+    .def("get_k", &density_sketch<T, K>::get_k,
+        "Returns the configured parameter k")
+    .def("get_dim", &density_sketch<T, K>::get_dim,
+        "Returns the configured parameter dim")
+    .def("get_n", &density_sketch<T, K>::get_n,
+        "Returns the length of the input stream")
+    .def("get_num_retained", &density_sketch<T, K>::get_num_retained,
+        "Returns the number of retained items (samples) in the sketch")
+    .def("is_estimation_mode", &density_sketch<T, K>::is_estimation_mode,
+        "Returns True if the sketch is in estimation mode, otherwise False")
+    .def("get_estimate", &density_sketch<T, K>::get_estimate, py::arg("point"),
+        "Returns an approximate density at the given point")
+    .def("__str__", &density_sketch<T, K>::to_string, py::arg("print_levels")=false, py::arg("print_items")=false,
+        "Produces a string summary of the sketch")
+    .def("to_string", &density_sketch<T, K>::to_string, py::arg("print_levels")=false, py::arg("print_items")=false,
+        "Produces a string summary of the sketch")
+    .def("__iter__", [](const density_sketch<T, K>& s){ return py::make_iterator(s.begin(), s.end()); })
+    .def("serialize",
+        [](const density_sketch<T, K>& sk) {
+          auto bytes = sk.serialize();
+          return py::bytes(reinterpret_cast<const char*>(bytes.data()), bytes.size());
+        },
+        "Serializes the sketch into a bytes object"
+    )
+    .def_static(
+        "deserialize",
+        [](const std::string& bytes, std::shared_ptr<kernel_function> kernel) {
+          kernel_function_holder holder(kernel);
+          return density_sketch<T, K>::deserialize(bytes.data(), bytes.size(), holder);
+        },
+        py::arg("bytes"), py::arg("kernel"),
+        "Reads a bytes object and returns the corresponding density_sketch"
+    );;
+}
+
+void init_density(py::module &m) {
+  using namespace datasketches;
+
+  // generic kernel function
+  py::class_<kernel_function, KernelFunction, std::shared_ptr<kernel_function>>(m, "KernelFunction")
+    .def(py::init())
+    .def("__call__", &kernel_function::operator(), py::arg("a"), py::arg("b"))
+    ;
+
+  // the old sketch names  can almost be defined, but the kernel_function_holder won't work in init()
+  //bind_density_sketch<float, gaussian_kernel<float>>(m, "density_floats_sketch");
+  //bind_density_sketch<double, gaussian_kernel<double>>(m, "density_doubles_sketch");
+  bind_density_sketch<double, kernel_function_holder>(m, "_density_sketch");
+}