blob: 6e3ae1a02a0d7fc8da8f29310b018284d814c4cd [file] [log] [blame]
/*
* 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 _TDIGEST_IMPL_HPP_
#define _TDIGEST_IMPL_HPP_
#include <algorithm>
#include <cmath>
#include <sstream>
#include "common_defs.hpp"
#include "memory_operations.hpp"
namespace datasketches {
template<typename T, typename A>
tdigest<T, A>::tdigest(uint16_t k, const A& allocator):
tdigest(false, k, std::numeric_limits<T>::infinity(), -std::numeric_limits<T>::infinity(), vector_centroid(allocator), 0, vector_t(allocator))
{}
template<typename T, typename A>
void tdigest<T, A>::update(T value) {
if (std::isnan(value)) return;
if (buffer_.size() == centroids_capacity_ * BUFFER_MULTIPLIER) compress();
buffer_.push_back(value);
min_ = std::min(min_, value);
max_ = std::max(max_, value);
}
template<typename T, typename A>
void tdigest<T, A>::merge(const tdigest& other) {
if (other.is_empty()) return;
vector_centroid tmp(buffer_.get_allocator());
tmp.reserve(buffer_.size() + centroids_.size() + other.buffer_.size() + other.centroids_.size());
for (const T value: buffer_) tmp.push_back(centroid(value, 1));
for (const T value: other.buffer_) tmp.push_back(centroid(value, 1));
std::copy(other.centroids_.begin(), other.centroids_.end(), std::back_inserter(tmp));
merge(tmp, buffer_.size() + other.get_total_weight());
}
template<typename T, typename A>
void tdigest<T, A>::compress() {
if (buffer_.size() == 0) return;
vector_centroid tmp(buffer_.get_allocator());
tmp.reserve(buffer_.size() + centroids_.size());
for (const T value: buffer_) tmp.push_back(centroid(value, 1));
merge(tmp, buffer_.size());
}
template<typename T, typename A>
bool tdigest<T, A>::is_empty() const {
return centroids_.empty() && buffer_.empty();
}
template<typename T, typename A>
T tdigest<T, A>::get_min_value() const {
if (is_empty()) throw std::runtime_error("operation is undefined for an empty sketch");
return min_;
}
template<typename T, typename A>
T tdigest<T, A>::get_max_value() const {
if (is_empty()) throw std::runtime_error("operation is undefined for an empty sketch");
return max_;
}
template<typename T, typename A>
uint64_t tdigest<T, A>::get_total_weight() const {
return centroids_weight_ + buffer_.size();
}
template<typename T, typename A>
A tdigest<T, A>::get_allocator() const {
return buffer_.get_allocator();
}
template<typename T, typename A>
double tdigest<T, A>::get_rank(T value) const {
if (is_empty()) throw std::runtime_error("operation is undefined for an empty sketch");
if (std::isnan(value)) throw std::invalid_argument("operation is undefined for NaN");
if (value < min_) return 0;
if (value > max_) return 1;
// one centroid and value == min_ == max_
if ((centroids_.size() + buffer_.size()) == 1) return 0.5;
const_cast<tdigest*>(this)->compress(); // side effect
// left tail
const T first_mean = centroids_.front().get_mean();
if (value < first_mean) {
if (first_mean - min_ > 0) {
if (value == min_) return 0.5 / centroids_weight_;
return (1.0 + (value - min_) / (first_mean - min_) * (centroids_.front().get_weight() / 2.0 - 1.0)); // ?
}
return 0; // should never happen
}
// right tail
const T last_mean = centroids_.back().get_mean();
if (value > last_mean) {
if (max_ - last_mean > 0) {
if (value == max_) return 1.0 - 0.5 / centroids_weight_;
return 1.0 - ((1.0 + (max_ - value) / (max_ - last_mean) * (centroids_.back().get_weight() / 2.0 - 1.0)) / centroids_weight_); // ?
}
return 1; // should never happen
}
auto lower = std::lower_bound(centroids_.begin(), centroids_.end(), centroid(value, 1), centroid_cmp());
if (lower == centroids_.end()) throw std::logic_error("lower == end in get_rank()");
auto upper = std::upper_bound(lower, centroids_.end(), centroid(value, 1), centroid_cmp());
if (upper == centroids_.begin()) throw std::logic_error("upper == begin in get_rank()");
if (value < lower->get_mean()) --lower;
if (upper == centroids_.end() || !((upper - 1)->get_mean() < value)) --upper;
double weight_below = 0;
auto it = centroids_.begin();
while (it != lower) {
weight_below += it->get_weight();
++it;
}
weight_below += lower->get_weight() / 2.0;
double weight_delta = 0;
while (it != upper) {
weight_delta += it->get_weight();
++it;
}
weight_delta -= lower->get_weight() / 2.0;
weight_delta += upper->get_weight() / 2.0;
if (upper->get_mean() - lower->get_mean() > 0) {
return (weight_below + weight_delta * (value - lower->get_mean()) / (upper->get_mean() - lower->get_mean())) / centroids_weight_;
}
return (weight_below + weight_delta / 2.0) / centroids_weight_;
}
template<typename T, typename A>
T tdigest<T, A>::get_quantile(double rank) const {
if (is_empty()) throw std::runtime_error("operation is undefined for an empty sketch");
if ((rank < 0.0) || (rank > 1.0)) {
throw std::invalid_argument("Normalized rank cannot be less than 0 or greater than 1");
}
const_cast<tdigest*>(this)->compress(); // side effect
if (centroids_.size() == 1) return centroids_.front().get_mean();
// at least 2 centroids
const double weight = rank * centroids_weight_;
if (weight < 1) return min_;
if (weight > centroids_weight_ - 1.0) return max_;
const double first_weight = centroids_.front().get_weight();
if (first_weight > 1 && weight < first_weight / 2.0) {
return min_ + (weight - 1.0) / (first_weight / 2.0 - 1.0) * (centroids_.front().get_mean() - min_);
}
const double last_weight = centroids_.back().get_weight();
if (last_weight > 1 && centroids_weight_ - weight <= last_weight / 2.0) {
return max_ + (centroids_weight_ - weight - 1.0) / (last_weight / 2.0 - 1.0) * (max_ - centroids_.back().get_mean());
}
// interpolate between extremes
double weight_so_far = first_weight / 2.0;
for (size_t i = 0; i < centroids_.size() - 1; ++i) {
const double dw = (centroids_[i].get_weight() + centroids_[i + 1].get_weight()) / 2.0;
if (weight_so_far + dw > weight) {
// the target weight is between centroids i and i+1
double left_weight = 0;
if (centroids_[i].get_weight() == 1) {
if (weight - weight_so_far < 0.5) return centroids_[i].get_mean();
left_weight = 0.5;
}
double right_weight = 0;
if (centroids_[i + 1].get_weight() == 1) {
if (weight_so_far + dw - weight <= 0.5) return centroids_[i + 1].get_mean();
right_weight = 0.5;
}
const double w1 = weight - weight_so_far - left_weight;
const double w2 = weight_so_far + dw - weight - right_weight;
return weighted_average(centroids_[i].get_mean(), w1, centroids_[i + 1].get_mean(), w2);
}
weight_so_far += dw;
}
const double w1 = weight - centroids_weight_ - centroids_.back().get_weight() / 2.0;
const double w2 = centroids_.back().get_weight() / 2.0 - w1;
return weighted_average(centroids_.back().get_weight(), w1, max_, w2);
}
template<typename T, typename A>
auto tdigest<T, A>::get_PMF(const T* split_points, uint32_t size) const -> vector_double {
auto buckets = get_CDF(split_points, size);
for (uint32_t i = size; i > 0; --i) {
buckets[i] -= buckets[i - 1];
}
return buckets;
}
template<typename T, typename A>
auto tdigest<T, A>::get_CDF(const T* split_points, uint32_t size) const -> vector_double {
check_split_points(split_points, size);
vector_double ranks(get_allocator());
ranks.reserve(size + 1);
for (uint32_t i = 0; i < size; ++i) ranks.push_back(get_rank(split_points[i]));
ranks.push_back(1);
return ranks;
}
template<typename T, typename A>
uint16_t tdigest<T, A>::get_k() const {
return k_;
}
template<typename T, typename A>
string<A> tdigest<T, A>::to_string(bool print_centroids) const {
// Using a temporary stream for implementation here does not comply with AllocatorAwareContainer requirements.
// The stream does not support passing an allocator instance, and alternatives are complicated.
std::ostringstream os;
os << "### t-Digest summary:" << std::endl;
os << " Nominal k : " << k_ << std::endl;
os << " Centroids : " << centroids_.size() << std::endl;
os << " Buffered : " << buffer_.size() << std::endl;
os << " Centroids capacity : " << centroids_capacity_ << std::endl;
os << " Buffer capacity : " << centroids_capacity_ * BUFFER_MULTIPLIER << std::endl;
os << " Centroids Weight : " << centroids_weight_ << std::endl;
os << " Total Weight : " << get_total_weight() << std::endl;
os << " Reverse Merge : " << (reverse_merge_ ? "true" : "false") << std::endl;
if (!is_empty()) {
os << " Min : " << min_ << std::endl;
os << " Max : " << max_ << std::endl;
}
os << "### End t-Digest summary" << std::endl;
if (print_centroids) {
if (centroids_.size() > 0) {
os << "Centroids:" << std::endl;
int i = 0;
for (const auto& c: centroids_) {
os << i++ << ": " << c.get_mean() << ", " << c.get_weight() << std::endl;
}
}
if (buffer_.size() > 0) {
os << "Buffer:" << std::endl;
int i = 0;
for (const T value: buffer_) {
os << i++ << ": " << value << std::endl;
}
}
}
return string<A>(os.str().c_str(), buffer_.get_allocator());
}
// assumes that there is enough room in the input buffer to add centroids from this tdigest
template<typename T, typename A>
void tdigest<T, A>::merge(vector_centroid& buffer, W weight) {
std::copy(centroids_.begin(), centroids_.end(), std::back_inserter(buffer));
centroids_.clear();
std::stable_sort(buffer.begin(), buffer.end(), centroid_cmp());
if (reverse_merge_) std::reverse(buffer.begin(), buffer.end());
centroids_weight_ += weight;
auto it = buffer.begin();
centroids_.push_back(*it);
++it;
double weight_so_far = 0;
while (it != buffer.end()) {
const double proposed_weight = centroids_.back().get_weight() + it->get_weight();
bool add_this = false;
if (std::distance(buffer.begin(), it) != 1 && std::distance(buffer.end(), it) != 1) {
const double q0 = weight_so_far / centroids_weight_;
const double q2 = (weight_so_far + proposed_weight) / centroids_weight_;
const double normalizer = scale_function().normalizer(2 * k_, centroids_weight_);
add_this = proposed_weight <= centroids_weight_ * std::min(scale_function().max(q0, normalizer), scale_function().max(q2, normalizer));
}
if (add_this) {
centroids_.back().add(*it);
} else {
weight_so_far += centroids_.back().get_weight();
centroids_.push_back(*it);
}
++it;
}
if (reverse_merge_) std::reverse(centroids_.begin(), centroids_.end());
min_ = std::min(min_, centroids_.front().get_mean());
max_ = std::max(max_, centroids_.back().get_mean());
reverse_merge_ = !reverse_merge_;
buffer_.clear();
}
template<typename T, typename A>
double tdigest<T, A>::weighted_average(double x1, double w1, double x2, double w2) {
return (x1 * w1 + x2 * w2) / (w1 + w2);
}
template<typename T, typename A>
void tdigest<T, A>::serialize(std::ostream& os, bool with_buffer) const {
if (!with_buffer) const_cast<tdigest*>(this)->compress(); // side effect
write(os, get_preamble_longs());
write(os, SERIAL_VERSION);
write(os, SKETCH_TYPE);
write(os, k_);
const uint8_t flags_byte(
(is_empty() ? 1 << flags::IS_EMPTY : 0)
| (is_single_value() ? 1 << flags::IS_SINGLE_VALUE : 0)
| (reverse_merge_ ? 1 << flags::REVERSE_MERGE : 0)
);
write(os, flags_byte);
write<uint16_t>(os, 0); // unused
if (is_empty()) return;
if (is_single_value()) {
write(os, min_);
return;
}
write(os, static_cast<uint32_t>(centroids_.size()));
write(os, static_cast<uint32_t>(buffer_.size()));
write(os, min_);
write(os, max_);
if (centroids_.size() > 0) write(os, centroids_.data(), centroids_.size() * sizeof(centroid));
if (buffer_.size() > 0) write(os, buffer_.data(), buffer_.size() * sizeof(T));
}
template<typename T, typename A>
uint8_t tdigest<T, A>::get_preamble_longs() const {
return is_empty() || is_single_value() ? PREAMBLE_LONGS_EMPTY_OR_SINGLE : PREAMBLE_LONGS_MULTIPLE;
}
template<typename T, typename A>
size_t tdigest<T, A>::get_serialized_size_bytes(bool with_buffer) const {
if (!with_buffer) const_cast<tdigest*>(this)->compress(); // side effect
size_t size_bytes = get_preamble_longs() * sizeof(uint64_t);
if (is_empty()) return size_bytes;
if (is_single_value()) return size_bytes + sizeof(T);
size_bytes += sizeof(T) * 2 // min and max
+ sizeof(centroid) * centroids_.size();
if (with_buffer) size_bytes += sizeof(T) * buffer_.size(); // count is a part of preamble
return size_bytes;
}
template<typename T, typename A>
auto tdigest<T, A>::serialize(unsigned header_size_bytes, bool with_buffer) const -> vector_bytes {
if (!with_buffer) const_cast<tdigest*>(this)->compress(); // side effect
vector_bytes bytes(get_serialized_size_bytes(with_buffer), 0, buffer_.get_allocator());
uint8_t* ptr = bytes.data() + header_size_bytes;
*ptr++ = get_preamble_longs();
*ptr++ = SERIAL_VERSION;
*ptr++ = SKETCH_TYPE;
ptr += copy_to_mem(k_, ptr);
const uint8_t flags_byte(
(is_empty() ? 1 << flags::IS_EMPTY : 0)
| (is_single_value() ? 1 << flags::IS_SINGLE_VALUE : 0)
| (reverse_merge_ ? 1 << flags::REVERSE_MERGE : 0)
);
*ptr++ = flags_byte;
ptr += 2; // unused
if (is_empty()) return bytes;
if (is_single_value()) {
copy_to_mem(min_, ptr);
return bytes;
}
ptr += copy_to_mem(static_cast<uint32_t>(centroids_.size()), ptr);
ptr += copy_to_mem(static_cast<uint32_t>(buffer_.size()), ptr);
ptr += copy_to_mem(min_, ptr);
ptr += copy_to_mem(max_, ptr);
if (centroids_.size() > 0) ptr += copy_to_mem(centroids_.data(), ptr, centroids_.size() * sizeof(centroid));
if (buffer_.size() > 0) copy_to_mem(buffer_.data(), ptr, buffer_.size() * sizeof(T));
return bytes;
}
template<typename T, typename A>
tdigest<T, A> tdigest<T, A>::deserialize(std::istream& is, const A& allocator) {
const auto preamble_longs = read<uint8_t>(is);
const auto serial_version = read<uint8_t>(is);
const auto sketch_type = read<uint8_t>(is);
if (sketch_type != SKETCH_TYPE) {
if (preamble_longs == 0 && serial_version == 0 && sketch_type == 0) return deserialize_compat(is, allocator);
throw std::invalid_argument("sketch type mismatch: expected " + std::to_string(SKETCH_TYPE) + ", actual " + std::to_string(sketch_type));
}
if (serial_version != SERIAL_VERSION) {
throw std::invalid_argument("serial version mismatch: expected " + std::to_string(SERIAL_VERSION) + ", actual " + std::to_string(serial_version));
}
const auto k = read<uint16_t>(is);
const auto flags_byte = read<uint8_t>(is);
const bool is_empty = flags_byte & (1 << flags::IS_EMPTY);
const bool is_single_value = flags_byte & (1 << flags::IS_SINGLE_VALUE);
const uint8_t expected_preamble_longs = is_empty || is_single_value ? PREAMBLE_LONGS_EMPTY_OR_SINGLE : PREAMBLE_LONGS_MULTIPLE;
if (preamble_longs != expected_preamble_longs) {
throw std::invalid_argument("preamble longs mismatch: expected " + std::to_string(expected_preamble_longs) + ", actual " + std::to_string(preamble_longs));
}
read<uint16_t>(is); // unused
if (is_empty) return tdigest(k, allocator);
const bool reverse_merge = flags_byte & (1 << flags::REVERSE_MERGE);
if (is_single_value) {
const T value = read<T>(is);
return tdigest(reverse_merge, k, value, value, vector_centroid(1, centroid(value, 1), allocator), 1, vector_t(allocator));
}
const auto num_centroids = read<uint32_t>(is);
const auto num_buffered = read<uint32_t>(is);
const T min = read<T>(is);
const T max = read<T>(is);
vector_centroid centroids(num_centroids, centroid(0, 0), allocator);
if (num_centroids > 0) read(is, centroids.data(), num_centroids * sizeof(centroid));
vector_t buffer(num_buffered, 0, allocator);
if (num_buffered > 0) read(is, buffer.data(), num_buffered * sizeof(T));
uint64_t weight = 0;
for (const auto& c: centroids) weight += c.get_weight();
return tdigest(reverse_merge, k, min, max, std::move(centroids), weight, std::move(buffer));
}
template<typename T, typename A>
tdigest<T, A> tdigest<T, A>::deserialize(const void* bytes, size_t size, const A& allocator) {
ensure_minimum_memory(size, 8);
const char* ptr = static_cast<const char*>(bytes);
const char* end_ptr = static_cast<const char*>(bytes) + size;
const uint8_t preamble_longs = *ptr++;
const uint8_t serial_version = *ptr++;
const uint8_t sketch_type = *ptr++;
if (sketch_type != SKETCH_TYPE) {
if (preamble_longs == 0 && serial_version == 0 && sketch_type == 0) return deserialize_compat(ptr, end_ptr - ptr, allocator);
throw std::invalid_argument("sketch type mismatch: expected " + std::to_string(SKETCH_TYPE) + ", actual " + std::to_string(sketch_type));
}
if (serial_version != SERIAL_VERSION) {
throw std::invalid_argument("serial version mismatch: expected " + std::to_string(SERIAL_VERSION) + ", actual " + std::to_string(serial_version));
}
uint16_t k;
ptr += copy_from_mem(ptr, k);
const uint8_t flags_byte = *ptr++;
const bool is_empty = flags_byte & (1 << flags::IS_EMPTY);
const bool is_single_value = flags_byte & (1 << flags::IS_SINGLE_VALUE);
const uint8_t expected_preamble_longs = is_empty || is_single_value ? PREAMBLE_LONGS_EMPTY_OR_SINGLE : PREAMBLE_LONGS_MULTIPLE;
if (preamble_longs != expected_preamble_longs) {
throw std::invalid_argument("preamble longs mismatch: expected " + std::to_string(expected_preamble_longs) + ", actual " + std::to_string(preamble_longs));
}
ptr += 2; // unused
if (is_empty) return tdigest(k, allocator);
const bool reverse_merge = flags_byte & (1 << flags::REVERSE_MERGE);
if (is_single_value) {
ensure_minimum_memory(end_ptr - ptr, sizeof(T));
T value;
ptr += copy_from_mem(ptr, value);
return tdigest(reverse_merge, k, value, value, vector_centroid(1, centroid(value, 1), allocator), 1, vector_t(allocator));
}
ensure_minimum_memory(end_ptr - ptr, 8);
uint32_t num_centroids;
ptr += copy_from_mem(ptr, num_centroids);
uint32_t num_buffered;
ptr += copy_from_mem(ptr, num_buffered);
ensure_minimum_memory(end_ptr - ptr, sizeof(T) * 2 + sizeof(centroid) * num_centroids + sizeof(T) * num_buffered);
T min;
ptr += copy_from_mem(ptr, min);
T max;
ptr += copy_from_mem(ptr, max);
vector_centroid centroids(num_centroids, centroid(0, 0), allocator);
if (num_centroids > 0) ptr += copy_from_mem(ptr, centroids.data(), num_centroids * sizeof(centroid));
vector_t buffer(num_buffered, 0, allocator);
if (num_buffered > 0) copy_from_mem(ptr, buffer.data(), num_buffered * sizeof(T));
uint64_t weight = 0;
for (const auto& c: centroids) weight += c.get_weight();
return tdigest(reverse_merge, k, min, max, std::move(centroids), weight, std::move(buffer));
}
// compatibility with the format of the reference implementation
// default byte order of ByteBuffer is used there, which is big endian
template<typename T, typename A>
tdigest<T, A> tdigest<T, A>::deserialize_compat(std::istream& is, const A& allocator) {
// this method was called because the first three bytes were zeros
// so read one more byte to see if it looks like the reference implementation format
const auto type = read<uint8_t>(is);
if (type != COMPAT_DOUBLE && type != COMPAT_FLOAT) {
throw std::invalid_argument("unexpected sketch preamble: 0 0 0 " + std::to_string(type));
}
if (type == COMPAT_DOUBLE) { // compatibility with asBytes()
const auto min = read_big_endian<double>(is);
const auto max = read_big_endian<double>(is);
const auto k = static_cast<uint16_t>(read_big_endian<double>(is));
const auto num_centroids = read_big_endian<uint32_t>(is);
vector_centroid centroids(num_centroids, centroid(0, 0), allocator);
uint64_t total_weight = 0;
for (auto& c: centroids) {
const W weight = static_cast<W>(read_big_endian<double>(is));
const auto mean = read_big_endian<double>(is);
c = centroid(mean, weight);
total_weight += weight;
}
return tdigest(false, k, min, max, std::move(centroids), total_weight, vector_t(allocator));
}
// COMPAT_FLOAT: compatibility with asSmallBytes()
const auto min = read_big_endian<double>(is); // reference implementation uses doubles for min and max
const auto max = read_big_endian<double>(is);
const auto k = static_cast<uint16_t>(read_big_endian<float>(is));
// reference implementation stores capacities of the array of centroids and the buffer as shorts
// they can be derived from k in the constructor
read<uint32_t>(is); // unused
const auto num_centroids = read_big_endian<uint16_t>(is);
vector_centroid centroids(num_centroids, centroid(0, 0), allocator);
uint64_t total_weight = 0;
for (auto& c: centroids) {
const W weight = static_cast<W>(read_big_endian<float>(is));
const auto mean = read_big_endian<float>(is);
c = centroid(mean, weight);
total_weight += weight;
}
return tdigest(false, k, min, max, std::move(centroids), total_weight, vector_t(allocator));
}
// compatibility with the format of the reference implementation
// default byte order of ByteBuffer is used there, which is big endian
template<typename T, typename A>
tdigest<T, A> tdigest<T, A>::deserialize_compat(const void* bytes, size_t size, const A& allocator) {
const char* ptr = static_cast<const char*>(bytes);
// this method was called because the first three bytes were zeros
// so read one more byte to see if it looks like the reference implementation format
const auto type = *ptr++;
if (type != COMPAT_DOUBLE && type != COMPAT_FLOAT) {
throw std::invalid_argument("unexpected sketch preamble: 0 0 0 " + std::to_string(type));
}
const char* end_ptr = static_cast<const char*>(bytes) + size;
if (type == COMPAT_DOUBLE) { // compatibility with asBytes()
ensure_minimum_memory(end_ptr - ptr, sizeof(double) * 3 + sizeof(uint32_t));
double min;
ptr += copy_from_mem(ptr, min);
min = byteswap(min);
double max;
ptr += copy_from_mem(ptr, max);
max = byteswap(max);
double k_double;
ptr += copy_from_mem(ptr, k_double);
const uint16_t k = static_cast<uint16_t>(byteswap(k_double));
uint32_t num_centroids;
ptr += copy_from_mem(ptr, num_centroids);
num_centroids = byteswap(num_centroids);
ensure_minimum_memory(end_ptr - ptr, sizeof(double) * num_centroids * 2);
vector_centroid centroids(num_centroids, centroid(0, 0), allocator);
uint64_t total_weight = 0;
for (auto& c: centroids) {
double weight;
ptr += copy_from_mem(ptr, weight);
weight = byteswap(weight);
double mean;
ptr += copy_from_mem(ptr, mean);
mean = byteswap(mean);
c = centroid(mean, static_cast<W>(weight));
total_weight += static_cast<uint64_t>(weight);
}
return tdigest(false, k, min, max, std::move(centroids), total_weight, vector_t(allocator));
}
// COMPAT_FLOAT: compatibility with asSmallBytes()
ensure_minimum_memory(end_ptr - ptr, sizeof(double) * 2 + sizeof(float) + sizeof(uint16_t) * 3);
double min; // reference implementation uses doubles for min and max
ptr += copy_from_mem(ptr, min);
min = byteswap(min);
double max;
ptr += copy_from_mem(ptr, max);
max = byteswap(max);
float k_float;
ptr += copy_from_mem(ptr, k_float);
const uint16_t k = static_cast<uint16_t>(byteswap(k_float));
// reference implementation stores capacities of the array of centroids and the buffer as shorts
// they can be derived from k in the constructor
ptr += sizeof(uint32_t); // unused
uint16_t num_centroids;
ptr += copy_from_mem(ptr, num_centroids);
num_centroids = byteswap(num_centroids);
ensure_minimum_memory(end_ptr - ptr, sizeof(float) * num_centroids * 2);
vector_centroid centroids(num_centroids, centroid(0, 0), allocator);
uint64_t total_weight = 0;
for (auto& c: centroids) {
float weight;
ptr += copy_from_mem(ptr, weight);
weight = byteswap(weight);
float mean;
ptr += copy_from_mem(ptr, mean);
mean = byteswap(mean);
c = centroid(mean, static_cast<W>(weight));
total_weight += static_cast<uint64_t>(weight);
}
return tdigest(false, k, min, max, std::move(centroids), total_weight, vector_t(allocator));
}
template<typename T, typename A>
bool tdigest<T, A>::is_single_value() const {
return get_total_weight() == 1;
}
template<typename T, typename A>
tdigest<T, A>::tdigest(bool reverse_merge, uint16_t k, T min, T max, vector_centroid&& centroids, uint64_t weight, vector_t&& buffer):
reverse_merge_(reverse_merge),
k_(k),
min_(min),
max_(max),
centroids_capacity_(0),
centroids_(std::move(centroids)),
centroids_weight_(weight),
buffer_(std::move(buffer))
{
if (k < 10) throw std::invalid_argument("k must be at least 10");
const size_t fudge = k < 30 ? 30 : 10;
centroids_capacity_ = 2 * k_ + fudge;
centroids_.reserve(centroids_capacity_);
buffer_.reserve(centroids_capacity_ * BUFFER_MULTIPLIER);
}
template<typename T, typename A>
void tdigest<T, A>::check_split_points(const T* values, uint32_t size) {
for (uint32_t i = 0; i < size ; i++) {
if (std::isnan(values[i])) {
throw std::invalid_argument("Values must not be NaN");
}
if ((i < (size - 1)) && !(values[i] < values[i + 1])) {
throw std::invalid_argument("Values must be unique and monotonically increasing");
}
}
}
} /* namespace datasketches */
#endif // _TDIGEST_IMPL_HPP_