datasketches 0.3.2 → 0.4.0

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

@@ -1,95 +0,0 @@
-/*
- * 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");
-}

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

@@ -1,182 +0,0 @@
-/*
- * 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 "py_serde.hpp"
-#include "py_object_ostream.hpp"
-#include "frequent_items_sketch.hpp"
-
-#include <pybind11/pybind11.h>
-
-#include <ostream>
-
-namespace py = pybind11;
-
-// forward declarations
-// std::string and arithmetic types, where we don't need a separate serde
-template<typename T, typename W, typename H, typename E, typename std::enable_if<std::is_arithmetic<T>::value || std::is_same<std::string, T>::value, bool>::type = 0>
-void add_serialization(py::class_<datasketches::frequent_items_sketch<T, W, H, E>>& clazz);
-
-// py::object and other types where the caller must provide a serde
-template<typename T, typename W, typename H, typename E, typename std::enable_if<!std::is_arithmetic<T>::value && !std::is_same<std::string, T>::value, bool>::type = 0>
-void add_serialization(py::class_<datasketches::frequent_items_sketch<T, W, H, E>>& clazz);
-
-template<typename T, typename W, typename H, typename E>
-void bind_fi_sketch(py::module &m, const char* name) {
-  using namespace datasketches;
-
-  auto fi_class = py::class_<frequent_items_sketch<T, W, H, E>>(m, name)
-    .def(py::init<uint8_t>(), py::arg("lg_max_k"))
-    .def("__str__", &frequent_items_sketch<T, W, H, E>::to_string, py::arg("print_items")=false,
-         "Produces a string summary of the sketch")
-    .def("to_string", &frequent_items_sketch<T, W, H, E>::to_string, py::arg("print_items")=false,
-         "Produces a string summary of the sketch")
-    .def("update", (void (frequent_items_sketch<T, W, H, E>::*)(const T&, uint64_t)) &frequent_items_sketch<T, W, H, E>::update, py::arg("item"), py::arg("weight")=1,
-         "Updates the sketch with the given string and, optionally, a weight")
-    .def("merge", (void (frequent_items_sketch<T, W, H, E>::*)(const frequent_items_sketch<T, W, H, E>&)) &frequent_items_sketch<T, W, H, E>::merge,
-         "Merges the given sketch into this one")
-    .def("is_empty", &frequent_items_sketch<T, W, H, E>::is_empty,
-         "Returns True if the sketch is empty, otherwise False")
-    .def("get_num_active_items", &frequent_items_sketch<T, W, H, E>::get_num_active_items,
-         "Returns the number of active items in the sketch")
-    .def("get_total_weight", &frequent_items_sketch<T, W, H, E>::get_total_weight,
-         "Returns the sum of the weights (frequencies) in the stream seen so far by the sketch")
-    .def("get_estimate", &frequent_items_sketch<T, W, H, E>::get_estimate, py::arg("item"),
-         "Returns the estimate of the weight (frequency) of the given item.\n"
-         "Note: The true frequency of a item would be the sum of the counts as a result of the "
-         "two update functions.")
-    .def("get_lower_bound", &frequent_items_sketch<T, W, H, E>::get_lower_bound, py::arg("item"),
-         "Returns the guaranteed lower bound weight (frequency) of the given item.")
-    .def("get_upper_bound", &frequent_items_sketch<T, W, H, E>::get_upper_bound, py::arg("item"),
-         "Returns the guaranteed upper bound weight (frequency) of the given item.")
-    .def("get_sketch_epsilon", (double (frequent_items_sketch<T, W, H, E>::*)(void) const) &frequent_items_sketch<T, W, H, E>::get_epsilon,
-         "Returns the epsilon value used by the sketch to compute error")
-    .def(
-        "get_frequent_items",
-        [](const frequent_items_sketch<T, W, H, E>& sk, frequent_items_error_type err_type, uint64_t threshold) {
-          if (threshold == 0) threshold = sk.get_maximum_error();
-          py::list list;
-          auto rows = sk.get_frequent_items(err_type, threshold);
-          for (auto row: rows) {
-            list.append(py::make_tuple(
-                row.get_item(),
-                row.get_estimate(),
-                row.get_lower_bound(),
-                row.get_upper_bound())
-            );
-          }
-          return list;
-        },
-        py::arg("err_type"), py::arg("threshold")=0
-    )
-    .def_static(
-        "get_epsilon_for_lg_size",
-        [](uint8_t lg_max_map_size) { return frequent_items_sketch<T, W, H, E>::get_epsilon(lg_max_map_size); },
-        py::arg("lg_max_map_size"),
-        "Returns the epsilon value used to compute a priori error for a given log2(max_map_size)"
-    )
-    .def_static(
-        "get_apriori_error",
-        &frequent_items_sketch<T, W, H, E>::get_apriori_error,
-        py::arg("lg_max_map_size"), py::arg("estimated_total_weight"),
-        "Returns the estimated a priori error given the max_map_size for the sketch and the estimated_total_stream_weight."
-    );
-
-    // serialization may need a caller-provided serde depending on the sketch type, so
-    // we use a separate method to handle that appropriately based on type T.
-    add_serialization(fi_class);
-}
-
-// std::string or arithmetic types, for which we have a built-in serde
-template<typename T, typename W, typename H, typename E, typename std::enable_if<std::is_arithmetic<T>::value || std::is_same<std::string, T>::value, bool>::type>
-void add_serialization(py::class_<datasketches::frequent_items_sketch<T, W, H, E>>& clazz) {
-    using namespace datasketches;
-    clazz.def(
-        "get_serialized_size_bytes",
-        [](const frequent_items_sketch<T, W, H, E>& sk) { return sk.get_serialized_size_bytes(); },
-        "Computes the size needed to serialize the current state of the sketch. This can be expensive since every item needs to be looked at."
-    )
-    .def(
-        "serialize",
-        [](const frequent_items_sketch<T, W, H, E>& 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 frequent_items_sketch<T, W, H, E>::deserialize(bytes.data(), bytes.size()); },
-        py::arg("bytes"),
-        "Reads a bytes object and returns the corresponding frequent_strings_sketch."
-    );
-}
-
-// py::object or any other type that requires a provided serde
-template<typename T, typename W, typename H, typename E, typename std::enable_if<!std::is_arithmetic<T>::value && !std::is_same<std::string, T>::value, bool>::type>
-void add_serialization(py::class_<datasketches::frequent_items_sketch<T, W, H, E>>& clazz) {
-    using namespace datasketches;
-    clazz.def(
-        "get_serialized_size_bytes",
-        [](const frequent_items_sketch<T, W, H, E>& sk, py_object_serde& serde) { return sk.get_serialized_size_bytes(serde); },
-        py::arg("serde"),
-        "Computes the size needed to serialize the current state of the sketch using the provided serde. This can be expensive since every item needs to be looked at."
-    )
-    .def(
-        "serialize",
-        [](const frequent_items_sketch<T, W, H, E>& sk, 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, py_object_serde& serde) {
-          return frequent_items_sketch<T, W, H, E>::deserialize(bytes.data(), bytes.size(), serde);
-        }, py::arg("bytes"), py::arg("serde"),
-        "Reads a bytes object using the provided serde and returns the corresponding frequent_strings_sketch."
-    );
-}
-
-// calls class __hash__ method
-struct py_hash_caller {
-  size_t operator()(const py::object& a) const {
-    return py::hash(a);
-  }
-};
-
-// calls class __eq__ method
-struct py_equal_caller {
-  bool operator()(const py::object& a, const py::object& b) const {
-    return a.equal(b);
-  }
-};
-
-void init_fi(py::module &m) {
-  using namespace datasketches;
-
-  py::enum_<frequent_items_error_type>(m, "frequent_items_error_type")
-    .value("NO_FALSE_POSITIVES", NO_FALSE_POSITIVES)
-    .value("NO_FALSE_NEGATIVES", NO_FALSE_NEGATIVES)
-    .export_values();
-
-  bind_fi_sketch<std::string, uint64_t, std::hash<std::string>, std::equal_to<std::string>>(m, "frequent_strings_sketch");
-  bind_fi_sketch<py::object, uint64_t, py_hash_caller, py_equal_caller>(m, "frequent_items_sketch"); 
-}

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

@@ -1,126 +0,0 @@
-/*
- * 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 "hll.hpp"
-
-namespace py = pybind11;
-
-void init_hll(py::module &m) {
-  using namespace datasketches;
-
-  py::enum_<target_hll_type>(m, "tgt_hll_type", "Target HLL flavor")
-    .value("HLL_4", HLL_4)
-    .value("HLL_6", HLL_6)
-    .value("HLL_8", HLL_8)
-    .export_values();
-
-  py::class_<hll_sketch>(m, "hll_sketch")
-    .def(py::init<uint8_t>(), py::arg("lg_k"))
-    .def(py::init<uint8_t, target_hll_type>(), py::arg("lg_k"), py::arg("tgt_type"))
-    .def(py::init<uint8_t, target_hll_type, bool>(), py::arg("lg_k"), py::arg("tgt_type"), py::arg("start_max_size")=false)
-    .def("__str__", (std::string (hll_sketch::*)(bool,bool,bool,bool) const) &hll_sketch::to_string,
-         py::arg("summary")=true, py::arg("detail")=false, py::arg("aux_detail")=false, py::arg("all")=false,
-         "Produces a string summary of the sketch")
-    .def("to_string", (std::string (hll_sketch::*)(bool,bool,bool,bool) const) &hll_sketch::to_string,
-         py::arg("summary")=true, py::arg("detail")=false, py::arg("aux_detail")=false, py::arg("all")=false,
-         "Produces a string summary of the sketch")
-    .def_property_readonly("lg_config_k", &hll_sketch::get_lg_config_k, "Configured lg_k value for the sketch")
-    .def_property_readonly("tgt_type", &hll_sketch::get_target_type, "Returns the HLL type (4, 6, or 8) when in estimation mode")
-    .def("get_estimate", &hll_sketch::get_estimate,
-         "Estimate of the distinct count of the input stream")
-    .def("get_lower_bound", &hll_sketch::get_lower_bound, py::arg("num_std_devs"),
-         "Returns the approximate lower error bound given the specified number of standard deviations in {1, 2, 3}")
-    .def("get_upper_bound", &hll_sketch::get_upper_bound, py::arg("num_std_devs"),
-         "Returns the approximate upper error bound given the specified number of standard deviations in {1, 2, 3}")
-    .def("is_compact", &hll_sketch::is_compact,
-         "True if the sketch is compact, otherwise False")
-    .def("is_empty", &hll_sketch::is_empty,
-         "True if the sketch is empty, otherwise False")
-    .def("get_updatable_serialization_bytes", &hll_sketch::get_updatable_serialization_bytes,
-         "Returns the size of the serialized sketch")
-    .def("get_compact_serialization_bytes", &hll_sketch::get_compact_serialization_bytes,
-         "Returns the size of the serialized sketch when compressing the exception table if HLL_4")
-    .def("reset", &hll_sketch::reset,
-         "Resets the sketch to the empty state in coupon collection mode")
-    .def("update", (void (hll_sketch::*)(int64_t)) &hll_sketch::update, py::arg("datum"),
-         "Updates the sketch with the given integral value")
-    .def("update", (void (hll_sketch::*)(double)) &hll_sketch::update, py::arg("datum"),
-         "Updates the sketch with the given floating point value")
-    .def("update", (void (hll_sketch::*)(const std::string&)) &hll_sketch::update, py::arg("datum"),
-         "Updates the sketch with the given string value")
-    .def_static("get_max_updatable_serialization_bytes", &hll_sketch::get_max_updatable_serialization_bytes,
-         py::arg("lg_k"), py::arg("tgt_type"),
-         "Provides a likely upper bound on serialization size for the given parameters")
-    .def_static("get_rel_err", &hll_sketch::get_rel_err,
-         py::arg("upper_bound"), py::arg("unioned"), py::arg("lg_k"), py::arg("num_std_devs"),
-         "Returns the a priori relative error bound for the given parameters")
-    .def(
-        "serialize_compact",
-        [](const hll_sketch& sk) {
-          auto bytes = sk.serialize_compact();
-          return py::bytes(reinterpret_cast<const char*>(bytes.data()), bytes.size());
-        },
-        "Serializes the sketch into a bytes object, compressing the exception table if HLL_4"
-    )
-    .def(
-        "serialize_updatable",
-        [](const hll_sketch& sk) {
-          auto bytes = sk.serialize_updatable();
-          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 hll_sketch::deserialize(bytes.data(), bytes.size()); },
-        py::arg("bytes"),
-        "Reads a bytes object and returns the corresponding hll_sketch"
-    );
-
-  py::class_<hll_union>(m, "hll_union")
-    .def(py::init<uint8_t>(), py::arg("lg_max_k"))
-    .def_property_readonly("lg_config_k", &hll_union::get_lg_config_k, "Configured lg_k value for the union")
-    .def_property_readonly("tgt_type", &hll_union::get_target_type, "Returns the HLL type (4, 6, or 8) when in estimation mode")
-    .def("get_estimate", &hll_union::get_estimate,
-         "Estimate of the distinct count of the input stream")
-    .def("get_lower_bound", &hll_union::get_lower_bound, py::arg("num_std_devs"),
-         "Returns the approximate lower error bound given the specified number of standard deviations in {1, 2, 3}")
-    .def("get_upper_bound", &hll_union::get_upper_bound, py::arg("num_std_devs"),
-         "Returns the approximate upper error bound given the specified number of standard deviations in {1, 2, 3}")
-    .def("is_empty", &hll_union::is_empty,
-         "True if the union is empty, otherwise False")    
-    .def("reset", &hll_union::reset,
-         "Resets the union to the empty state")
-    .def("get_result", &hll_union::get_result, py::arg("tgt_type")=HLL_4,
-         "Returns a sketch of the target type representing the current union state")
-    .def<void (hll_union::*)(const hll_sketch&)>("update", &hll_union::update, py::arg("sketch"),
-         "Updates the union with the given HLL sketch")
-    .def<void (hll_union::*)(int64_t)>("update", &hll_union::update, py::arg("datum"),
-         "Updates the union with the given integral value")
-    .def<void (hll_union::*)(double)>("update", &hll_union::update, py::arg("datum"),
-         "Updates the union with the given floating point value")
-    .def<void (hll_union::*)(const std::string&)>("update", &hll_union::update, py::arg("datum"),
-         "Updates the union with the given string value")
-    .def_static("get_rel_err", &hll_union::get_rel_err,
-         py::arg("upper_bound"), py::arg("unioned"), py::arg("lg_k"), py::arg("num_std_devs"),
-         "Returns the a priori relative error bound for the given parameters")
-    ;
-}

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

@@ -1,158 +0,0 @@
-/*
- * 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 "py_object_lt.hpp"
-#include "py_object_ostream.hpp"
-#include "quantile_conditional.hpp"
-#include "kll_sketch.hpp"
-
-#include <pybind11/pybind11.h>
-#include <pybind11/stl.h>
-#include <vector>
-#include <stdexcept>
-
-namespace py = pybind11;
-
-template<typename T, typename C>
-void bind_kll_sketch(py::module &m, const char* name) {
-  using namespace datasketches;
-
-  auto kll_class = py::class_<kll_sketch<T, C>>(m, name)
-    .def(py::init<uint16_t>(), py::arg("k")=kll_constants::DEFAULT_K)
-    .def(py::init<const kll_sketch<T, C>&>())
-    .def(
-        "update",
-        static_cast<void (kll_sketch<T, C>::*)(const T&)>(&kll_sketch<T, C>::update),
-        py::arg("item"),
-        "Updates the sketch with the given value"
-    )
-    .def("merge", (void (kll_sketch<T, C>::*)(const kll_sketch<T, C>&)) &kll_sketch<T, C>::merge, py::arg("sketch"),
-        "Merges the provided sketch into this one")
-    .def("__str__", &kll_sketch<T, C>::to_string, py::arg("print_levels")=false, py::arg("print_items")=false,
-        "Produces a string summary of the sketch")
-    .def("to_string", &kll_sketch<T, C>::to_string, py::arg("print_levels")=false, py::arg("print_items")=false,
-        "Produces a string summary of the sketch")
-    .def("is_empty", &kll_sketch<T, C>::is_empty,
-        "Returns True if the sketch is empty, otherwise False")
-    .def("get_k", &kll_sketch<T, C>::get_k,
-        "Returns the configured parameter k")
-    .def("get_n", &kll_sketch<T, C>::get_n,
-        "Returns the length of the input stream")
-    .def("get_num_retained", &kll_sketch<T, C>::get_num_retained,
-        "Returns the number of retained items (samples) in the sketch")
-    .def("is_estimation_mode", &kll_sketch<T, C>::is_estimation_mode,
-        "Returns True if the sketch is in estimation mode, otherwise False")
-    .def("get_min_value", &kll_sketch<T, C>::get_min_item,
-        "Returns the minimum value from the stream. If empty, kll_floats_sketch returns nan; kll_ints_sketch throws a RuntimeError")
-    .def("get_max_value", &kll_sketch<T, C>::get_max_item,
-        "Returns the maximum value from the stream. If empty, kll_floats_sketch returns nan; kll_ints_sketch throws a RuntimeError")
-    .def("get_quantile", &kll_sketch<T, C>::get_quantile, py::arg("rank"), py::arg("inclusive")=false,
-        "Returns an approximation to the data value "
-        "associated with the given normalized rank in a hypothetical sorted "
-        "version of the input stream so far.\n"
-        "For kll_floats_sketch: if the sketch is empty this returns nan. "
-        "For kll_ints_sketch: if the sketch is empty this throws a RuntimeError.")
-    .def(
-        "get_quantiles",
-        [](const kll_sketch<T, C>& sk, const std::vector<double>& ranks, bool inclusive) {
-          return sk.get_quantiles(ranks.data(), ranks.size(), inclusive);
-        },
-        py::arg("ranks"), py::arg("inclusive")=false,
-        "This returns an array that could have been generated by using get_quantile() for each "
-        "normalized rank separately.\n"
-        "If the sketch is empty this returns an empty vector.\n"
-        "Deprecated. Will be removed in the next major version. Use get_quantile() instead."
-    )
-    .def("get_rank", &kll_sketch<T, C>::get_rank, py::arg("value"), py::arg("inclusive")=false,
-         "Returns an approximation to the normalized rank of the given value from 0 to 1, inclusive.\n"
-         "The resulting approximation has a probabilistic guarantee that can be obtained from the "
-         "get_normalized_rank_error(False) function.\n"
-         "With the parameter inclusive=true the weight of the given value is included into the rank."
-         "Otherwise the rank equals the sum of the weights of values less than the given value.\n"
-         "If the sketch is empty this returns nan.")
-    .def(
-        "get_pmf",
-        [](const kll_sketch<T, C>& sk, const std::vector<T>& split_points, bool inclusive) {
-          return sk.get_PMF(split_points.data(), split_points.size(), inclusive);
-        },
-        py::arg("split_points"), py::arg("inclusive")=false,
-        "Returns an approximation to the Probability Mass Function (PMF) of the input stream "
-        "given a set of split points (values).\n"
-        "The resulting approximations have a probabilistic guarantee that can be obtained from the "
-        "get_normalized_rank_error(True) function.\n"
-        "If the sketch is empty this returns an empty vector.\n"
-        "split_points is an array of m unique, monotonically increasing float values "
-        "that divide the real number line into m+1 consecutive disjoint intervals.\n"
-        "If the parameter inclusive=false, the definition of an 'interval' is inclusive of the left split point (or minimum value) and "
-        "exclusive of the right split point, with the exception that the last interval will include "
-        "the maximum value.\n"
-        "If the parameter inclusive=true, the definition of an 'interval' is exclusive of the left split point (or minimum value) and "
-        "inclusive of the right split point.\n"
-        "It is not necessary to include either the min or max values in these split points."
-    )
-    .def(
-        "get_cdf",
-        [](const kll_sketch<T, C>& sk, const std::vector<T>& split_points, bool inclusive) {
-          return sk.get_CDF(split_points.data(), split_points.size(), inclusive);
-        },
-        py::arg("split_points"), py::arg("inclusive")=false,
-        "Returns an approximation to the Cumulative Distribution Function (CDF), which is the "
-        "cumulative analog of the PMF, of the input stream given a set of split points (values).\n"
-        "The resulting approximations have a probabilistic guarantee that can be obtained from the "
-        "get_normalized_rank_error(True) function.\n"
-        "If the sketch is empty this returns an empty vector.\n"
-        "split_points is an array of m unique, monotonically increasing float values "
-        "that divide the real number line into m+1 consecutive disjoint intervals.\n"
-        "If the parameter inclusive=false, the definition of an 'interval' is inclusive of the left split point (or minimum value) and "
-        "exclusive of the right split point, with the exception that the last interval will include "
-        "the maximum value.\n"
-        "If the parameter inclusive=true, the definition of an 'interval' is exclusive of the left split point (or minimum value) and "
-        "inclusive of the right split point.\n"
-        "It is not necessary to include either the min or max values in these split points."
-    )
-    .def(
-        "normalized_rank_error",
-        static_cast<double (kll_sketch<T, C>::*)(bool) const>(&kll_sketch<T, C>::get_normalized_rank_error),
-         py::arg("as_pmf"),
-         "Gets the normalized rank error for this sketch.\n"
-         "If pmf is True, returns the 'double-sided' normalized rank error for the get_PMF() function.\n"
-         "Otherwise, it is the 'single-sided' normalized rank error for all the other queries.\n"
-         "Constants were derived as the best fit to 99 percentile empirically measured max error in thousands of trials"
-    )
-    .def_static(
-        "get_normalized_rank_error",
-        [](uint16_t k, bool pmf) { return kll_sketch<T, C>::get_normalized_rank_error(k, pmf); },
-         py::arg("k"), py::arg("as_pmf"),
-         "Gets the normalized rank error given parameters k and the pmf flag.\n"
-         "If pmf is True, returns the 'double-sided' normalized rank error for the get_PMF() function.\n"
-         "Otherwise, it is the 'single-sided' normalized rank error for all the other queries.\n"
-         "Constants were derived as the best fit to 99 percentile empirically measured max error in thousands of trials"
-    )
-    .def("__iter__", [](const kll_sketch<T, C>& s) { return py::make_iterator(s.begin(), s.end()); });
-
-    add_serialization<T>(kll_class);
-    add_vector_update<T>(kll_class);
-}
-
-void init_kll(py::module &m) {
-  bind_kll_sketch<int, std::less<int>>(m, "kll_ints_sketch");
-  bind_kll_sketch<float, std::less<float>>(m, "kll_floats_sketch");
-  bind_kll_sketch<double, std::less<double>>(m, "kll_doubles_sketch");
-  bind_kll_sketch<py::object, py_object_lt>(m, "kll_items_sketch");
-}

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

@@ -1,68 +0,0 @@
-/*
- * 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 "kolmogorov_smirnov.hpp"
-#include "kll_sketch.hpp"
-#include "quantiles_sketch.hpp"
-
-#include <pybind11/pybind11.h>
-
-namespace py = pybind11;
-
-void init_kolmogorov_smirnov(py::module &m) {
-  using namespace datasketches;
-
-  m.def("ks_test", &kolmogorov_smirnov::test<kll_sketch<int>>, py::arg("sk_1"), py::arg("sk_2"), py::arg("p"),
-    "Performs the Kolmogorov-Smirnov Test between kll_ints_sketches.\n"
-    "Note: if the given sketches have insufficient data or if the sketch sizes are too small, "
-    "this will return false.\n"
-    "Returns True if we can reject the null hypothesis (that the sketches reflect the same underlying "
-    "distribution) using the provided p-value, otherwise False.");
-  m.def("ks_test", &kolmogorov_smirnov::test<kll_sketch<float>>, py::arg("sk_1"), py::arg("sk_2"), py::arg("p"),
-    "Performs the Kolmogorov-Smirnov Test between kll_floats_sketches.\n"
-    "Note: if the given sketches have insufficient data or if the sketch sizes are too small, "
-    "this will return false.\n"
-    "Returns True if we can reject the null hypothesis (that the sketches reflect the same underlying "
-    "distribution) using the provided p-value, otherwise False.");
-  m.def("ks_test", &kolmogorov_smirnov::test<kll_sketch<double>>, py::arg("sk_1"), py::arg("sk_2"), py::arg("p"),
-    "Performs the Kolmogorov-Smirnov Test between kll_doubles_sketches.\n"
-    "Note: if the given sketches have insufficient data or if the sketch sizes are too small, "
-    "this will return false.\n"
-    "Returns True if we can reject the null hypothesis (that the sketches reflect the same underlying "
-    "distribution) using the provided p-value, otherwise False.");
-
-  m.def("ks_test", &kolmogorov_smirnov::test<quantiles_sketch<int>>, py::arg("sk_1"), py::arg("sk_2"), py::arg("p"),
-    "Performs the Kolmogorov-Smirnov Test between quantiles_ints_sketches.\n"
-    "Note: if the given sketches have insufficient data or if the sketch sizes are too small, "
-    "this will return false.\n"
-    "Returns True if we can reject the null hypothesis (that the sketches reflect the same underlying "
-    "distribution) using the provided p-value, otherwise False.");
-  m.def("ks_test", &kolmogorov_smirnov::test<quantiles_sketch<float>>, py::arg("sk_1"), py::arg("sk_2"), py::arg("p"),
-    "Performs the Kolmogorov-Smirnov Test between quantiles_floats_sketches.\n"
-    "Note: if the given sketches have insufficient data or if the sketch sizes are too small, "
-    "this will return false.\n"
-    "Returns True if we can reject the null hypothesis (that the sketches reflect the same underlying "
-    "distribution) using the provided p-value, otherwise False.");
-  m.def("ks_test", &kolmogorov_smirnov::test<quantiles_sketch<double>>, py::arg("sk_1"), py::arg("sk_2"), py::arg("p"),
-    "Performs the Kolmogorov-Smirnov Test between quantiles_doubles_sketches.\n"
-    "Note: if the given sketches have insufficient data or if the sketch sizes are too small, "
-    "this will return false.\n"
-    "Returns True if we can reject the null hypothesis (that the sketches reflect the same underlying "
-    "distribution) using the provided p-value, otherwise False.");
-}