Struct HyperLogLog8 

pub struct HyperLogLog8<T, H, const BETA: bool = true> { /* private fields */ }

Estimation logic implementing the HyperLogLog algorithm with byte-sized registers.

This implementation uses a full byte for each register instead of packed 5– or 6-bit registers. This approach trades 60% (for 5-bit registers) or 33.3% (for 6-bit registers) extra space with respect to HyperLogLog for:

• fast register access (byte indexing instead of bit-field extraction);
• no backend alignment constraints;
• SIMD-accelerated merge using platform-specific byte-wise maximum instructions (SSE2 on x86/x86_64, NEON on aarch64);
• no temporary allocations for merge operations.

The choice between the two logics should be guided by the specific use case and constraints of your application. Please try the included benchmarks to have an idea of the difference in performance between the two logics in your environment.

Instances are created through HyperLogLog8Builder:

// Default: LogLog-β correction enabled
let logic = HyperLogLog8Builder::new()
    .log2_num_regs(8)
    .build::<String>();

// Disable LogLog-β, use classic HLL + linear-counting fallback
let logic = HyperLogLog8Builder::new()
    .log2_num_regs(8)
    .beta::<false>()
    .build::<String>();

Type parameters

• T: the type of elements to count (must implement Hash).

• H: the BuildHasher used to hash elements.

• BETA: when true (the default), the LogLog-β bias correction is used during estimation. See HyperLogLog for details.

Implementations

impl<T, H: Clone, const BETA: bool> HyperLogLog8<T, H, BETA>

pub fn log2_num_regs(&self) -> u32

Returns the base-2 logarithm of the number of registers per estimator.

Trait Implementations

impl<T, H: Clone, const BETA: bool> Clone for HyperLogLog8<T, H, BETA>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug, H: Debug, const BETA: bool> Debug for HyperLogLog8<T, H, BETA>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T, H, const BETA: bool> Display for HyperLogLog8<T, H, BETA>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Hash, H: BuildHasher + Clone, const BETA: bool> EstimationLogic for HyperLogLog8<T, H, BETA>

type Item = T

The type of items.

type Backend = [u8]

The type of the backend.

type Estimator<'a> = DefaultEstimator<HyperLogLog8<T, H, BETA>, &'a HyperLogLog8<T, H, BETA>, Box<[u8]>> where T: 'a, H: 'a

The type of an estimator.

fn new_estimator(&self) -> Self::Estimator<'_>

Creates a new empty estimator using this logic.

fn add(&self, backend: &mut Self::Backend, element: impl Borrow<T>)

Adds an element to an estimator with the given backend.

fn estimate(&self, backend: &[u8]) -> f64

Returns an estimation of the number of distinct elements that have been added to an estimator with the given backend so far.

fn clear(&self, backend: &mut [u8])

Clears a backend, making it empty.

fn set(&self, dst: &mut [u8], src: &[u8])

Sets the contents of dst to the contents of src.

impl<T: Hash, H: BuildHasher + Clone, const BETA: bool> MergeEstimationLogic for HyperLogLog8<T, H, BETA>

type Helper = ()

The type of the helper used in merge calculations.

fn new_helper(&self) -> Self::Helper

Creates a new helper to use in merge operations.

fn merge_with_helper( &self, dst: &mut [u8], src: &[u8], _helper: &mut Self::Helper, )

Merges src into dst using the provided helper to avoid allocations.

fn merge(&self, dst: &mut Self::Backend, src: &Self::Backend)

Merges src into dst.

impl<T: PartialEq, H: PartialEq, const BETA: bool> PartialEq for HyperLogLog8<T, H, BETA>

fn eq(&self, other: &HyperLogLog8<T, H, BETA>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Hash, H: BuildHasher + Clone, const BETA: bool> SliceEstimationLogic<u8> for HyperLogLog8<T, H, BETA>

fn backend_len(&self) -> usize

The number of elements of type T in a backend.

impl<T, H, const BETA: bool> StructuralPartialEq for HyperLogLog8<T, H, BETA>