Struct hyperloglog_rs::serde::HyperLogLogArray

#[repr(transparent)]
pub struct HyperLogLogArray<const PRECISION: usize, const BITS: usize, const N: usize> { /* private fields */ }

Implementations

impl<const PRECISION: usize, const BITS: usize, const N: usize> HyperLogLogArray<PRECISION, BITS, N>

pub fn new() -> Self

Creates a new HyperLogLogArray with the given precision and number of bits.

Example

#![feature(generic_const_exprs)]
use hyperloglog_rs::prelude::*;

let hll_array = HyperLogLogArray::<12, 6, 3>::new();

pub fn estimate_overlap_cardinalities(&self, other: &Self) -> [[f32; N]; N]

Returns the estimated overlap cardinality matrices with the provided HyperLogLogArray.

Arguments

• other: The HyperLogLogArray to estimate the overlap cardinality matrices with.

Returns

The estimated overlap cardinality matrices with the provided HyperLogLogArray.

pub fn estimated_difference_cardinality_vector( &self, other: &HyperLogLog<PRECISION, BITS> ) -> [f32; N]

Returns the estimated difference cardinality matrices with the provided HyperLogLog.

Arguments

• other: The HyperLogLog to estimate the difference cardinality matrices with.

Returns

The estimated difference cardinality matrices with the provided HyperLogLogArray.

pub fn estimated_overlap_and_differences_cardinality_matrices( &self, other: &Self ) -> ([[f32; N]; N], [f32; N], [f32; N])

Returns the estimated overlap and difference cardinality matrices and vectors with the provided HyperLogLogArray.

Arguments

• other: The HyperLogLogArray to estimate the overlap and difference cardinality matrices and vectors with.

Returns

The estimated overlap and difference cardinality matrices and vectors with the provided HyperLogLogArray.

Trait Implementations

impl<const PRECISION: usize, const BITS: usize, const N: usize> AsMut<[HyperLogLog<PRECISION, BITS>; N]> for HyperLogLogArray<PRECISION, BITS, N>

fn as_mut(&mut self) -> &mut [HyperLogLog<PRECISION, BITS>; N]

Returns a mutable reference to the underlying array of HyperLogLog counters.

Returns

A mutable reference to the underlying array of HyperLogLog counters.

impl<const PRECISION: usize, const BITS: usize, const N: usize> AsRef<[HyperLogLog<PRECISION, BITS>; N]> for HyperLogLogArray<PRECISION, BITS, N>

fn as_ref(&self) -> &[HyperLogLog<PRECISION, BITS>; N]

Returns a reference to the underlying array of HyperLogLog counters.

Returns

A reference to the underlying array of HyperLogLog counters.

impl<const PRECISION: usize, const BITS: usize, const N: usize> Clone for HyperLogLogArray<PRECISION, BITS, N>

fn clone(&self) -> HyperLogLogArray<PRECISION, BITS, N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const PRECISION: usize, const BITS: usize, const N: usize> Debug for HyperLogLogArray<PRECISION, BITS, N>

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

Formats the value using the given formatter.

impl<const PRECISION: usize, const BITS: usize, const N: usize> Default for HyperLogLogArray<PRECISION, BITS, N>

fn default() -> Self

Creates a new HyperLogLogArray with the given precision and number of bits.

Returns

A new HyperLogLogArray with the given precision and number of bits.

Example

#![feature(generic_const_exprs)]
use hyperloglog_rs::prelude::*;

let hll_array = HyperLogLogArray::<12, 6, 3>::default();

impl<'de, const PRECISION: usize, const BITS: usize, const N: usize> Deserialize<'de> for HyperLogLogArray<PRECISION, BITS, N>

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserializes the HyperLogLog counter using the given deserializer.

This method is part of the Deserialize trait implementation for the HyperLogLog struct, allowing the counter to be deserialized from a format supported by the deserializer.

Arguments

• deserializer: The deserializer used to deserialize the HyperLogLog counter.

Returns

The deserialization result, indicating success or failure.

impl<const PRECISION: usize, const BITS: usize, const N: usize> Index<usize> for HyperLogLogArray<PRECISION, BITS, N>

fn index(&self, index: usize) -> &Self::Output

Returns a reference to the HyperLogLog counter at the given index.

Arguments

• index: The index of the HyperLogLog counter to return.

Returns

A reference to the HyperLogLog counter at the given index.

Panics

Panics if the index is out of bounds.

Example

#![feature(generic_const_exprs)]
use hyperloglog_rs::prelude::*;

let mut hll_array = HyperLogLogArray::<12, 6, 4>::new();
hll_array[0].insert(&1);
hll_array[1].insert(&2);
hll_array[2].insert(&3);

assert!(hll_array[0].estimate_cardinality() > 0.9
    && hll_array[1].estimate_cardinality() < 1.1
);
assert!(hll_array[1].estimate_cardinality() > 0.9
   && hll_array[1].estimate_cardinality() < 1.1
);
assert!(hll_array[2].estimate_cardinality() > 0.9
  && hll_array[2].estimate_cardinality() < 1.1
);
assert!(hll_array[3].estimate_cardinality() > -0.1
 && hll_array[3].estimate_cardinality() < 0.1
);

type Output = HyperLogLog<PRECISION, BITS>

The returned type after indexing.

impl<const PRECISION: usize, const BITS: usize, const N: usize> IndexMut<usize> for HyperLogLogArray<PRECISION, BITS, N>

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Returns a mutable reference to the HyperLogLog counter at the given index.

Arguments

• index: The index of the HyperLogLog counter to return.

Returns

A mutable reference to the HyperLogLog counter at the given index.

Panics

Panics if the index is out of bounds.

Example

#![feature(generic_const_exprs)]
use hyperloglog_rs::prelude::*;

let mut hll_array = HyperLogLogArray::<12, 6, 4>::new();
hll_array[0].insert(&1);
hll_array[1].insert(&2);
hll_array[2].insert(&3);

assert!(hll_array[0].estimate_cardinality() > 0.9
   && hll_array[1].estimate_cardinality() < 1.1
);
assert!(hll_array[1].estimate_cardinality() > 0.9
 && hll_array[1].estimate_cardinality() < 1.1
);
assert!(hll_array[2].estimate_cardinality() > 0.9
&& hll_array[2].estimate_cardinality() < 1.1
);
assert!(hll_array[3].estimate_cardinality() > -0.1
&& hll_array[3].estimate_cardinality() < 0.1
);

impl<const PRECISION: usize, const BITS: usize, const N: usize> PartialEq<HyperLogLogArray<PRECISION, BITS, N>> for HyperLogLogArray<PRECISION, BITS, N>

fn eq(&self, other: &HyperLogLogArray<PRECISION, BITS, N>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<const PRECISION: usize, const BITS: usize, const N: usize> Serialize for HyperLogLogArray<PRECISION, BITS, N>

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serializes the HyperLogLog counter using the given serializer.

This method is part of the Serialize trait implementation for the HyperLogLog struct, allowing the counter to be serialized into a format supported by the serializer.

Arguments

• serializer: The serializer used to serialize the HyperLogLog counter.

Returns

The serialization result, indicating success or failure.

Example

In this example, we serialize an array of HyperLogLog counters into a JSON string. The resulting string is then deserialized back into an array of HyperLogLog counters.

Since we cannot implement these traits for array, we need to wrap the array in a struct, which in this case is HyperLogLogArray.

#![feature(generic_const_exprs)]
use serde::Serialize;
use serde_json::Serializer;
use hyperloglog_rs::prelude::*;

let mut hll_array = HyperLogLogArray::<12, 6, 3>::new();
hll_array[0].insert(&1);
hll_array[1].insert(&2);
hll_array[2].insert(&3);
let mut serializer = Serializer::new(Vec::new());
let result = hll_array.serialize(&mut serializer);
assert!(result.is_ok(), "Serialization failed, error: {:?}", result.err());
let hll_array_str = String::from_utf8(serializer.into_inner()).unwrap();
let hll_array_deserialized = serde_json::from_str(&hll_array_str);
assert!(hll_array_deserialized.is_ok(), "Deserialization failed, error: {:?}", hll_array_deserialized.err());
let hll_array_deserialized = hll_array_deserialized.unwrap();
assert_eq!(hll_array, hll_array_deserialized, "Deserialized array does not match original array");

impl<const PRECISION: usize, const BITS: usize, const N: usize> Copy for HyperLogLogArray<PRECISION, BITS, N>

impl<const PRECISION: usize, const BITS: usize, const N: usize> Eq for HyperLogLogArray<PRECISION, BITS, N>

impl<const PRECISION: usize, const BITS: usize, const N: usize> StructuralEq for HyperLogLogArray<PRECISION, BITS, N>

impl<const PRECISION: usize, const BITS: usize, const N: usize> StructuralPartialEq for HyperLogLogArray<PRECISION, BITS, N>