Struct Registers 

struct Registers<B: Bucket> {
    registers: Box<[B]>,
    initial_count: i64,
}

Approximates the count of non-null rows using a modified version of the HyperLogLog algorithm. Each Bucket stores a count of how many hash values have x trailing zeroes for all x from 1-64. This allows the algorithm to support insertion and deletion, but uses up more memory and limits the number of rows that can be counted.

This can count up to a total of 2^64 unduplicated rows.

The estimation error for HyperLogLog is 1.04/sqrt(num of registers). With 2^16 registers this is ~1/256, or about 0.4%. The memory usage for the default choice of parameters is about (1024 + 24) bits * 2^16 buckets, which is about 8.58 MB.

Fields

registers: Box<[B]>

initial_count: i64

Implementations

impl<B: Bucket> Registers<B>

fn update(&mut self, scalar_ref: ScalarRefImpl<'_>, retract: bool) -> Result<()>

Adds the count of the datum’s hash into the register, if it is greater than the existing count at the register

fn get_hash(&self, scalar: ScalarRefImpl<'_>) -> u64

Calculate the hash of the scalar using Rust’s default hasher Perhaps a different hash like Murmur2 could be used instead for optimization?

fn count_hash(&self, hash: u64) -> u8

Counts the number of trailing zeroes plus 1 in the non-index bits of the hash

fn calculate_result(&self) -> i64

Calculates the bias-corrected harmonic mean of the registers to get the approximate count

Trait Implementations

impl<B: Clone + Bucket> Clone for Registers<B>

fn clone(&self) -> Registers<B>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<B: Debug + Bucket> Debug for Registers<B>

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

Formats the value using the given formatter.

impl<B: Bucket> Default for Registers<B>

fn default() -> Self

Returns the “default value” for a type.

impl<B: Bucket> EstimateSize for Registers<B>

fn estimated_heap_size(&self) -> usize

The estimated heap size of the current struct in bytes.

fn estimated_size(&self) -> usize

where Self: Sized,

The estimated total size of the current struct in bytes, including the estimated_heap_size and the size of Self.

impl<B: Bucket> From<Registers<B>> for i64

fn from(reg: Registers<B>) -> Self

Converts to this type from the input type.

impl<B: PartialEq + Bucket> PartialEq for Registers<B>

fn eq(&self, other: &Registers<B>) -> 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<B: Bucket> AggStateDyn for Registers<B>

impl<B: Eq + Bucket> Eq for Registers<B>

impl<B: Bucket> StructuralPartialEq for Registers<B>