quantile::detail::TDigest< RealType, IndexType > Class Template Reference

#include <quantile.h>

Collaboration diagram for quantile::detail::TDigest< RealType, IndexType >:

Public Types
using	Memory = CentroidsMemory< RealType, IndexType >

Public Member Functions
	TDigest ()=default
DEVICE	TDigest (Memory &mem)
DEVICE	TDigest (RealType q, SimpleAllocator *simple_allocator, IndexType buf_allocate, IndexType centroids_allocate)
TDigest &	operator= (TDigest &&rhs)
DEVICE Centroids< RealType, IndexType > &	centroids ()
DEVICE void	add (RealType value)
DEVICE void	allocate ()
DEVICE void	mergeBuffer ()
DEVICE void	mergeBufferFinal ()
DEVICE void	mergeSorted (RealType *sums, IndexType *counts, IndexType size)
DEVICE void	mergeTDigest (TDigest &t_digest)
DEVICE VectorView< IndexType const >	partialSumOfCounts (IndexType *const buf) const
DEVICE RealType	quantile (VectorView< IndexType const > const partial_sum, RealType const q) const
DEVICE RealType	quantile (RealType const q) const
DEVICE RealType	quantile ()
DEVICE void	setBuffer (Memory &mem)
DEVICE void	setCentroids (Memory &mem)
DEVICE void	setCentroids (VectorView< RealType > const sums, VectorView< IndexType > const counts)
DEVICE IndexType	totalWeight () const

Static Public Member Functions
static IndexType	nbytes (IndexType buf_allocate, IndexType centroids_allocate)

Private Member Functions
DEVICE RealType	max () const
DEVICE RealType	min () const
DEVICE IndexType	maxCardinality (IndexType const sum, IndexType const total_weight, RealType const c)
DEVICE void	mergeCentroids (Centroids< RealType, IndexType > &)
DEVICE RealType	firstCentroid (RealType const x) const
DEVICE RealType	interiorCentroid (RealType const x, IndexType const idx1, IndexType const prefix_sum) const
DEVICE RealType	lastCentroid (RealType const x, IndexType const N) const
DEVICE RealType	oneCentroid (RealType const x) const
DEVICE RealType	slope (IndexType const idx1, IndexType const idx2) const

Private Attributes
Centroids< RealType, IndexType >	buf_
Centroids< RealType, IndexType >	centroids_
bool	forward_ {true}
std::mutex	merge_buffer_final_called_mutex_
bool	merge_buffer_final_called_ {false}
std::optional< RealType >	q_ {std::nullopt}
bool	use_linear_scaling_function_ {false}
SimpleAllocator *	simple_allocator_ {nullptr}
IndexType	buf_allocate_ {0}
IndexType	centroids_allocate_ {0}

Detailed Description

template<typename RealType, typename IndexType = size_t>
class quantile::detail::TDigest< RealType, IndexType >

Definition at line 184 of file quantile.h.

Member Typedef Documentation

template<typename RealType , typename IndexType = size_t>

using quantile::detail::TDigest< RealType, IndexType >::Memory = CentroidsMemory<RealType, IndexType>

Definition at line 227 of file quantile.h.

Constructor & Destructor Documentation

template<typename RealType , typename IndexType = size_t>

quantile::detail::TDigest< RealType, IndexType >::TDigest ( )

default

template<typename RealType , typename IndexType = size_t>

DEVICE quantile::detail::TDigest< RealType, IndexType >::TDigest ( Memory &  mem )

inline

Definition at line 231 of file quantile.h.

References quantile::detail::TDigest< RealType, IndexType >::centroids_.

      : centroids_(mem.sums().data(), mem.counts().data(), mem.size()) {
    centroids_.clear();
  }

template<typename RealType , typename IndexType = size_t>

DEVICE quantile::detail::TDigest< RealType, IndexType >::TDigest ( RealType  q, SimpleAllocator *  simple_allocator, IndexType  buf_allocate, IndexType  centroids_allocate  )

inline

Definition at line 236 of file quantile.h.

      : q_(q)
      , use_linear_scaling_function_(q_ && 0.1 <= *q_ && *q_ <= 0.9)
      , simple_allocator_(simple_allocator)
      , buf_allocate_(buf_allocate)
      , centroids_allocate_(centroids_allocate) {}

Member Function Documentation

template<typename RealType , typename IndexType >

DEVICE void quantile::detail::TDigest< RealType, IndexType >::add

(

RealType

value

)

Definition at line 623 of file quantile.h.

                                                            {
  if (buf_.sums_.full()) {
    mergeBuffer();
  }
  buf_.sums_.push_back(value);
  buf_.counts_.push_back(1);
}

template<typename RealType , typename IndexType >

DEVICE void quantile::detail::TDigest< RealType, IndexType >::allocate

(

)

Definition at line 633 of file quantile.h.

Referenced by agg_approx_quantile().

                                                   {
  if (buf_.capacity() == 0) {
    auto* p0 = simple_allocator_->allocate(buf_allocate_ * sizeof(RealType));
    auto* p1 = simple_allocator_->allocate(buf_allocate_ * sizeof(IndexType));
    buf_ = Centroids<RealType, IndexType>(
        VectorView<RealType>(reinterpret_cast<RealType*>(p0), 0, buf_allocate_),
        VectorView<IndexType>(reinterpret_cast<IndexType*>(p1), 0, buf_allocate_));
    p0 = simple_allocator_->allocate(centroids_allocate_ * sizeof(RealType));
    p1 = simple_allocator_->allocate(centroids_allocate_ * sizeof(IndexType));
    centroids_ = Centroids<RealType, IndexType>(
        VectorView<RealType>(reinterpret_cast<RealType*>(p0), 0, centroids_allocate_),
        VectorView<IndexType>(reinterpret_cast<IndexType*>(p1), 0, centroids_allocate_));
  }
}

Here is the caller graph for this function:

template<typename RealType , typename IndexType = size_t>

DEVICE Centroids<RealType, IndexType>& quantile::detail::TDigest< RealType, IndexType >::centroids ( )

inline

Definition at line 265 of file quantile.h.

References quantile::detail::TDigest< RealType, IndexType >::centroids_.

                                                     {
    return centroids_;
  }

template<typename RealType , typename IndexType >

DEVICE RealType quantile::detail::TDigest< RealType, IndexType >::firstCentroid ( RealType const  x ) const

private

Definition at line 749 of file quantile.h.

                                                                                  {
  if (x < 1) {
    return min();
  } else if (centroids_.size() == 1) {
    return oneCentroid(x);
  } else if (centroids_.counts_.front() == 2) {
    RealType const sum = centroids_.sums_.front();
    return x == 1 ? 0.5 * sum : sum - min();
  } else {
    RealType const count = centroids_.counts_.front();
    RealType const dx = x - RealType(0.5) * (1 + count);
    RealType const mean = (centroids_.sums_.front() - min()) / (count - 1);
    return mean + slope(0, 0 < dx) * dx;
  }
}

template<typename RealType , typename IndexType >

DEVICE RealType quantile::detail::TDigest< RealType, IndexType >::interiorCentroid ( RealType const  x, IndexType const  idx1, IndexType const  prefix_sum  ) const

private

Definition at line 768 of file quantile.h.

References quantile::detail::anonymous_namespace{quantile.h}::isSingleton().

                                                                                 {
  if (isSingleton(centroids_.counts_.begin() + idx1)) {
    RealType const sum1 = centroids_.sums_[idx1];
    if (x == prefix_sum - centroids_.counts_[idx1]) {
      if (isSingleton(centroids_.counts_.begin() + idx1 - 1)) {
        return 0.5 * (centroids_.sums_[idx1 - 1] + sum1);
      } else if (idx1 == 1 && centroids_.counts_[0] == 2) {
        return 0.5 * (centroids_.sums_[idx1 - 1] - min() + sum1);
      }
    }
    return sum1;
  } else {
    RealType const dx = x + RealType(0.5) * centroids_.counts_[idx1] - prefix_sum;
    IndexType const idx2 = idx1 + 2 * (0 < dx) - 1;
    return centroids_.mean(idx1) + slope(idx1, idx2) * dx;
  }
}

Here is the call graph for this function:

template<typename RealType , typename IndexType >

DEVICE RealType quantile::detail::TDigest< RealType, IndexType >::lastCentroid ( RealType const  x, IndexType const  N  ) const

private

Definition at line 790 of file quantile.h.

References quantile::detail::anonymous_namespace{quantile.h}::isSingleton().

                                                                                    {
  if (N - 1 < x) {
    return max();
  }
  IndexType const idx1 = centroids_.size() - 1;
  RealType const sum1 = centroids_.sums_[idx1];
  IndexType const count1 = centroids_.counts_[idx1];
  if (count1 == 1) {  // => x == N - 1
    if (isSingleton(centroids_.counts_.begin() + (idx1 - 1))) {
      return 0.5 * (centroids_.sums_[idx1 - 1] + sum1);
    } else if (idx1 == 1 && centroids_.counts_[0] == 2) {
      return 0.5 * (centroids_.sums_[idx1 - 1] - min() + sum1);
    } else {
      return sum1;
    }
  } else if (count1 == 2) {  // => 3 <= N
    if (x == N - 1) {
      return 0.5 * sum1;
    } else if (x == N - 2) {
      RealType const sum2 = centroids_.sums_[idx1 - 1];
      if (isSingleton(centroids_.counts_.begin() + (idx1 - 1))) {
        return 0.5 * (sum2 + sum1 - max());
      } else if (idx1 == 1 && centroids_.counts_[0] == 2) {
        return 0.5 * (sum2 - min() + sum1 - max());
      }
    }
    return sum1 - max();
  } else {  // => 3 <= count1
    RealType const dx = x + RealType(0.5) * (count1 + 1) - N;
    RealType const mean = (sum1 - max()) / (count1 - 1);
    return mean + slope(idx1, idx1 - (dx < 0)) * dx;
  }
}

Here is the call graph for this function:

template<typename RealType , typename IndexType = size_t>

DEVICE RealType quantile::detail::TDigest< RealType, IndexType >::max ( ) const

inlineprivate

Definition at line 203 of file quantile.h.

References quantile::detail::TDigest< RealType, IndexType >::centroids_.

                              {
    return centroids_.max_;
  }

template<typename RealType , typename IndexType >

DEVICE IndexType quantile::detail::TDigest< RealType, IndexType >::maxCardinality ( IndexType const  sum, IndexType const  total_weight, RealType const  c  )

private

Definition at line 651 of file quantile.h.

                                                               {
  IndexType const max_bins = centroids_.capacity();  // "compression parameter" delta
  if (total_weight <= max_bins) {
    return 0;
  } else if (use_linear_scaling_function_) {
    // Whitepaper scaling function k=0.
    return 2 * total_weight / max_bins;
  } else {
    // Whitepaper scaling function k=1.
    RealType const x = 2.0 * sum / total_weight - 1;  // = 2 q_{i-1} - 1
    RealType const f_inv = 0.5 + 0.5 * std::sin(c + std::asin(x));
    constexpr RealType eps = 1e-5;  // round-off epsilon for floor().
    IndexType const dsum = static_cast<IndexType>(total_weight * f_inv + eps);
    return dsum < sum ? 0 : dsum - sum;
  }
}

template<typename RealType , typename IndexType >

DEVICE void quantile::detail::TDigest< RealType, IndexType >::mergeBuffer

(

)

Definition at line 672 of file quantile.h.

References gpu_enabled::sort().

Referenced by quantile::detail::TDigest< RealType, IndexType >::mergeTDigest().

                                                      {
  if (buf_.size()) {
    gpu_enabled::sort(buf_.sums_.begin(), buf_.sums_.end());
    buf_.min_ = buf_.sums_.front();
    buf_.max_ = buf_.sums_.back();
    mergeCentroids(buf_);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename RealType , typename IndexType >

DEVICE void quantile::detail::TDigest< RealType, IndexType >::mergeBufferFinal

(

)

Definition at line 683 of file quantile.h.

Referenced by ResultSet::calculateQuantile().

                                                           {
#ifndef __CUDACC__
  std::lock_guard<std::mutex> lock_guard(merge_buffer_final_called_mutex_);
#endif
  if (!merge_buffer_final_called_) {
    mergeBuffer();
    assert(centroids_.size() <= buf_.capacity());
    partialSumOfCounts(buf_.counts_.data());
    merge_buffer_final_called_ = true;
  }
}

Here is the caller graph for this function:

template<typename RealType , typename IndexType >

DEVICE void quantile::detail::TDigest< RealType, IndexType >::mergeCentroids ( Centroids< RealType, IndexType > &  buf )

private

Definition at line 719 of file quantile.h.

References quantile::detail::Centroids< RealType, IndexType >::clear(), and quantile::detail::CentroidsMerger< RealType, IndexType >::merge().

Referenced by quantile::detail::TDigest< RealType, IndexType >::mergeTDigest().

                                         {
  constexpr RealType two_pi = 6.283185307179586476925286766559005768e+00;
  // Hoisted constant used in maxCardinality().
  RealType const c = two_pi / centroids_.capacity();
  // Loop over sorted sequence of buf and centroids_.
  // Some latter centroids may be merged into the current centroid, so the number
  // of iterations is only at most equal to the number of initial centroids.
  using CM = CentroidsMerger<RealType, IndexType>;
  for (CM cm(&buf, &centroids_, forward_); cm.hasNext(); cm.next()) {
    // cm.prefixSum() == 0 on first iteration.
    // Max cardinality for current centroid to be fully merged based on scaling function.
    IndexType const max_cardinality = maxCardinality(cm.prefixSum(), cm.totalWeight(), c);
    cm.merge(max_cardinality);
  }
  // Combine sorted centroids buf[0..curr_idx_] + centroids_[0..curr_idx_] if forward
  centroids_.appendAndSortCurrent(buf);
  buf.clear();
  forward_ ^= true;  // alternate merge direction on each call
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename RealType , typename IndexType >

DEVICE void quantile::detail::TDigest< RealType, IndexType >::mergeSorted	(	RealType *	sums,
		IndexType *	counts,
		IndexType	size
	)

Definition at line 696 of file quantile.h.

References gpu_enabled::fill(), VectorView< T >::set(), and quantile::detail::Centroids< RealType, IndexType >::sums_.

                                                                      {
  if (size) {
    if (buf_.capacity() == 0) {
      buf_ = Centroids<RealType, IndexType>(sums, counts, size);  // Set capacity and size
    } else {
      buf_.sums_.set(sums, size);  // Does not change capacity
      buf_.counts_.set(counts, size);
    }
    gpu_enabled::fill(buf_.counts_.begin(), buf_.counts_.end(), IndexType(1));
    buf_.min_ = buf_.sums_.front();
    buf_.max_ = buf_.sums_.back();
    mergeCentroids(buf_);
  }
}

Here is the call graph for this function:

template<typename RealType , typename IndexType = size_t>

DEVICE void quantile::detail::TDigest< RealType, IndexType >::mergeTDigest ( TDigest< RealType, IndexType > &  t_digest )

inline

Definition at line 283 of file quantile.h.

References quantile::detail::TDigest< RealType, IndexType >::centroids_, quantile::detail::TDigest< RealType, IndexType >::mergeBuffer(), and quantile::detail::TDigest< RealType, IndexType >::mergeCentroids().

                                              {
    mergeBuffer();
    t_digest.mergeBuffer();
    mergeCentroids(t_digest.centroids_);
  }

Here is the call graph for this function:

template<typename RealType , typename IndexType = size_t>

DEVICE RealType quantile::detail::TDigest< RealType, IndexType >::min ( ) const

inlineprivate

Definition at line 206 of file quantile.h.

References quantile::detail::TDigest< RealType, IndexType >::centroids_.

                              {
    return centroids_.min_;
  }

template<typename RealType , typename IndexType = size_t>

static IndexType quantile::detail::TDigest< RealType, IndexType >::nbytes ( IndexType  buf_allocate, IndexType  centroids_allocate  )

inlinestatic

Definition at line 261 of file quantile.h.

Referenced by anonymous_namespace{QueryMemoryInitializer.cpp}::AddNbytes::operator()().

                                                                                {
    return (buf_allocate + centroids_allocate) * (sizeof(RealType) + sizeof(IndexType));
  }

Here is the caller graph for this function:

template<typename RealType , typename IndexType >

DEVICE RealType quantile::detail::TDigest< RealType, IndexType >::oneCentroid ( RealType const  x ) const

private

Definition at line 827 of file quantile.h.

References anonymous_namespace{Utm.h}::N.

                                                                                {
  IndexType const N = centroids_.counts_.front();
  if (N - 1 < x) {  // includes case N == 1
    return max();
  } else if (N == 2) {  // x == 1
    return 0.5 * centroids_.sums_.front();
  } else if (N == 3) {  // 1 <= x <= 2
    if (x == 2) {
      return 0.5 * (centroids_.sums_.front() - min());
    } else {
      RealType const s = centroids_.sums_.front() - max();
      return x == 1 ? 0.5 * s : s - min();
    }
  } else {  // 3 < N
    RealType const dx = x - RealType(0.5) * N;
    RealType const mean = (centroids_.sums_.front() - (min() + max())) / (N - 2);
    RealType const slope = 2 * (0 < dx ? max() - mean : mean - min()) / (N - 2);
    return mean + slope * dx;
  }
}

template<typename RealType , typename IndexType = size_t>

TDigest& quantile::detail::TDigest< RealType, IndexType >::operator= ( TDigest< RealType, IndexType > &&  rhs )

inline

Definition at line 247 of file quantile.h.

References quantile::detail::TDigest< RealType, IndexType >::buf_, quantile::detail::TDigest< RealType, IndexType >::buf_allocate_, quantile::detail::TDigest< RealType, IndexType >::centroids_, quantile::detail::TDigest< RealType, IndexType >::centroids_allocate_, quantile::detail::TDigest< RealType, IndexType >::forward_, quantile::detail::TDigest< RealType, IndexType >::merge_buffer_final_called_, quantile::detail::TDigest< RealType, IndexType >::q_, quantile::detail::TDigest< RealType, IndexType >::simple_allocator_, and quantile::detail::TDigest< RealType, IndexType >::use_linear_scaling_function_.

                                    {
    buf_ = std::move(rhs.buf_);
    centroids_ = std::move(rhs.centroids_);
    forward_ = std::move(rhs.forward_);
    merge_buffer_final_called_ = std::move(rhs.merge_buffer_final_called_);
    q_ = std::move(rhs.q_);
    use_linear_scaling_function_ = std::move(rhs.use_linear_scaling_function_);
    simple_allocator_ = std::move(rhs.simple_allocator_);
    buf_allocate_ = std::move(rhs.buf_allocate_);
    centroids_allocate_ = std::move(rhs.centroids_allocate_);
    return *this;
  }

template<typename RealType , typename IndexType >

DEVICE VectorView< IndexType const > quantile::detail::TDigest< RealType, IndexType >::partialSumOfCounts

(

IndexType *const

buf

)

const

Definition at line 850 of file quantile.h.

References gpu_enabled::partial_sum().

                                {
  gpu_enabled::partial_sum(centroids_.counts_.begin(), centroids_.counts_.end(), buf);
  return {buf, centroids_.size()};
}

Here is the call graph for this function:

template<typename RealType , typename IndexType >

DEVICE RealType quantile::detail::TDigest< RealType, IndexType >::quantile	(	VectorView< IndexType const > const	partial_sum,
		RealType const	q
	)		const

Definition at line 858 of file quantile.h.

References VectorView< T >::back(), VectorView< T >::begin(), VectorView< T >::end(), anonymous_namespace{Utm.h}::N, and gpu_enabled::upper_bound().

Referenced by ResultSet::calculateQuantile().

                                                               {
  if (centroids_.size()) {
    IndexType const N = partial_sum.back();
    RealType const x = q * N;
    auto const it1 = gpu_enabled::upper_bound(partial_sum.begin(), partial_sum.end(), x);
    if (it1 == partial_sum.begin()) {
      return firstCentroid(x);
    } else if (it1 == partial_sum.end()) {  // <==> 1 <= q
      return max();
    } else if (it1 + 1 == partial_sum.end()) {
      return lastCentroid(x, N);
    } else {
      return interiorCentroid(x, it1 - partial_sum.begin(), *it1);
    }
  } else {
    return centroids_.nan;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename RealType , typename IndexType = size_t>

DEVICE RealType quantile::detail::TDigest< RealType, IndexType >::quantile ( RealType const  q ) const

inline

Definition at line 296 of file quantile.h.

References quantile::detail::TDigest< RealType, IndexType >::buf_, quantile::detail::TDigest< RealType, IndexType >::centroids_, and quantile::detail::TDigest< RealType, IndexType >::quantile().

                                                   {
    return quantile({buf_.counts_.data(), centroids_.size()}, q);
  }

Here is the call graph for this function:

template<typename RealType , typename IndexType = size_t>

DEVICE RealType quantile::detail::TDigest< RealType, IndexType >::quantile ( )

inline

Definition at line 300 of file quantile.h.

References quantile::detail::TDigest< RealType, IndexType >::centroids_, and quantile::detail::TDigest< RealType, IndexType >::q_.

Referenced by quantile::detail::TDigest< RealType, IndexType >::quantile().

                             {
    return q_ ? quantile(*q_) : centroids_.nan;
  }

Here is the caller graph for this function:

template<typename RealType , typename IndexType = size_t>

DEVICE void quantile::detail::TDigest< RealType, IndexType >::setBuffer ( Memory &  mem )

inline

Definition at line 305 of file quantile.h.

References quantile::detail::TDigest< RealType, IndexType >::buf_, quantile::detail::CentroidsMemory< RealType, IndexType >::counts(), VectorView< T >::data(), quantile::detail::CentroidsMemory< RealType, IndexType >::size(), and quantile::detail::CentroidsMemory< RealType, IndexType >::sums().

                                     {
    buf_ = Centroids<RealType, IndexType>(
        mem.sums().data(), mem.counts().data(), mem.size());
    buf_.clear();
  }

Here is the call graph for this function:

template<typename RealType , typename IndexType = size_t>

DEVICE void quantile::detail::TDigest< RealType, IndexType >::setCentroids ( Memory &  mem )

inline

Definition at line 312 of file quantile.h.

References quantile::detail::TDigest< RealType, IndexType >::centroids_, quantile::detail::CentroidsMemory< RealType, IndexType >::counts(), VectorView< T >::data(), quantile::detail::CentroidsMemory< RealType, IndexType >::size(), and quantile::detail::CentroidsMemory< RealType, IndexType >::sums().

                                        {
    centroids_ = Centroids<RealType, IndexType>(
        mem.sums().data(), mem.counts().data(), mem.size());
    centroids_.clear();
  }

Here is the call graph for this function:

template<typename RealType , typename IndexType = size_t>

DEVICE void quantile::detail::TDigest< RealType, IndexType >::setCentroids ( VectorView< RealType > const  sums, VectorView< IndexType > const  counts  )

inline

Definition at line 318 of file quantile.h.

References quantile::detail::TDigest< RealType, IndexType >::centroids_.

                                                               {
    centroids_ = Centroids<RealType, IndexType>(sums, counts);
    centroids_.clear();
  }

template<typename RealType , typename IndexType >

DEVICE RealType quantile::detail::TDigest< RealType, IndexType >::slope ( IndexType const  idx1, IndexType const  idx2  ) const

private

Definition at line 883 of file quantile.h.

References quantile::detail::anonymous_namespace{quantile.h}::isSingleton(), and anonymous_namespace{Utm.h}::n.

                                                                          {
  IndexType const M = centroids_.size();
  if (idx1 == idx2) {  // Line segment is contained in either the first or last centroid.
    RealType const n = static_cast<RealType>(centroids_.counts_[idx1]);
    RealType const s = centroids_.sums_[idx1];
    return idx1 == 0 ? 2 * (s - n * min()) / ((n - 1) * (n - 1))
                     : 2 * (n * max() - s) / ((n - 1) * (n - 1));
  } else {
    bool const min1 = idx1 == 0;      // idx1 is the min centroid
    bool const max1 = idx1 == M - 1;  // idx1 is the max centroid
    bool const min2 = idx2 == 0;      // idx2 is the min centroid
    bool const max2 = idx2 == M - 1;  // idx2 is the max centroid
    RealType const n1 = static_cast<RealType>(centroids_.counts_[idx1] - min1 - max1);
    RealType const s1 = centroids_.sums_[idx1] - (min1 ? min() : max1 ? max() : 0);
    RealType const s2 = centroids_.sums_[idx2] - (min2 ? min() : max2 ? max() : 0);
    if (isSingleton(centroids_.counts_.begin() + idx2)) {
      return (idx1 < idx2 ? 2 : -2) * (n1 * s2 - s1) / (n1 * n1);
    } else {
      RealType const n2 = static_cast<RealType>(centroids_.counts_[idx2] - min2 - max2);
      return (idx1 < idx2 ? 2 : -2) * (n1 * s2 - n2 * s1) / (n1 * n2 * (n1 + n2));
    }
  }
}

Here is the call graph for this function:

template<typename RealType , typename IndexType = size_t>

DEVICE IndexType quantile::detail::TDigest< RealType, IndexType >::totalWeight ( ) const

inline

Definition at line 325 of file quantile.h.

References quantile::detail::TDigest< RealType, IndexType >::centroids_.

                                       {
    return centroids_.totalWeight();
  }

Member Data Documentation

template<typename RealType , typename IndexType = size_t>

Centroids<RealType, IndexType> quantile::detail::TDigest< RealType, IndexType >::buf_

private

Definition at line 188 of file quantile.h.

Referenced by quantile::detail::TDigest< RealType, IndexType >::operator=(), quantile::detail::TDigest< RealType, IndexType >::quantile(), and quantile::detail::TDigest< RealType, IndexType >::setBuffer().

template<typename RealType , typename IndexType = size_t>

IndexType quantile::detail::TDigest< RealType, IndexType >::buf_allocate_ {0}

private

Definition at line 200 of file quantile.h.

Referenced by quantile::detail::TDigest< RealType, IndexType >::operator=().

template<typename RealType , typename IndexType = size_t>

Centroids<RealType, IndexType> quantile::detail::TDigest< RealType, IndexType >::centroids_

private

Definition at line 189 of file quantile.h.

Referenced by quantile::detail::TDigest< RealType, IndexType >::centroids(), quantile::detail::TDigest< RealType, IndexType >::max(), quantile::detail::TDigest< RealType, IndexType >::mergeTDigest(), quantile::detail::TDigest< RealType, IndexType >::min(), quantile::detail::TDigest< RealType, IndexType >::operator=(), quantile::detail::TDigest< RealType, IndexType >::quantile(), quantile::detail::TDigest< RealType, IndexType >::setCentroids(), quantile::detail::TDigest< RealType, IndexType >::TDigest(), and quantile::detail::TDigest< RealType, IndexType >::totalWeight().

template<typename RealType , typename IndexType = size_t>

IndexType quantile::detail::TDigest< RealType, IndexType >::centroids_allocate_ {0}

private

Definition at line 201 of file quantile.h.

Referenced by quantile::detail::TDigest< RealType, IndexType >::operator=().

template<typename RealType , typename IndexType = size_t>

bool quantile::detail::TDigest< RealType, IndexType >::forward_ {true}

private

Definition at line 190 of file quantile.h.

Referenced by quantile::detail::TDigest< RealType, IndexType >::operator=().

template<typename RealType , typename IndexType = size_t>

bool quantile::detail::TDigest< RealType, IndexType >::merge_buffer_final_called_ {false}

private

Definition at line 194 of file quantile.h.

Referenced by quantile::detail::TDigest< RealType, IndexType >::operator=().

template<typename RealType , typename IndexType = size_t>

std::mutex quantile::detail::TDigest< RealType, IndexType >::merge_buffer_final_called_mutex_

private

Definition at line 192 of file quantile.h.

template<typename RealType , typename IndexType = size_t>

std::optional<RealType> quantile::detail::TDigest< RealType, IndexType >::q_ {std::nullopt}

private

Definition at line 197 of file quantile.h.

Referenced by quantile::detail::TDigest< RealType, IndexType >::operator=(), and quantile::detail::TDigest< RealType, IndexType >::quantile().

template<typename RealType , typename IndexType = size_t>

SimpleAllocator* quantile::detail::TDigest< RealType, IndexType >::simple_allocator_ {nullptr}

private

Definition at line 199 of file quantile.h.

Referenced by quantile::detail::TDigest< RealType, IndexType >::operator=().

template<typename RealType , typename IndexType = size_t>

bool quantile::detail::TDigest< RealType, IndexType >::use_linear_scaling_function_ {false}

private

Definition at line 198 of file quantile.h.

Referenced by quantile::detail::TDigest< RealType, IndexType >::operator=().

---

The documentation for this class was generated from the following file:

• /home/jenkins-slave/workspace/core-os-doxygen/Shared/quantile.h